mailboxer 0.8.0 → 0.9.0

data/README.md

@@ -1,4 +1,4 @@
-# Mailboxer 0.8.x [![](https://secure.travis-ci.org/ging/mailboxer.png)](http://travis-ci.org/ging/mailboxer) [![](https://gemnasium.com/ging/mailboxer.png)](https://gemnasium.com/ging/mailboxer)
+# Mailboxer 0.9.x [![](https://secure.travis-ci.org/ging/mailboxer.png)](http://travis-ci.org/ging/mailboxer) [![](https://gemnasium.com/ging/mailboxer.png)](https://gemnasium.com/ging/mailboxer)
 
 This project is based on the need of a private message system for [ging
 / social\_stream](https://github.com/ging/social_stream). Instead of creating our core message system heavily

data/app/models/receipt.rb

@@ -6,7 +6,7 @@ class Receipt < ActiveRecord::Base
   validates_presence_of :receiver
 
   scope :recipient, lambda { |recipient|
-    where(:receiver_id => recipient.id,:receiver_type => recipient.class.to_s)
+    where(:receiver_id => recipient.id,:receiver_type => recipient.class.base_class.to_s)
   }
   #Notifications Scope checks type to be nil, not Notification because of STI behaviour
   #with the primary class (no type is saved)

data/db/migrate/20111204163911_add_attachments.rb

@@ -2,8 +2,8 @@ class AddAttachments < ActiveRecord::Migration
   def self.up
     add_column :notifications, :attachment, :string
   end
-  
+
   def self.down
-    remove_column :notifications, :attachment, :string
+    remove_column :notifications, :attachment
   end
 end

data/lib/mailboxer/models/messageable.rb

@@ -12,182 +12,186 @@ module Mailboxer
           has_many :messages, :as => :sender
           has_many :receipts, :order => 'created_at DESC', :dependent => :destroy, :as => :receiver
 
-          include Mailboxer::Models::Messageable::InstanceMethods
         end
       end
 
-      module InstanceMethods
-          eval <<-EOM
-           #Returning any kind of identification you want for the model
-           def #{Mailboxer.name_method}
-             super
-           rescue NameError
-             return "You should add method :#{Mailboxer.name_method} in your Messageable model"
-           end
-
-           #Returning the email address of the model if an email should be sent for this object (Message or Notification).
-           #If no mail has to be sent, return nil.
-           def #{Mailboxer.email_method}(object)
-             super
-           rescue NameError
-             return "You should add method :#{Mailboxer.email_method} in your Messageable model"
-           end
-           EOM
-        #Gets the mailbox of the messageable
-        def mailbox
-          @mailbox = Mailbox.new(self) if @mailbox.nil?
-          @mailbox.type = :all
-          return @mailbox
+      unless defined?(Mailboxer.name_method)
+        # Returning any kind of identification you want for the model
+        define_method Mailboxer.name_method do
+          begin
+            super
+          rescue NameError
+            return "You should add method :#{Mailboxer.name_method} in your Messageable model"
+          end
         end
+      end
 
-        #Sends a notification to the messageable
-        def notify(subject,body,obj = nil,sanitize_text=true,notification_code=nil)
-          return Notification.notify_all([self],subject,body,obj,sanitize_text,notification_code)
+      unless defined?(Mailboxer.email_method)
+      #Returning the email address of the model if an email should be sent for this object (Message or Notification).
+      #If no mail has to be sent, return nil.
+        define_method Mailboxer.email_method do |object|
+          begin
+            super
+          rescue NameError
+            return "You should add method :#{Mailboxer.email_method} in your Messageable model"
+          end
         end
+      end
 
-        #Sends a messages, starting a new conversation, with the messageable
-        #as originator
-        def send_message(recipients, msg_body, subject, sanitize_text=true, attachment=nil)
-          convo = Conversation.new({:subject => subject})
-          message = messages.new({:body => msg_body, :subject => subject, :attachment => attachment})
-          message.conversation = convo
-          message.recipients = recipients.is_a?(Array) ? recipients : [recipients]
-          message.recipients = message.recipients.uniq
-          return message.deliver false,sanitize_text
-        end
+      #Gets the mailbox of the messageable
+      def mailbox
+        @mailbox = Mailbox.new(self) if @mailbox.nil?
+        @mailbox.type = :all
+        return @mailbox
+      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, sanitize_text=true, attachment=nil)
-          subject = subject || "RE: #{conversation.subject}"
-          response = messages.new({:body => reply_body, :subject => subject, :attachment => attachment})
-          response.conversation = conversation
-          response.recipients = recipients.is_a?(Array) ? recipients : [recipients]
-          response.recipients = response.recipients.uniq
-          response.recipients.delete(self)
-          return response.deliver true, sanitize_text
-        end
+      #Sends a notification to the messageable
+      def notify(subject,body,obj = nil,sanitize_text=true,notification_code=nil)
+        return Notification.notify_all([self],subject,body,obj,sanitize_text,notification_code)
+      end
 
