mailboxer 0.0.15 → 0.0.16

data/.gitignore

@@ -10,3 +10,4 @@ Gemfile.lock
 .project
 .document
 .settings/
+rdoc/

data/Rakefile

@@ -1,53 +1,27 @@
 require 'rubygems'
-require 'bundler'
 begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
+  require 'bundler/setup'
+  require 'bundler'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 require 'rake'
-
-require 'jeweler'
-Jeweler::Tasks.new do |gem|
-  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
-  gem.name = "mailboxer"
-  gem.homepage = "http://github.com/roendal/mailboxer"
-  gem.license = "MIT"
-  gem.summary = %Q{Private messaging system for rails apps.}
-  gem.description = %Q{TODO: longer description of your gem}
-  gem.email = "ecasanovac@gmail.com"
-  gem.authors = ["Eduardo Casanova Cuesta"]
-  # Include your dependencies below. Runtime dependencies are required when using your gem,
-  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
-  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
-  #  gem.add_development_dependency 'rspec', '> 1.2.3'
-  gem.add_development_dependency('rspec-rails', '~> 2.4.1')
-  gem.add_development_dependency('factory_girl', '~> 1.3.2')
-  gem.add_development_dependency('forgery', '~> 0.3.6')
-end
-Jeweler::RubygemsDotOrgTasks.new
+require 'rake/rdoctask'
 
 require 'rspec/core'
 require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = FileList['spec/**/*_spec.rb']
-end
 
-RSpec::Core::RakeTask.new(:rcov) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-end
+RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
 
-require 'rake/rdoctask'
 Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "mailboxer #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.title = "Mailboxer"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb', 'app/**/*.rb')
 end
+
+
+Bundler::GemHelper.install_tasks

data/app/models/conversation.rb

@@ -1,5 +1,4 @@
 class Conversation < ActiveRecord::Base
-	attr_reader :originator, :original_message, :last_sender, :last_message
 	has_many :messages
 	has_many :receipts, :through => :messages
 
@@ -7,7 +6,6 @@ class Conversation < ActiveRecord::Base
 
 	before_validation :clean
 
-	#  before_create :clean
 	scope :participant, lambda {|participant|
     joins(:receipts).select('DISTINCT conversations.*').where('notifications.type'=> Message.to_s,'receipts.receiver_id' => participant.id,'receipts.receiver_type' => participant.class.to_s).order("conversations.updated_at DESC")
   }
@@ -23,32 +21,32 @@ class Conversation < ActiveRecord::Base
 	scope :unread,  lambda {|participant|
     joins(:receipts).select('DISTINCT conversations.*').where('notifications.type'=> Message.to_s,'receipts.receiver_id' => participant.id,'receipts.receiver_type' => participant.class.to_s,'receipts.read' => false).order("conversations.updated_at DESC")
   }
-	class << self
-		def total
-			count('DISTINCT conversations.id')
-		end
-	end
 
+  #Mark the conversation as read for one of the participants
 	def mark_as_read(participant)
 		return if participant.nil?
 		return self.receipts_for(participant).mark_as_read
 	end
 
+  #Mark the conversation as unread for one of the participants
 	def mark_as_unread(participant)
 		return if participant.nil?
 		return self.receipts_for(participant).mark_as_unread
 	end
 
+  #Move the conversation to the trash for one of the participants
 	def move_to_trash(participant)
 		return if participant.nil?
 		return self.receipts_for(participant).move_to_trash
 	end
 
+  #Takes the conversation out of the trash for one of the participants
 	def untrash(participant)
 		return if participant.nil?
 		return self.receipts_for(participant).untrash
 	end
 
+  #Returns an array of participants
 	def recipients
 		if self.last_message
 			recps = self.last_message.recipients
@@ -57,71 +55,75 @@ class Conversation < ActiveRecord::Base
 		end
 		return []
 	end
+	
+  #Returns an array of participants
+	def participants
+	  return recipients
+	end
 
-	#originator of the conversation.
+	#Originator of the conversation.
 	def originator
 		@orignator = self.original_message.sender if @originator.nil?
 		return @orignator
 	end
 
