## db/migrate/001_create_messages.rb

class CreateMessages < ActiveRecord::Migration

  def self.up
    create_table :messages, :force => true do |t|
      t.column "sender_id",     :integer, :null => false
      t.column "receiver_id",   :integer, :null => false
      t.column "subject", :string, :null => false
      t.column "body", :text
      t.column "created_at",  :datetime
      t.column "read_at", :datetime
      t.column "sender_deleted", :boolean
      t.column "receiver_deleted", :boolean
      t.column "sender_purged", :boolean
      t.column "receiver_purged", :boolean
    end
    add_index(:messages, "sender_id")
    add_index(:messages, "receiver_id")
  end

  def self.down
    drop_table :messages
  end

end

## app/models/message.rb

class Message < ActiveRecord::Base
  belongs_to :sender,
             :foreign_key => 'sender_id',
             :class_name => 'User'

  belongs_to :receiver,
             :foreign_key => 'receiver_id',
             :class_name => 'User'

  acts_as_textiled :body

  validates_presence_of :subject, :body

  cattr_reader :per_page
  @@per_page = 10

  def read?
    !self.read_at.nil?
  end

end

## app/controllers/messages_controller.rb

class MessagesController < ApplicationController
  before_filter :login_required, :find_user_and_message
  before_filter :protect_message, :except => [:new, :create]

  tab :hub
  tab :community, :only => :new

  def index
    @messages = @user.received_messages.paginate :page => params[:page]
  end

  def sent
    @messages = @user.sent_messages.paginate :page => params[:page]
  end

  def show
    if current_user == @message.receiver
      @message.read_at = Time.now
      @message.save
    end
  end

  def new
    @message = Message.new
  end

  def reply
    @old_message = @message
    @old_message.textiled = false
    @message = Message.new
    @message.receiver_id = @old_message.sender_id
    @message.subject = "RE: #{@old_message.subject}"
    @message.textiled = false
    @message.body = ""
    @message.body += "\r\n\r\n\r\n--------------------"
    @message.body += "\r\nReceived from #{@old_message.sender.full_name} at #{@old_message.created_at}"
    @message.body += "\r\n\r\n#{@old_message.body}"
    render :action => 'new'
  end

  def create
    message = Message.new(params[:message])
    recipient = message.receiver || @user
    current_user.send_message(recipient, message)
    respond_to do |format|
      format.html do
        flash[:notice] = 'Message Sent'
        redirect_to messages_path(current_user)
        false;
      end
    end
  rescue ActiveRecord::RecordInvalid
    render :action => 'new'
  end

  def destroy

  end

  private

  def find_user_and_message
    @user = User.find(params[:user_id])
    @message = params[:id].nil? ? nil : @message = Message.find(params[:id])
  end

  def protect_message
    unless @user == current_user || @message && @user == @message.sender || @message && @user == @message.receiver
      flash[:error] = "You don't have permission to see that page!"
      redirect_to hub_url
      return false
    end
  end

end

## app/models/user.rb

  has_many :messages_as_sender,   :foreign_key => 'sender_id',    :class_name => 'Message', :order => 'created_at DESC'
  has_many :messages_as_receiver, :foreign_key => 'receiver_id',  :class_name => 'Message', :order => 'created_at DESC'
  has_many :unread_messages,      :foreign_key => 'receiver_id',  :class_name => 'Message', :conditions => 'read_at IS NULL', :order => 'created_at DESC'
  has_many :read_messages,        :foreign_key => 'receiver_id',  :class_name => 'Message', :conditions => 'read_at IS NOT NULL', :order => 'created_at DESC'

  # Alias for all received messages
  def received_messages
    self.messages_as_receiver
  end

  # Alias for all sent messages
  def sent_messages
    self.messages_as_sender
  end

  # Alias for unread messages
  def new_messages
    self.unread_messages
  end

  # Alias for read messages
  def old_messages
    self.read_messages
  end

  # Accepts a message object and flags the message as deleted by sender
  def delete_from_sent(message)
    if message.sender_id == self.id
      message.update_attribute :sender_deleted, true
      return true
    else
      return false
    end
  end

  # Accepts a message object and flags the message as deleted by the sender
  def delete_from_received(message)
    if message.receiver_id == self.id
      message.update_attribute :receiver_deleted, true
      return true
    else
      return false
    end
  end

  # Accepts a user object as the receiver, and a message
  # and creates a message relationship joining the two users
  def send_message(receiver, message)
    Message.create!(:sender => self, :receiver => receiver, :subject => message.subject, :body => message.body)
  end

## config/routes.rb

  # User resources
  map.resources :users, :member => { :change_email => :put, :change_password => :put } do |user|
    ...
    user.resources :messages, :collection => { :sent => :get }, :member => { :reply => :get }
  end