-        #Replies to the sender of the message in the conversation
-        def reply_to_sender(receipt, reply_body, subject=nil, sanitize_text=true, attachment=nil)
-          return reply(receipt.conversation, receipt.message.sender, reply_body, subject, sanitize_text, attachment)
-        end
+      #Sends a messages, starting a new conversation, with the messageable
+      #as originator
+      def send_message(recipients, msg_body, subject, sanitize_text=true, attachment=nil)
+        convo = Conversation.new({:subject => subject})
+        message = messages.new({:body => msg_body, :subject => subject, :attachment => attachment})
+        message.conversation = convo
+        message.recipients = recipients.is_a?(Array) ? recipients : [recipients]
+        message.recipients = message.recipients.uniq
+        return message.deliver false,sanitize_text
+      end
 
-        #Replies to all the recipients of the message in the conversation
-        def reply_to_all(receipt, reply_body, subject=nil, sanitize_text=true, attachment=nil)
-          return reply(receipt.conversation, receipt.message.recipients, reply_body, subject, sanitize_text, attachment)
-        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, sanitize_text=true, attachment=nil)
+        subject = subject || "RE: #{conversation.subject}"
+        response = messages.new({:body => reply_body, :subject => subject, :attachment => attachment})
+        response.conversation = conversation
+        response.recipients = recipients.is_a?(Array) ? recipients : [recipients]
+        response.recipients = response.recipients.uniq
+        response.recipients.delete(self)
+        return response.deliver true, sanitize_text
+      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, sanitize_text=true, attachment=nil)
-          #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, sanitize_text, attachment)
-        end
+      #Replies to the sender of the message in the conversation
+      def reply_to_sender(receipt, reply_body, subject=nil, sanitize_text=true, attachment=nil)
+        return reply(receipt.conversation, receipt.message.sender, reply_body, subject, sanitize_text, attachment)
+      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 mark_as_read(obj)
-          case obj
-          when Receipt
-            return obj.mark_as_read if obj.receiver == self
-          when Message, Notification
-            obj.mark_as_read(self)
-          when Conversation
-            obj.mark_as_read(self)
-          when Array
-            obj.map{ |sub_obj| mark_as_read(sub_obj) }
-          else
-            return nil
-          end
+      #Replies to all the recipients of the message in the conversation
+      def reply_to_all(receipt, reply_body, subject=nil, sanitize_text=true, attachment=nil)
+        return reply(receipt.conversation, receipt.message.recipients, reply_body, subject, sanitize_text, attachment)
+      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, sanitize_text=true, attachment=nil)
+        #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, sanitize_text, attachment)
+      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 mark_as_unread(obj)
-          case obj
-          when Receipt
-            return obj.mark_as_unread if obj.receiver == self
-          when Message, Notification
-            obj.mark_as_unread(self)
-          when Conversation
-            obj.mark_as_unread(self)
-          when Array
-            obj.map{ |sub_obj| mark_as_unread(sub_obj) }
-          else
+      #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 mark_as_read(obj)
+        case obj
+        when Receipt
+          return obj.mark_as_read if obj.receiver == self
+        when Message, Notification
+          obj.mark_as_read(self)
+        when Conversation
+          obj.mark_as_read(self)
+        when Array
+          obj.map{ |sub_obj| mark_as_read(sub_obj) }
+        else
           return nil
-          end
         end
+      end
 
-        #Mark the object as trashed for messageable.
-        #
-        #Object can be:
-        #* A Receipt
-        #* A Message
-        #* A Notification
-        #* A Conversation
-        #* An array with any of them
-        def trash(obj)
-          case obj
-          when Receipt
-            return obj.move_to_trash if obj.receiver == self
-          when Message, Notification
-            obj.move_to_trash(self)
-          when Conversation
-            obj.move_to_trash(self)
-          when Array
-            obj.map{ |sub_obj| trash(sub_obj) }
-          else
-          return nil
-          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 mark_as_unread(obj)
+        case obj
+        when Receipt
+          return obj.mark_as_unread if obj.receiver == self
+        when Message, Notification
+          obj.mark_as_unread(self)
+        when Conversation
+          obj.mark_as_unread(self)
+        when Array
+          obj.map{ |sub_obj| mark_as_unread(sub_obj) }
+        else
+        return nil
         end
+      end
 