-	#first message of the conversation.
+	#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.
+	#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.
+	#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
 
+  #Returns the receipts of the conversation for one participants
 	def receipts_for(participant)
 		return Receipt.conversation(self).receiver(participant)
 	end
 
+  #Returns the number of messages of the conversation
 	def count_messages
 		return Message.conversation(self).count
 	end
 
+  #Returns true if the messageable is a participant of the conversation
 	def is_participant?(participant)
 		return false if participant.nil?
 		return self.receipts_for(participant).count != 0
 	end
 
+  #Returns true if the participant has at least one trashed message of the conversation
 	def is_trashed?(participant)
 		return false if participant.nil?
 		return self.receipts_for(participant).trash.count!=0
 	end
 
+  #Returns true if the participant has trashed all the messages of the conversation
 	def is_completely_trashed?(participant)
 		return false if participant.nil?
 		return self.receipts_for(participant).trash.count==self.receipts(participant).count
 	end
 
+  #Returns true if the participant has at least one unread message of the conversation
 	def is_unread?(participant)
 		return false if participant.nil?
 		return self.receipts_for(participant).unread.count!=0
 	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
 
 	protected
 
 	include ActionView::Helpers::SanitizeHelper
 
+  #Use the default sanitize to clean the conversation subject
 	def clean
 		self.subject = sanitize self.subject
 	end

data/app/models/mailbox.rb

@@ -1,69 +1,114 @@
 class Mailbox
-	attr_accessor :type
-	attr_reader :messageable
-	def initialize(recipient, box = :all)
-		@messageable = recipient
-	end
-	
-	def notifications(options = {})
-	  return Receipt.where(options).receiver(@messageable).notifications
-	end
+  attr_accessor :type
+  attr_reader :messageable
+  #Initializer method
+  def initialize(messageable)
+    @messageable = messageable
+  end
 
-	def conversations(options = {})
-		conv = Conversation.participant(@messageable)
+  #Returns the notifications for the messageable
+  def notifications(options = {})
+    return Notification.receiver(@messageable)
+  end
 
-		if options[:mailbox_type].present?
-			case options[:mailbox_type]
-			when 'inbox'
-				conv = Conversation.inbox(@messageable)
-			when 'sentbox'
-				conv = Conversation.sentbox(@messageable)
-			when 'trash'
-				conv = Conversation.trash(@messageable)
-			end
-		end
+  #Returns the conversations for the messageable
+  #
+  #Options
+  #
+  #* :mailbox_type
+  #  * "inbox"
+  #  * "sentbox"
+  #  * "trash"
+  #
+  #* :read=false
+  #* :unread=true
+  #
+  def conversations(options = {})
+    conv = Conversation.participant(@messageable)
 
-		if (options[:read].present? and options[:read]==false) or (options[:unread].present? and options[:unread]==true)
-		conv = conv.unread(@messageable)
-		end
-		
-		return conv.uniq
-	end
+    if options[:mailbox_type].present?
+      case options[:mailbox_type]
+      when 'inbox'
+        conv = Conversation.inbox(@messageable)
+      when 'sentbox'
+        conv = Conversation.sentbox(@messageable)
+      when 'trash'
+        conv = Conversation.trash(@messageable)
+      end
+    end
 
-	def inbox(options={})
-		options = options.merge(:mailbox_type => 'inbox')
-		return self.conversations(options)
-	end
+    if (options[:read].present? and options[:read]==false) or (options[:unread].present? and options[:unread]==true)
+    conv = conv.unread(@messageable)
+    end
 
-	def sentbox(options={})
-		options = options.merge(:mailbox_type => 'sentbox')
-		return self.conversations(options)
-	end
+    return conv.uniq
+  end
 
-	def trash(options={})
-		options = options.merge(:mailbox_type => 'trash')
-		return self.conversations(options)
-	end
+  #Returns the conversations in the inbox of messageable
+  #
+  #Same as conversations({:mailbox_type => 'inbox'})
+  def inbox(options={})
+    options = options.merge(:mailbox_type => 'inbox')
+    return self.conversations(options)
+  end
 
