private_mail 0.0.1

data/lib/generators/private_mail/install/install_generator.rb

@@ -0,0 +1,37 @@
+require 'rails/generators/migration'
+
+module PrivateMail
+
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      include Rails::Generators::Migration
+      
+      source_root File.expand_path('../templates', __FILE__)
+      desc "add the migrations"
+
+      def self.next_migration_number(path)
+        unless @prev_migration_nr
+          @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+        else
+          @prev_migration_nr += 1
+        end
+        @prev_migration_nr.to_s
+      end
+
+      def copy_migrations        
+        migration_template "create_conversations.rb", "db/migrate/create_conversations.rb"
+        migration_template "create_messages.rb", "db/migrate/create_messages.rb"
+        migration_template "create_messages_recipients.rb", "db/migrate/create_messages_recipients.rb"
+        migration_template "create_mail.rb", "db/migrate/create_mail.rb"
+      end
+
+      def copy_models
+          copy_file "../models/mail.rb", "app/models/mail.rb"
+          copy_file "../models/message.rb", "app/models/message.rb"
+          copy_file "../models/conversation.rb", "app/models/conversation.rb"
+      end
+
+    end
+  end
+
+end

data/lib/generators/private_mail/install/models/conversation.rb

@@ -0,0 +1,56 @@
+class Conversation < ActiveRecord::Base
+  attr_reader :originator, :original_message, :last_sender, :last_message, :users
+  has_many :messages
+  has_many :mails
+  before_create :clean
+  #looks like shit but isnt too bad
+  #has_many :users, :through :messages, :source => :recipients, :uniq => true doesnt work due to recipients being a habtm association
+  has_many :recipients, :class_name => 'User', :finder_sql => 
+    'SELECT users.* FROM conversations 
+    INNER JOIN messages ON conversations.id = messages.conversation_id 
+    INNER JOIN messages_recipients ON messages_recipients.message_id = messages.id 
+    INNER JOIN users ON messages_recipients.recipient_id = users.id
+    WHERE conversations.id = #{self.id} GROUP BY users.id;'
+  
+  #originator of the conversation.
+  def originator()
+    @orignator = self.original_message.sender if @originator.nil?
+    return @orignator
+  end
+  
+  #first message of the conversation.
+  def original_message()
+    @original_message = self.messages.find(:first, :order => 'created_at') if @original_message.nil?
+    return @original_message
+  end
+  
+  #sender of the last message.
+  def last_sender()
+     @last_sender = self.last_message.sender if @last_sender.nil?
+    return @last_sender
+  end
+  
+  #last message in the conversation.
+  def last_message()
+    @last_message = self.messages.find(:first, :order => 'created_at DESC') if @last_message.nil?
+    return @last_message
+  end
+  
+  #all users involved in the conversation.
+  def users()
+    if(@users.nil?)
+      @users = self.recipients.clone
+      @users << self.originator unless @users.include?(self.originator) 
+    end
+    return @users
+  end
+  
+  protected
+  #[empty method]
+  #
+  #this gets called before_create. Implement this if you wish to clean out illegal content such as scripts or anything that will break layout. This is left empty because what is considered illegal content varies.
+  def clean()
+    return if(subject.nil?)
+    #strip all illegal content here. (scripts, shit that will break layout, etc.)
+  end
+end

data/lib/generators/private_mail/install/models/mail.rb

@@ -0,0 +1,16 @@
+class Mail < ActiveRecord::Base
+  self.table_name = "mail"
+  belongs_to :message
+  belongs_to :user
+  belongs_to :conversation
+  
+  #sets the read attribute of the mail message to true.
+  def mark_as_read()
+    update_attribute('read', true)
+  end
+  
+  #sets the read attribute of the mail message to false.
+  def mark_as_unread()
+    update_attribute('read', false)
+  end
+end

data/lib/generators/private_mail/install/models/message.rb