-        #Mark the object as not trashed for messageable.
-        #
-        #Object can be:
-        #* A Receipt
-        #* A Message
-        #* A Notification
-        #* A Conversation
-        #* An array with any of them
-        def untrash(obj)
-          case obj
-          when Receipt
-            return obj.untrash if obj.receiver == self
-          when Message, Notification
-            obj.untrash(self)
-          when Conversation
-            obj.untrash(self)
-          when Array
-            obj.map{ |sub_obj| untrash(sub_obj) }
-          else
-          return nil
-          end
+      #Mark the object as trashed for messageable.
+      #
+      #Object can be:
+      #* A Receipt
+      #* A Message
+      #* A Notification
+      #* A Conversation
+      #* An array with any of them
+      def trash(obj)
+        case obj
+        when Receipt
+          return obj.move_to_trash if obj.receiver == self
+        when Message, Notification
+          obj.move_to_trash(self)
+        when Conversation
+          obj.move_to_trash(self)
+        when Array
+          obj.map{ |sub_obj| trash(sub_obj) }
+        else
+        return nil
         end
+      end
 
-        def search_messages(query)
-          @search = Receipt.search do
-            fulltext query
-            with :receiver_id, self.id
-          end
+      #Mark the object as not trashed for messageable.
+      #
+      #Object can be:
+      #* A Receipt
+      #* A Message
+      #* A Notification
+      #* A Conversation
+      #* An array with any of them
+      def untrash(obj)
+        case obj
+        when Receipt
+          return obj.untrash if obj.receiver == self
+        when Message, Notification
+          obj.untrash(self)
+        when Conversation
+          obj.untrash(self)
+        when Array
+          obj.map{ |sub_obj| untrash(sub_obj) }
+        else
+        return nil
+        end
+      end
 
-          @search.results.map { |r| r.conversation }.uniq
+      def search_messages(query)
+        @search = Receipt.search do
+          fulltext query
+          with :receiver_id, self.id
         end
+
+        @search.results.map { |r| r.conversation }.uniq
       end
     end
   end

data/mailboxer.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "mailboxer"
-  s.version = "0.8.0"
+  s.version = "0.9.0"
   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, adding the ability to exchange messages " +

data/spec/integration/message_and_receipt_spec.rb

@@ -714,4 +714,190 @@ describe "Messages And Receipts" do
       end           
     end
   end