-	def receipts(options = {})
-		return Receipt.where(options).receiver(@messageable)
-	end
+  #Returns the conversations in the sentbox of messageable
+  #
+  #Same as conversations({:mailbox_type => 'sentbox'})
+  def sentbox(options={})
+    options = options.merge(:mailbox_type => 'sentbox')
+    return self.conversations(options)
+  end
 
-	def empty_trash(options = {})
-	  #TODO
-		return false
-	end
+  #Returns the conversations in the trash of messageable
+  #
+  #Same as conversations({:mailbox_type => 'trash'})
+  def trash(options={})
+    options = options.merge(:mailbox_type => 'trash')
+    return self.conversations(options)
+  end
 
-	def has_conversation?(conversation)
-		return conversation.is_participant?(@messageable)
-	end
+  #Returns all the receipts of messageable, from Messages and Notifications
+  def receipts(options = {})
+    return Receipt.where(options).receiver(@messageable)
+  end
 
-	def is_trashed?(conversation)
-		return conversation.is_trashed?(@messageable)
-	end
+  #Deletes all the messages in the trash of messageable. NOT IMPLEMENTED.
+  def empty_trash(options = {})
+    #TODO
+    return false
+  end
 
-	def is_completely_trashed?(conversation)
-		return conversation.is_completely_trashed?(@messageable)
-	end
+  #Returns if messageable is a participant of conversation
+  def has_conversation?(conversation)
+    return conversation.is_participant?(@messageable)
+  end
+
+  #Returns true if messageable has at least one trashed message of the conversation
+  def is_trashed?(conversation)
+    return conversation.is_trashed?(@messageable)
+  end
+
+  #Returns true if messageable has trashed all the messages of the conversation
+  def is_completely_trashed?(conversation)
+    return conversation.is_completely_trashed?(@messageable)
+  end
+
+  #Returns the receipts of object for messageable
+  #
+  #Object can be:
+  #* A Message
+  #* A Notification
+  #* A Conversation
+  def receipts_for(object)
+    case object
+    when Message,Notification
+      return [object.receipt_for(@messageable)]
+    when Conversation
+      return object.receipts_for(@messageable)
+    else
+    return Array.new
+    end
+  end
 
 end

data/app/models/message.rb

@@ -8,12 +8,16 @@ class Message < Notification
   scope :conversation, lambda { |conversation|
     where(:conversation_id => conversation.id)
   }
+  
   class << self
+    #Sets the on deliver callback method.
     def on_deliver(callback_method)
       self.on_deliver_callback = callback_method
     end
   end
-
+  
+  #Delivers a Message. USE NOT RECOMENDED.
+  #Use Mailboxer::Models::Message.send_message instead.
   def deliver(reply = false, should_clean = true)
     self.clean if should_clean
     temp_receipts = Array.new
@@ -45,6 +49,4 @@ class Message < Notification
     end
     return sender_receipt
   end  
-
-
 end

data/app/models/notification.rb

@@ -5,7 +5,12 @@ class Notification < ActiveRecord::Base
   validates_presence_of :subject, :body
   has_many :receipts
   
+  scope :receiver, lambda { |receiver|
+    joins(:receipts).where('receipts.receiver_id' => receiver.id,'receipts.receiver_type' => receiver.class.to_s)
+  }
+  
   class << self
+    #Sends a Notification to all the recipients
     def notify_all(recipients,subject,body)
       notification = Notification.new({:body => body, :subject => subject})
       notification.recipients = recipients.is_a?(Array) ? recipients : [recipients]
@@ -14,6 +19,8 @@ class Notification < ActiveRecord::Base
     end
   end
 
+  #Delivers a Notification. USE NOT RECOMENDED.
+  #Use Mailboxer::Models::Message.notify and Notification.notify_all instead.
   def deliver(should_clean = true)
     self.clean if should_clean
     temp_receipts = Array.new
@@ -32,7 +39,8 @@ class Notification < ActiveRecord::Base
     end
     return temp_receipts
   end
-
+  
+  #Returns the recipients of the Notification
   def recipients
     if @recipients.blank?
       recipients_array = Array.new