@@ -0,0 +1,39 @@
+class Message < ActiveRecord::Base
+  #any additional info that needs to be sent in a message (ex. I use these to determine request types)
+  serialize :headers
+  
+  class_inheritable_accessor :on_deliver_callback
+  protected :on_deliver_callback
+  
+  belongs_to :sender, :class_name => 'User', :foreign_key => 'sender_id'
+  belongs_to :conversation
+  has_and_belongs_to_many :recipients, :class_name => 'User', :join_table => 'messages_recipients', :association_foreign_key => 'recipient_id'
+  
+  #delivers a message to the the given mailbox of all recipients, calls the on_deliver_callback if initialized.
+  #
+  #====params:
+  #mailbox_type:: the mailbox to send the message to
+  #clean:: calls the clean method if this is set (must be implemented)
+  #
+  def deliver(mailbox_type, clean = true)
+    clean() if clean
+    self.save()
+    self.recipients.each do |r|
+      r.mailbox[mailbox_type] << self
+    end
+    self.on_deliver_callback.call(self, mailbox_type) unless self.on_deliver_callback.nil?
+  end
+  
+  #sets the on_deliver_callback to the passed method. The method call should expect 2 params (message, mailbox_type).
+  def Message.on_deliver(method)
+    self.on_deliver_callback = method
+  end
+  
+  protected
+  #[empty method]
+  #
+  #this gets called when a message is delivered and the clean param is set (default). Implement this if you wish to clean out illegal content such as scripts or anything that will break layout. This is left empty because what is considered illegal content varies.
+  def clean()
+    #strip all illegal content here. (scripts, shit that will break layout, etc.)
+  end
+end

data/lib/generators/private_mail/install/templates/create_conversations.rb

@@ -0,0 +1,12 @@
+class CreateConversations < ActiveRecord::Migration
+  def self.up
+    create_table :conversations do |t|
+      t.column :subject, :string, :default => ""
+      t.column :created_at, :datetime, :null => false
+    end
+  end
+
+  def self.down
+    drop_table :conversations
+  end
+end

data/lib/generators/private_mail/install/templates/create_mail.rb

@@ -0,0 +1,18 @@
+class CreateMail < ActiveRecord::Migration
+  def self.up
+    create_table :mail do |t|
+      t.column :user_id, :integer, :null => false
+      t.column :message_id, :integer, :null => false
+      t.column :conversation_id, :integer
+      t.column :read, :boolean, :default => false
+      t.column :trashed, :boolean, :default => false
+      t.column :mailbox, :string, :limit => 25
+      t.column :created_at, :datetime, :null => false
+    end
+    #i use foreign keys but its a custom method, so i'm leaving it up to you want them.
+  end
+
+  def self.down
+    drop_table :mail
+  end
+end

data/lib/generators/private_mail/install/templates/create_messages.rb

@@ -0,0 +1,18 @@
+class CreateMessages < ActiveRecord::Migration
+  def self.up
+    create_table :messages do |t|
+      t.column :body, :text
+      t.column :subject, :string, :default => ""
+      t.column :headers, :text
+      t.column :sender_id, :integer, :null => false
+      t.column :conversation_id, :integer
+      t.column :sent, :boolean, :default => false
+      t.column :created_at, :datetime, :null => false
+    end
+    #i use foreign keys but its a custom method, so i'm leaving it up to you if you want them.
+  end
+
+  def self.down
+    drop_table :messages
+  end
+end

data/lib/generators/private_mail/install/templates/create_messages_recipients.rb

@@ -0,0 +1,13 @@
+class CreateMessagesRecipients < ActiveRecord::Migration
+  def self.up
+    create_table :messages_recipients, :id => false do |t|
+      t.column :message_id, :integer, :null => false
+      t.column :recipient_id, :integer, :null => false
+    end
+    #i use foreign keys but its a custom method, so i'm leaving it up to you want them.
+  end
+
+  def self.down
+    drop_table :messages_recipients
+  end
+end

data/lib/mailbox.rb