+
+  describe "two STI entities" do
+    before do
+      @entity1 = FactoryGirl.create(:commander)
+      @entity2 = FactoryGirl.create(:commander)
+    end
+    
+    describe "message sending" do    
+      
+      before do
+        @receipt1 = @entity1.send_message(@entity2,"Body","Subject")
+        @message1 = @receipt1.notification
+      end
+      
+      it "should create proper message" do
+        @message1.sender.id.should == @entity1.id
+        @message1.sender.class.should == @entity1.class
+        assert @message1.body.eql?"Body"
+        assert @message1.subject.eql?"Subject"
+      end
+      
+      it "should create proper mails" do
+        #Sender Mail
+        mail = Receipt.recipient(@entity1).notification(@message1).first
+        assert mail
+        if mail
+          mail.is_read.should==true
+          mail.trashed.should==false
+          mail.mailbox_type.should=="sentbox"
+        end      
+        #Receiver Mail
+        mail = Receipt.recipient(@entity2).notification(@message1).first
+        assert mail
+        if mail
+          mail.is_read.should==false
+          mail.trashed.should==false
+          mail.mailbox_type.should=="inbox"
+        end
+      end
+      
+      it "should have the correct recipients" do
+        recipients = @message1.recipients
+        recipients.count.should==2
+        recipients.count(@entity1).should==1
+        recipients.count(@entity2).should==1
+      end
+      
+    end
+    
+    describe "message replying to sender" do
+      before do
+        @receipt1 = @entity1.send_message(@entity2,"Body","Subject")
+        @receipt2 = @entity2.reply_to_sender(@receipt1,"Reply body")
+        @message1 = @receipt1.notification
+        @message2 = @receipt2.notification
+      end
+      
+      it "should create proper message" do
+        @message2.sender.id.should == @entity2.id
+        @message2.sender.class.should == @entity2.class
+        assert @message2.body.eql?"Reply body"
+        assert @message2.subject.eql?"RE: Subject"
+      end
+      
+      it "should create proper mails" do
+        #Sender Mail
+        mail = Receipt.recipient(@entity2).notification(@message2).first
+        assert mail
+        if mail
+          mail.is_read.should==true
+          mail.trashed.should==false
+          mail.mailbox_type.should=="sentbox"
+        end      
+        #Receiver Mail
+        mail = Receipt.recipient(@entity1).notification(@message2).first
+        assert mail
+        if mail
+          mail.is_read.should==false
+          mail.trashed.should==false
+          mail.mailbox_type.should=="inbox"
+        end
+      end
+      
+      it "should have the correct recipients" do
+        recipients = @message2.recipients
+        recipients.count.should==2
+        recipients.count(@entity1).should==1
+        recipients.count(@entity2).should==1
+      end
+      
+      it "should be associated to the same conversation" do
+        @message1.conversation.id.should==@message2.conversation.id      
+      end           
+    end
+    
+    describe "message replying to all" do
+      before do
+        @receipt1 = @entity1.send_message(@entity2,"Body","Subject")
+        @receipt2 = @entity2.reply_to_all(@receipt1,"Reply body")
+        @message1 = @receipt1.notification
+        @message2 = @receipt2.notification
+      end
+      
+      it "should create proper message" do
+        @message2.sender.id.should == @entity2.id
+        @message2.sender.class.should == @entity2.class
+        assert @message2.body.eql?"Reply body"
+        assert @message2.subject.eql?"RE: Subject"
+      end
+      
+      it "should create proper mails" do
+        #Sender Mail
+        mail = Receipt.recipient(@entity2).notification(@message2).first
+        assert mail
+        if mail
+          mail.is_read.should==true
+          mail.trashed.should==false
+          mail.mailbox_type.should=="sentbox"
+        end      
+        #Receiver Mail
+        mail = Receipt.recipient(@entity1).notification(@message2).first
+        assert mail
+        if mail
+          mail.is_read.should==false
+          mail.trashed.should==false
+          mail.mailbox_type.should=="inbox"
+        end
+      end
+      
+      it "should have the correct recipients" do
+        recipients = @message2.recipients
+        recipients.count.should==2
+        recipients.count(@entity1).should==1
+        recipients.count(@entity2).should==1
+      end
+      
+      it "should be associated to the same conversation" do
+        @message1.conversation.id.should==@message2.conversation.id      
+      end           
+    end
+    describe "message replying to conversation" do
+      before do
+        @receipt1 = @entity1.send_message(@entity2,"Body","Subject")
+        @receipt2 = @entity2.reply_to_conversation(@receipt1.conversation,"Reply body")
+        @message1 = @receipt1.notification
+        @message2 = @receipt2.notification
+      end
+      
+      it "should create proper message" do
+        @message2.sender.id.should == @entity2.id
+        @message2.sender.class.should == @entity2.class
+        assert @message2.body.eql?"Reply body"
+        assert @message2.subject.eql?"RE: Subject"
+      end
+      
+      it "should create proper mails" do
+        #Sender Mail
+        mail = Receipt.recipient(@entity2).notification(@message2).first
+        assert mail
+        if mail
+          mail.is_read.should==true
+          mail.trashed.should==false
+          mail.mailbox_type.should=="sentbox"
+        end      
+        #Receiver Mail
+        mail = Receipt.recipient(@entity1).notification(@message2).first
+        assert mail
+        if mail
+          mail.is_read.should==false
+          mail.trashed.should==false
+          mail.mailbox_type.should=="inbox"
+        end
+      end
+      
+      it "should have the correct recipients" do
+        recipients = @message2.recipients
+        recipients.count.should==2
+        recipients.count(@entity1).should==1
+        recipients.count(@entity2).should==1
+      end
+      
+      it "should be associated to the same conversation" do
+        @message1.conversation.id.should==@message2.conversation.id      
+      end              
+    end
+  end
 end

data/spec/models/mailbox_spec.rb

@@ -102,6 +102,23 @@ describe Mailbox do
     assert @entity2.mailbox.receipts.trash
     @entity2.mailbox.receipts.trash.count.should==0    
   end
-  
+
+  context "STI models" do
+    before do
+      @sti_entity1 = FactoryGirl.create(:commander)
+      @sti_entity2 = FactoryGirl.create(:commander)
+      @sti_mail = @sti_entity1.send_message(@sti_entity2, "Body", "Subject")
+    end
+
+    it "should add one to senders sentbox" do
+      @sti_entity1.mailbox.sentbox.count.should==1
+      @sti_entity1.mailbox.sentbox.should include(@sti_mail.conversation)
+    end
+
+    it "should add one to recievers inbox" do
+      @sti_entity2.mailbox.inbox.count.should == 1
+      @sti_entity2.mailbox.inbox.should include(@sti_mail.conversation)
+    end
+  end
   
 end

data/spec/models/receipt_spec.rb

@@ -29,5 +29,16 @@ describe Receipt do
     @mail1.is_read.should==true    
   end
   
+  context "STI models" do
+    before do
+      @entity3 = FactoryGirl.create(:commander)
+      @entity4 = FactoryGirl.create(:commander)
+      @mail2 = @entity3.send_message(@entity4, "Body", "Subject")
+    end
+	
+    it "should refer to the correct base class" do
+      @mail2.receiver_type.should == @entity3.class.base_class.to_s
+    end
+  end
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mailboxer
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-15 00:00:00.000000000 Z
+date: 2012-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: foreigner
@@ -264,7 +264,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2240527445875672830
+      hash: 1911356081747184373
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -273,7 +273,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2240527445875672830
+      hash: 1911356081747184373
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23