@@ -44,10 +52,12 @@ class Notification < ActiveRecord::Base
     return @recipients
   end
 
+  #Returns the receipt for the participant
   def receipt_for(participant)
     return Receipt.notification(self).receiver(participant)
   end
 
+  #Returns if the participant have read the Notification
   def is_unread?(participant)
     return false if participant.nil?
     return self.receipt_for(participant).unread.count!=0
@@ -55,6 +65,7 @@ class Notification < ActiveRecord::Base
 
   include ActionView::Helpers::SanitizeHelper
 
+  #Sanitizes the body and subject
   def clean
     unless self.subject.nil?
       self.subject = sanitize self.subject

data/app/models/receipt.rb

@@ -10,8 +10,8 @@ class Receipt < ActiveRecord::Base
   }
   #Notifications Scope checks type to be nil, not Notification because of STI behaviour
   #with the primary class (no type is saved)
-  scope :notifications, joins(:notification).where('notifications.type' => nil)
-  scope :messages, joins(:notification).where('notifications.type' => Message.to_s)
+  scope :notifications_receipts, joins(:notification).where('notifications.type' => nil)
+  scope :messages_receipts, joins(:notification).where('notifications.type' => Message.to_s)
 	scope :notification, lambda { |notification|
     where(:notification_id => notification.id)
   }
@@ -27,66 +27,82 @@ class Receipt < ActiveRecord::Base
 
 	after_validation :remove_duplicate_errors
 	class << self
+	  
+    #Marks all the receipts from the relation as read
 		def mark_as_read(options={})
 			where(options).update_all(:read => true)
 		end
 
+    #Marks all the receipts from the relation as unread
 		def mark_as_unread(options={})
 			where(options).update_all(:read => false)
 		end
 
+    #Marks all the receipts from the relation as trashed
 		def move_to_trash(options={})
 			where(options).update_all(:trashed => true)
 		end
 
+    #Marks all the receipts from the relation as not trashed
 		def untrash(options={})
 			where(options).update_all(:trashed => false)
 		end
 
+    #Moves all the receipts from the relation to inbox
 		def move_to_inbox(options={})
 			where(options).update_all(:mailbox_type => :inbox, :trashed => false)
 		end
 
+    #Moves all the receipts from the relation to sentbox
 		def move_to_sentbox(options={})
 			where(options).update_all(:mailbox_type => :sentbox, :trashed => false)
 		end
 	end
 
+  #Marks the receipt as read
 	def mark_as_read
 		update_attributes(:read => true)
 	end
 
+  #Marks the receipt as unread
 	def mark_as_unread
 		update_attributes(:read => false)
 	end
 
+  #Marks the receipt as trashed
 	def move_to_trash
 		update_attributes(:trashed => true)
 	end
 
+  #Marks the receipt as not trashed
 	def untrash
 		update_attributes(:trashed => false)
 	end
 
+  #Moves the receipt to inbox
 	def move_to_inbox
 		update_attributes(:mailbox_type => :inbox, :trashed => false)
 	end
 
+  #Moves the receipt to sentbox
 	def move_to_sentbox
 		update_attributes(:mailbox_type => :sentbox, :trashed => false)
 	end
 
+  #Returns the conversation associated to the receipt if the notification is a Message
   def conversation
-    return nil if notification.class == Notification
-    return notification.conversation if notification.class == Message
+    return message.conversation if message.is_a? Message
+    return nil
   end
 
 	protected
 
+  #Removes the duplicate error about not present subject from Conversation if it has been already
+  #raised by Message
 	def remove_duplicate_errors
-		if self.errors["message.conversation.subject"].present? and self.errors["message.subject"].present?
-			self.errors["message.conversation.subject"].each do |msg|
-				self.errors["message.conversation.subject"].delete(msg)
+		if self.errors["notification.conversation.subject"].present? and self.errors["notification.subject"].present?
+			self.errors["notification.conversation.subject"].each do |msg|
+				self.errors["notification.conversation.subject"].delete(msg)
 			end
 		end
 	end