@@ -0,0 +1,343 @@
+module PrivateMail
+  
+  class Mailbox
+    #this is used to filter mail by mailbox type, use the [] method rather than setting this directly.
+    attr_accessor :type
+    #the user/owner of this mailbox, set when initialized.
+    attr_reader :user
+
+    #creates a new Mailbox instance with the given user and optional type.
+    def initialize(user, type = :all)
+      @user = user
+      @type = type
+    end
+
+    #sets the mailbox type to the symbol corresponding to the given val.
+    def type=(val)
+      @type = val.to_sym
+    end
+
+    #returns a count of mail messages filtered by type and filter, if set.
+    #
+    #*this performs an actual sql count rather than selecting all mail and then gettin a length on the array... not a big deal but this could be something that is checked often to notify the user when they receive a new mail.
+    #
+    #====params:
+    #filter:: filters the count by the 'read' attribute.
+    #* :all - count of both read and unread mail.
+    #* :read - count of read mail.
+    #* :unread - count of unread mail.
+    #options:: see mail for acceptable options.
+    #
+    #====returns:
+    #number of mail messages
+    #
+    #====example:
+    #   phil = User.find(3123)
+    #
+    #   #get number of unread mail messages in phil's inbox
+    #   phil.mailbox[:inbox].mail_count(:unread)
+    #
+    def mail_count(filter = :all, options = {})
+      default_options = {:conditions => ["mail.user_id = ?", @user.id]}
+      add_mailbox_condition!(default_options, @type)
+      add_conditions!(default_options, "mail.read = ?", filter == :read) unless filter == :all
+      return count_mail(default_options, options)
+    end
+
+    #returns an array of all Mail for the user filtered by type, if set. 
+    #
+    #====params:
+    #options:: all valid find options are accepted as well as an additional conversation option.
+    #* :conversation - Conversation object to filter mail only belonging to this conversation.
+    #* :conditions - same as find conditions however the array version of conditions will not work, i.e., :conditions => ['mail.read = ?', false] will not work here.
+    #* all other find options will work as expected.
+    # 
+    #====returns:
+    #array of Mail.
+    #
+    #====example:
+    #   phil = User.find(3123)
+    #
+    #   #get all mail messages belonging to phil
+    #   phil.mailbox.mail
+    #
+    #   #get all mail messages in phil's inbox associated with conversation 23
+    #   phil.mailbox[:inbox].mail(:conversation => Conversation.find(23)) 
+    #
+    #   #get all unread mail messages belonging to phil associated with conversation 23
+    #   phil.mailbox.mail(:conversation => Conversation.find(23), :conditions => 'mail.read = false')
+    #
+    def mail(options = {})
+      default_options = {}
+      add_mailbox_condition!(default_options, @type)
+      return get_mail(default_options, options)
+    end
+
+    #returns an array of unread Mail for the user filtered by type, if set. 
+    #
+    #====params:
+    #options:: see mail for acceptable options.
+    # 
+    #====returns:
+    #array of Mail.
+    #
+    #====example:
+    #   phil = User.find(3123)
+    #
+    #   #get all unread mail in phil's inbox
+    #   phil.mailbox[:inbox].unread_mail
+    #
+    def unread_mail(options = {})
+      default_options = {:conditions => ["mail.read = ?", false]}
+      add_mailbox_condition!(default_options, @type)
+      return get_mail(default_options, options)
+    end
+
+    #returns an array of read Mail for the user filtered by type, if set. 
+    #
+    #====params:
+    #options:: see mail for acceptable options.
+    # 
+    #====returns:
+    #array of Mail.
+    #
+    #====example:
+    #   phil = User.find(3123)
+    #
+    #   #get all read mail in phil's inbox
+    #   phil.mailbox[:inbox].read_mail
+    #
+    def read_mail(options = {})
+      default_options = {:conditions => ["mail.read = ?", true]}
+      add_mailbox_condition!(default_options, @type)
+      return get_mail(default_options, options)
+    end
+
+    #returns an array of the latest Mail message for each conversation the user is involved in filtered by type, if set. 
+    #
+    #*possible use for this would be an inbox view of your mail so you can easily see the status of all the convos your involved in.
+    #
+    #====params:
+    #options:: see mail for acceptable options.
+    # 
+    #====returns:
+    #array of Mail.
+    #
+    #====example:
+    #   phil = User.find(3123)
+    #
+    #   #get a list of the latest received mail for each conversation
+    #   phil.mailbox[:inbox].latest_mail
+    #
+    def latest_mail(options = {})
+      return only_latest(mail(options))
+    end
+
+    #adds a mail message to the user's mailbox specified by type.
+    #
+    #*this is used when sending a new message, all the recipients get a mail added to their inbox and the sender gets a mail in their sentbox.
+    #
+    #====params:
+    #msg:: 
+    #     Message object from which a new mail is created from.
+    # 
+    #====returns:
+    #new Mail.
+    #
+    def add(msg)
+      attributes = {:message => msg, :conversation => msg.conversation}
+      attributes[:mailbox] = @type.to_s unless @type == :all
+      attributes[:read] = msg.sender.id == @user.id
+      mail_msg = Mail.new(attributes)
+      @user.mail << mail_msg
+      return mail_msg
+    end
+
+    #marks all the mail messages matched by the options and type as read.
+    #
+    #====params:
+    #options:: see mail for acceptable options.
+    # 
+    #====returns:
+    #array of Mail.
+    #
+    #====example:
+    #   phil = User.find(3123)
+    #
+    #   #mark all inbox messages as read
+    #   phil.mailbox[:inbox].mark_as_read()
+    #
+    def mark_as_read(options = {})
+      default_options = {}
+      add_mailbox_condition!(default_options, @type)
+      return update_mail("mail.read = true", default_options, options)
+    end
+
+    #marks all the mail messages matched by the options and type as unread, except for sent messages.
+    #
+    #====params:
+    #options:: see mail for acceptable options.
+    # 
+    #====returns:
+    #array of Mail.
+    #
+    #====example:
+    #   phil = User.find(3123)
+    #
+    #   #mark all inbox messages as unread
+    #   phil.mailbox[:inbox].mark_as_unread()
+    #
+    def mark_as_unread(options = {})
+      default_options = {:conditions => ["mail.mailbox != ?",@user.mailbox_types[:sent].to_s]}
+      add_mailbox_condition!(default_options, @type)
+      return update_mail("mail.read = false", default_options, options)
+    end
+
+    #moves all mail matched by the options to the given mailbox. sent messages stay in the sentbox.
+    #
+    #====params:
+    #mailbox:: the mailbox_type to move the mail messages to. (ex. :inbox, :trash)
+    #options:: see mail for acceptable options.
+    # 
+    def move_to(mailbox, options = {})
+      mailbox = mailbox.to_sym
+      trash = mailbox == @user.mailbox_types[:deleted].to_sym
+      default_options = {}
+      add_mailbox_condition!(default_options, @type)
+      if(!trash)
+        #conditional update because sentmail is always sentmail - I believe case if the most widely supported conditional, mysql also has an if which would work as well but i think mysql is the only one to support it
+        return update_mail("mail.trashed = false, mail.mailbox = 
+        CASE mail.mailbox
+          WHEN '#{@user.mailbox_types[:sent].to_s}' THEN mail.mailbox
+          ELSE '#{mailbox.to_s}'
+        END", default_options, options)
+      end
+      return update_mail("mail.trashed = true", default_options, options)
+    end
+
+    #permanantly deletes all the mail messages matched by the options. Use move_to(:trash) instead if you want to send to user's trash without deleting.
+    #
+    #====params:
+    #options:: see mail for acceptable options.
+    # 
+    def delete(options = {})
+      default_options = {:conditions => ["mail.user_id = ?", @user.id]}
+      add_mailbox_condition!(default_options, @type)
+      return delete_mail(default_options, options)
+    end
+
+    #alias for add
+    def <<(msg)
+      return self.add(msg)
+    end
+
+    #deletes all messages that have been trashed and match the options if passed.
+    #
+    #====params:
+    #options:: see mail for acceptable options.
+    # 
+    def empty_trash(options = {})
+      default_options = {:conditions => ["mail.user_id = ? AND mail.trashed = ?", @user.id, true]}
+      add_mailbox_condition!(default_options, @type)
+      return delete_mail(default_options, options)
+    end
+
+    #return true if the user is involved in the given conversation.
+    def has_conversation?(conversation)
+      return mail_count(:all, :conversation => conversation) != 0
+    end
+
+    #sets the mailbox type and returns itself.
+    #
+    #====params:
+    #mailbox_type::
+    #     type of mailbox to filter mail by, this can be anything, but the three most likely values for this will be the received, sent, and trash values set within the acts_as_messageable method.
+    # 
+    #====returns:
+    #self
+    #
+    #====example:
+    #   phil = User.find(3123)
+    #
+    #   #all mails in the user's inbox
+    #   phil.mailbox[:inbox].mail
+    #
+    def [](mailbox_type)
+      self.type = mailbox_type
+      return self
+    end
+
+    private
+
+    def get_mail(default_options, options)
+      build_options(default_options, options) unless options.empty?
+      return @user.mail.find(:all, default_options)
+    end
+
+    def update_mail(updates, default_options, options)
+      build_options(default_options, options) unless options.empty?
+      return @user.mail.update_all(updates, default_options[:conditions])
+    end
+
+    def delete_mail(default_options, options)
+      build_options(default_options, options) unless options.empty?
+      return Mail.delete_all(default_options[:conditions])
+    end
+
+    def count_mail(default_options, options)
+      build_options(default_options, options) unless options.empty?
+      return Mail.count(:all, default_options)
+    end
+
+    def build_options(default_options, options)
+      add_conversation_condition!(default_options, options[:conversation]) unless options[:conversation].nil?
+      options.delete(:conversation)
+      add_conditions!(default_options, options[:conditions]) unless options[:conditions].nil?
+      options.delete(:conditions)
+      default_options.merge!(options)
+    end
+
+    def only_latest(mail)
+      convos = []
+      latest = []
+      mail.each do |m|
+        next if(convos.include?(m.conversation_id))
+        convos << m.conversation_id
+        latest << m
+      end
+      return latest
+    end
+
+    def add_mailbox_condition!(options, mailbox_type)
+      return if mailbox_type == :all
+      return add_conditions!(options, "mail.mailbox = ? AND mail.trashed = ?", mailbox_type.to_s, false) unless mailbox_type == @user.mailbox_types[:deleted]
+      return add_conditions!(options, "mail.trashed = ?", true)
+    end
+
+    def add_conversation_condition!(options, conversation)
+      options.merge!({:order => 'created_at ASC'})
+      if(conversation.is_a?(Array))
+        conversation.map! {|c| c.is_a?(Integer) ? c : c.id}
+      else
+        conversation = conversation.is_a?(Integer) ? [conversation] : [conversation.id]
+      end
+      return add_conditions!(options, "conversation_id IN (?)", conversation)
+    end
+
+    def add_conditions!(options, conditions, *values)
+      return nil unless options.is_a?(Hash)
+      if(options[:conditions].nil?)
+        options[:conditions] = values.length == 0 ? conditions : [conditions]
+      elsif(options[:conditions].is_a?(Array))
+        options[:conditions][0] = "(#{options[:conditions][0]}) AND (#{conditions})"
+      else
+        options[:conditions] = "(#{options[:conditions]}) AND (#{conditions})"
+      end
+      values.each do |val|
+          options[:conditions].push(val)
+      end
+      return options
+    end
+
+  end
+end

data/lib/private_mail/version.rb

@@ -0,0 +1,3 @@
+module PrivateMail
+  VERSION = "0.0.1" unless defined? PrivateMail::VERSION
+end

data/lib/private_mail.rb

@@ -0,0 +1,204 @@
+# Private Mail implements simple private messaging between users in a Rails application.
+
+require 'logger'
+require 'active_record'
+require 'mailbox'
+
+module PrivateMail
+  def self.included(mod)
+    mod.extend(ClassMethods)
+  end
+
+  # declare the class level helper methods which
+  # will load the relevant instance methods
+  # defined below when invoked
+  module ClassMethods
+    #enables a class to send and receive messages to members of the same class - currently assumes the model is of class type 'User', 
+    #some modifications to the migrations and model classes will need to be made to use a model of different type.
+    #
+    #====options:
+    #* :received - the mailbox type to store received messages (defaults to :inbox)
+    #
+    #* :sent - the mailbox type to store sent messages (defaults to :sentbox)
+    #
+    #* :deleted - the mailbox type to store deleted messages (defaults to :trash)
+    #
+    #====example:
+    #   acts_as_messageable :received => :in, :sent => :sent, :deleted => :garbage
+    def acts_as_messageable(options = {})
+      cattr_accessor :mailbox_types
+      has_many :mail, :order => 'created_at DESC', :dependent => :delete_all
+      
+      self.mailbox_types = {
+        :received => :inbox,
+        :sent => :sentbox,
+        :deleted => :trash
+      }.merge(options)
+      
+      include PrivateMail::InstanceMethods
+    end
+  end
+
+  # Adds instance methods.
+  module InstanceMethods
+    #returns an instance of class type Mailbox - this object essentially wraps the user's mail messages and provides a clean interface for accessing them. 
+    #see Mailbox for more details.
+    #
+    #====example:
+    #   phil = User.find(3123)
+    #   phil.mailbox[:inbox].unread_mail      #returns all unread mail in your inbox
+    #   phil.mailbox[:sentbox].mail         #returns all sent mail messages
+    #  
+    def mailbox()
+      @mailbox = Mailbox.new(self) if @mailbox.nil?
+      @mailbox.type = :all
+      return @mailbox
+    end
+    #creates new Message and Conversation objects from the given parameters and delivers Mail to each of the recipients' inbox.
+    #
+    #====params:
+    #recipients::
+    #     a single user object or array of users to deliver the message to.
+    #msg_body::
+    #     the body of the message.
+    #subject::
+    #     the subject of the message, defaults to empty string if not provided.
+    #====returns:
+    #the sent Mail.
+    #
+    #====example:
+    #   phil = User.find(3123)
+    #   todd = User.find(4141)
+    #   phil.send_message(todd, 'whats up for tonight?', 'hey guy')      #sends a Mail message to todd's inbox, and a Mail message to phil's sentbox
+    #  
+    def send_message(recipients, msg_body, subject = '')
+      convo = Conversation.create({:subject => subject})
+      message = Message.create({:sender => self, :conversation => convo,  :body => msg_body, :subject => subject})
+      message.recipients = recipients.is_a?(Array) ? recipients : [recipients]
+      message.deliver(self.mailbox_types[:received])
+      return mailbox[:sentbox] << message
+    end
+    #creates a new Message associated with the given conversation and delivers the reply to each of the given recipients.
+    #
+    #*explicitly calling this method is rare unless you are replying to a subset of the users involved in the conversation or 
+    #if you are including someone that is not currently in the conversation. 
+    #reply_to_sender, reply_to_all, and reply_to_conversation will suffice in most cases.
+    #
+    #====params:
+    #conversation::
+    #     the Conversation object that the mail you are responding to belongs.
+    #recipients::
+    #     a single User object or array of Users to deliver the reply message to.
+    #reply_body::
+    #     the body of the reply message.
+    #subject::
+    #     the subject of the message, defaults to 'RE: [original subject]' if one isnt given.
+    #====returns:
+    #the sent Mail.
+    #
+    def reply(conversation, recipients, reply_body, subject = nil)
+      return nil if(reply_body.blank?)
+      subject = subject || "RE: #{conversation.subject}"
+      response = Message.create({:sender => self, :conversation => conversation, :body => reply_body, :subject => subject})
+      response.recipients = recipients.is_a?(Array) ? recipients : [recipients]
+      response.deliver(self.mailbox_types[:received])
+      return mailbox[self.mailbox_types[:sent]] << response
+    end
+    #sends a Mail to the sender of the given mail message.
+    #
+    #====params:
+    #mail::
+    #     the Mail object that you are replying to.
+    #reply_body::
+    #     the body of the reply message.
+    #subject::
+    #     the subject of the message, defaults to 'RE: [original subject]' if one isnt given.
+    #====returns:
+    #the sent Mail.
+    #
+    def reply_to_sender(mail, reply_body, subject = nil)
+      return reply(mail.conversation, mail.message.sender, reply_body, subject)
+    end
+    #sends a Mail to all of the recipients of the given mail message (excluding yourself).
+    #
+    #====params:
+    #mail::
+    #     the Mail object that you are replying to.
+    #reply_body::
+    #     the body of the reply message.
+    #subject::
+    #     the subject of the message, defaults to 'RE: [original subject]' if one isnt given.
+    #====returns:
+    #the sent Mail.
+    #
+    def reply_to_all(mail, reply_body, subject = nil)
+      msg = mail.message
+      recipients = msg.recipients.clone()
+      if(msg.sender != self)
+        recipients.delete(self)
+        if(!recipients.include?(msg.sender))
+          recipients << msg.sender
+        end
+      end
+      return reply(mail.conversation, recipients, reply_body, subject)
+    end
+    #sends a Mail to all users involved in the given conversation (excluding yourself).
+    #
+    #*this may have undesired effects if users have been added to the conversation after it has begun.
+    #
+    #====params:
+    #conversation::
+    #     the Conversation object that the mail you are responding to belongs.
+    #reply_body::
+    #     the body of the reply message.
+    #subject::
+    #     the subject of the message, defaults to 'RE: [original subject]' if one isnt given.
+    #====returns:
+    #the sent Mail.
+    #
+    def reply_to_conversation(conversation, reply_body, subject = nil)
+      #move conversation to inbox if it is currently in the trash - doesnt make much sense replying to a trashed convo.
+      if((mailbox[self.mailbox_types[:deleted]].has_conversation?(conversation)))
+        mailbox.move_to(self.mailbox_types[:received], :conversation => conversation)
+      end
+      #remove self from recipients unless you are the originator of the convo
+      recipients = conversation.original_message.recipients.clone()
+      if(conversation.originator != self)
+        recipients.delete(self)
+        if(!recipients.include?(conversation.originator))
+          recipients << conversation.originator
+        end
+      end
+      return reply(conversation,recipients, reply_body, subject)
+    end
+    #returns the mail given as the parameter, marked as read.
+    def read_mail(mail)
+      return mail.mark_as_read()
+    end
+    #returns an array of the user's Mail associated with the given conversation. 
+    #All mail is marked as read but the returning array is built before this so you can see which messages were unread when viewing the conversation.
+    #
+    #This returns deleted/trashed messages as well for the purpose of reading trashed convos, to disable this send the option ':conditions => "mail.trashed != true"'
+    #
+    #====params:
+    #conversation::
+    #     the Conversation object that you want to read.
+    #options::
+    #     any options to filter the conversation, these are used as find options so all valid options for find will work.
+    #
+    #====returns:
+    #array of Mail belonging to the given conversation.
+    #
+    def read_conversation(conversation, options = {})
+      convo_mail = self.mailbox.mail(options.merge(:conversation => conversation))
+      self.mailbox.mark_as_read(:conversation => conversation)
+      return convo_mail
+    end
+  end
+end
+
+# reopen ActiveRecord and include all the above to make
+# them available to all our models if they want it
+ActiveRecord::Base.class_eval do
+  include PrivateMail
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: private_mail
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- John McDowall
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-31 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &2170459640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2170459640
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2170459220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2170459220
+description: ''
+email: john@mcdowall.info
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/generators/private_mail/install/install_generator.rb
+- lib/generators/private_mail/install/models/conversation.rb
+- lib/generators/private_mail/install/models/mail.rb
+- lib/generators/private_mail/install/models/message.rb
+- lib/generators/private_mail/install/templates/create_conversations.rb
+- lib/generators/private_mail/install/templates/create_mail.rb
+- lib/generators/private_mail/install/templates/create_messages.rb
+- lib/generators/private_mail/install/templates/create_messages_recipients.rb
+- lib/mailbox.rb
+- lib/private_mail/version.rb
+- lib/private_mail.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1834868077319262402
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: ''
+test_files: []