data/lib/mailboxer/models/messageable.rb

@@ -1,102 +1,127 @@
 module Mailboxer
-	module Models
-		module Messageable
-			def self.included(mod)
-				mod.extend(ClassMethods)
-			end
+  module Models
+    module Messageable
+      def self.included(mod)
+        mod.extend(ClassMethods)
+      end
 
-			module ClassMethods
-				def acts_as_messageable
-					has_many :messages
-					has_many :receipts, :order => 'created_at DESC', :dependent => :delete_all
+      module ClassMethods
+        #Converts the model into messageable allowing it to interchange messages and
+        #receive notifications
+        def acts_as_messageable
+          has_many :messages
+          has_many :receipts, :order => 'created_at DESC', :dependent => :delete_all
 
-					include Mailboxer::Models::Messageable::InstanceMethods
-				end
-			end
+          include Mailboxer::Models::Messageable::InstanceMethods
+        end
+      end
 
-			module InstanceMethods
-			  
-			  ################################### MAILBOXES
-			  
-				def mailbox
-					@mailbox = Mailbox.new(self) if @mailbox.nil?
-					@mailbox.type = :all
-					return @mailbox
-				end
-				
-				################################### NOTIFICATIONS
-				
-				def notify(subject,body)
+      module InstanceMethods
+        #Gets the mailbox of the messageable
+        def mailbox
+          @mailbox = Mailbox.new(self) if @mailbox.nil?
+          @mailbox.type = :all
+          return @mailbox
+        end
+
+        #Sends a notification to the messageable
+        def notify(subject,body)
           notification = Notification.new({:body => body, :subject => subject})
           notification.recipients = [self]
-          return notification.deliver				  
-				end
-				
-				################################### MESSAGES
+          return notification.deliver
+        end
 
-				def send_message(recipients, msg_body, subject)
-					convo = Conversation.new({:subject => subject})
-					message = Message.new({:sender => self, :conversation => convo,  :body => msg_body, :subject => subject})
-					message.recipients = recipients.is_a?(Array) ? recipients : [recipients]
-					message.recipients = message.recipients.uniq
-					return message.deliver
-				end
+        #Sends a messages, starting a new conversation, with the messageable
+        #as originator
+        def send_message(recipients, msg_body, subject)
+          convo = Conversation.new({:subject => subject})
+          message = Message.new({:sender => self, :conversation => convo,  :body => msg_body, :subject => subject})
+          message.recipients = recipients.is_a?(Array) ? recipients : [recipients]
+          message.recipients = message.recipients.uniq
+          return message.deliver
+        end
 
-				def reply(conversation, recipients, reply_body, subject = nil)
-					subject = subject || "RE: #{conversation.subject}"
-					response = Message.new({:sender => self, :conversation => conversation, :body => reply_body, :subject => subject})
-					response.recipients = recipients.is_a?(Array) ? recipients : [recipients]					
-					response.recipients = response.recipients.uniq
-					response.recipients.delete(self)
-					return response.deliver(true)
-				end
+        #Basic reply method. USE NOT RECOMENDED.
+        #Use reply_to_sender, reply_to_all and reply_to_conversation instead.
+        def reply(conversation, recipients, reply_body, subject = nil)
+          subject = subject || "RE: #{conversation.subject}"
+          response = Message.new({:sender => self, :conversation => conversation, :body => reply_body, :subject => subject})
+          response.recipients = recipients.is_a?(Array) ? recipients : [recipients]
+          response.recipients = response.recipients.uniq
+          response.recipients.delete(self)
+          return response.deliver(true)
+        end
 
-				def reply_to_sender(receipt, reply_body, subject = nil)
-					return reply(receipt.conversation, receipt.notification.sender, reply_body, subject)
-				end
+        #Replies to the sender of the message in the conversation
+        def reply_to_sender(receipt, reply_body, subject = nil)
+          return reply(receipt.conversation, receipt.message.sender, reply_body, subject)
+        end
 
-				def reply_to_all(receipt, reply_body, subject = nil)
-					return reply(receipt.conversation, receipt.notification.recipients, reply_body, subject)
-				end
+        #Replies to all the recipients of the message in the conversation
+        def reply_to_all(receipt, reply_body, subject = nil)
+          return reply(receipt.conversation, receipt.message.recipients, reply_body, subject)
+        end
 
-				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.is_trashed?(conversation))
-						mailbox.receipts.conversation(conversation).untrash
-					end
-					#remove self from recipients unless you are the originator of the convo
-					recipients = conversation.last_message.recipients
-					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
+        #Replies to all the recipients of the last message in the conversation and untrash any trashed message by messageable
+        #if should_untrash is set to true (this is so by default)
+        def reply_to_conversation(conversation, reply_body, subject = nil, should_untrash = true)
+          #move conversation to inbox if it is currently in the trash and should_untrash parameter is true.
+          if should_untrash && mailbox.is_trashed?(conversation)
+            mailbox.receipts_for(conversation).untrash
+          end
+          return reply(conversation, conversation.last_message.recipients, reply_body, subject)
+        end
 
-				def read_message(obj)
-					if obj.class.to_s.eql? 'Receipt'
-						return obj.mark_as_read if obj.receiver == self
-					elsif obj.class.to_s.eql? 'Message'
-						receipts = obj.receipts.receiver(self)
-						return receipts.mark_as_read
-					end
-					return nil
-				end
+        #Mark the object as read for messageable.
+        #
+        #Object can be:
+        #* A Receipt
+        #* A Message
+        #* A Notification
+        #* A Conversation
+        #* An array with any of them
+        def read(obj)
+          case obj
+          when Receipt
+            return obj.mark_as_read if obj.receiver == self
+          when Message, Notification
+            receipt = obj.receipt_for(self)
+            return receipt.mark_as_read
+          when Conversation
+            receipts = obj.receipts_for(self)
+            return receipts.mark_as_read
+          when Array
+            obj.map{ |sub_obj| read(sub_obj) }
+          else
+          return nil
+          end
+        end
 
-				def unread_message(obj)
-					if obj.class.to_s.eql? 'Receipt'
-						return obj.mark_as_unread if obj.receiver == self
-					elsif obj.class.to_s.eql? 'Message'
-						receipts = obj.receipts.receiver(self)
-						return receipts.mark_as_unread
-					end
-					return nil
-				end
-				
-				
-			end
-		end
-	end
+        #Mark the object as unread for messageable.
+        #
+        #Object can be:
+        #* A Receipt
+        #* A Message
+        #* A Notification
+        #* A Conversation
+        #* An array with any of them
+        def unread(obj)
+          case obj
+          when Receipt
+            return obj.mark_as_unread if obj.receiver == self
+          when Message, Notification
+            receipt = obj.receipt_for(self)
+            return receipt.mark_as_unread
+          when Conversation
+            receipts = obj.receipts_for(self)
+            return receipts.mark_as_unread
+          when Array
+            obj.map{ |sub_obj| unread(sub_obj) }
+          else
+          return nil
+          end
+        end
+      end
+    end
+  end
 end

data/mailboxer.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
 	s.name = "mailboxer"
-	s.version = "0.0.15"
+	s.version = "0.0.16"
 	s.authors = ["Eduardo Casanova Cuesta"]
 	s.summary = "Messaging system for rails apps."
 	s.description = "A Rails engine that allows any model to act as messageable, permitting it interchange messages with any other messageable model." +  

data/spec/models/mailboxer_models_messageable_spec.rb

@@ -32,30 +32,30 @@ describe "Mailboxer::Models::Messageable through User" do
   it "should be able to unread an owned mail (mark as unread)" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @receipt.read.should==true
-    @entity1.unread_message(@receipt)
+    @entity1.unread(@receipt)
     @receipt.read.should==false
   end
   
   it "should be able to read an owned mail (mark as read)" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @receipt.read.should==true
-    @entity1.unread_message(@receipt)
-    @entity1.read_message(@receipt)
+    @entity1.unread(@receipt)
+    @entity1.read(@receipt)
     @receipt.read.should==true
   end
   
   it "should be able to unread anot owned mail (mark as unread)" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @receipt.read.should==true
-    @entity2.unread_message(@receipt) #Should not change
+    @entity2.unread(@receipt) #Should not change
     @receipt.read.should==true
   end
   
   it "should be able to read a not owned mail (mark as read)" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @receipt.read.should==true
-    @entity1.unread_message(@receipt) #From read to unread
-    @entity2.read_message(@receipt) #Should not change
+    @entity1.unread(@receipt) #From read to unread
+    @entity2.read(@receipt) #Should not change
     @receipt.read.should==false
   end
   

data/spec/models/notification_spec.rb

@@ -20,8 +20,7 @@ describe Message do
     
     #Check getting NOTIFICATION receipts only
     @entity1.mailbox.notifications.size.should==1
-    receipt = @entity1.mailbox.notifications.first
-    notification = receipt.notification
+    notification = @entity1.mailbox.notifications.first
     notification.subject.should=="Subject"
     notification.body.should=="Body"       
   end
@@ -48,18 +47,15 @@ describe Message do
     
     #Check getting NOTIFICATION receipts only
     @entity1.mailbox.notifications.size.should==1
-    receipt = @entity1.mailbox.notifications.first
-    notification = receipt.notification
+    notification = @entity1.mailbox.notifications.first
     notification.subject.should=="Subject"
     notification.body.should=="Body"
     @entity2.mailbox.notifications.size.should==1
-    receipt = @entity2.mailbox.notifications.first
-    notification = receipt.notification
+    notification = @entity2.mailbox.notifications.first
     notification.subject.should=="Subject"
     notification.body.should=="Body"
     @entity3.mailbox.notifications.size.should==1
-    receipt = @entity3.mailbox.notifications.first
-    notification = receipt.notification
+    notification = @entity3.mailbox.notifications.first
     notification.subject.should=="Subject"
     notification.body.should=="Body"
           

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mailboxer
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 63
   prerelease: false
   segments: 
   - 0
   - 0
-  - 15
-  version: 0.0.15
+  - 16
+  version: 0.0.16
 platform: ruby
 authors: 
 - Eduardo Casanova Cuesta
@@ -15,12 +15,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-12 00:00:00 +02:00
+date: 2011-04-17 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: foreigner
-  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -33,10 +31,10 @@ dependencies:
         - 1
         version: 0.9.1
   type: :runtime
+  name: foreigner
+  prerelease: false
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: rails
-  prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -49,10 +47,10 @@ dependencies:
         - 5
         version: 3.0.5
   type: :development
+  name: rails
+  prerelease: false
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: sqlite3-ruby
-  prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -63,10 +61,10 @@ dependencies:
         - 0
         version: "0"
   type: :development
+  name: sqlite3-ruby
+  prerelease: false
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: ruby-debug
-  prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -79,10 +77,10 @@ dependencies:
         - 3
         version: 0.10.3
   type: :development
+  name: ruby-debug
+  prerelease: false
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: rspec-rails
-  prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -95,10 +93,10 @@ dependencies:
         - 0
         version: 2.5.0
   type: :development
+  name: rspec-rails
+  prerelease: false
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
-  name: factory_girl
-  prerelease: false
   requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -111,10 +109,10 @@ dependencies:
         - 2
         version: 1.3.2
   type: :development
+  name: factory_girl
+  prerelease: false
   version_requirements: *id006
 - !ruby/object:Gem::Dependency 
-  name: forgery
-  prerelease: false
   requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -127,10 +125,10 @@ dependencies:
         - 6
         version: 0.3.6
   type: :development
+  name: forgery
+  prerelease: false
   version_requirements: *id007
 - !ruby/object:Gem::Dependency 
-  name: capybara
-  prerelease: false
   requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -143,6 +141,8 @@ dependencies:
         - 9
         version: 0.3.9
   type: :development
+  name: capybara
+  prerelease: false
   version_requirements: *id008
 description: A Rails engine that allows any model to act as messageable, permitting it interchange messages with any other messageable model.It also supports sending system notifications to messageable models.
 email: ecasanovac@gmail.com