facteur 1.2.1 → 1.3.0

data/Rakefile

@@ -1,41 +1,19 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "facteur"
-    gem.summary = "Messaging system for Rails 3"
-    gem.description = "Facteur allows you add a messaging system in your Rails 3. You can create many mailboxes for your users. They will be able to send and receive messages."
-    gem.email = "dev@raw1z.fr"
-    gem.homepage = "http://github.com/raw1z/facteur"
-    gem.authors = ["Rawane ZOSSOU"]
-    gem.add_development_dependency "rspec", ">= 1.2.9"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
-require 'rspec/core'
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |spec|
-end
-
-RSpec::Core::RakeTask.new(:rcov) do |spec|
-end
-
-task :spec => :check_dependencies
-
-task :default => :spec
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "facteur #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec'
+require 'rspec/core/rake_task'
+
+namespace :spec do
+  Rspec::Core::RakeTask.new(:activerecord) do |t|
+    t.pattern = "./spec/activerecord/**/*_spec.rb"
+    t.rspec_opts = "--format Fuubar"
+  end
+
+  Rspec::Core::RakeTask.new(:mongoid) do |t|
+    t.pattern = "./spec/mongoid/**/*_spec.rb"
+    t.rspec_opts = "--format Fuubar"
+  end
+end
+
+

data/lib/facteur.rb

@@ -1,14 +1,25 @@
-require File.join(File.dirname(__FILE__), 'facteur/message_model')
-require File.join(File.dirname(__FILE__), 'facteur/mailbox_model')
-require File.join(File.dirname(__FILE__), 'facteur/addressee_model')
-require 'rails'
-
-module Facteur
-  module Rails
-    class Railtie < ::Rails::Railtie
-      rake_tasks do
-        load "facteur/rails/tasks/facteur.rake"
-      end
-    end
-  end
-end
+require 'active_support/concern'
+require 'active_support/dependencies/autoload'
+
+module Facteur
+  extend ActiveSupport::Autoload
+  
+  autoload :ActiveRecordMessageModel
+  autoload :MongoidMessageModel
+  autoload :MessageModel
+  autoload :ActiveRecordMailboxModel
+  autoload :MongoidMailboxModel
+  autoload :MailboxModel
+  autoload :BaseAddresseeModel
+  autoload :ActiveRecordAddresseeModel
+  autoload :MongoidAddresseeModel
+  autoload :AddresseeModel
+  
+  def self.addressee_model
+    @addressee_model || "User"
+  end
+  
+  def self.addressee_model=(model)
+    @addressee_model = model
+  end
+end

data/lib/facteur/active_record_addressee_model.rb

@@ -0,0 +1,12 @@
+require 'active_record'
+
+module Facteur
+  module ActiveRecordAddresseeModel
+    include Facteur::BaseAddresseeModel
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :mailboxes, :as => :addressee, :class_name => "Facteur::Mailbox"
+    end
+  end
+end

data/lib/facteur/active_record_mailbox_model.rb

@@ -0,0 +1,15 @@
+require 'active_record'
+
+module Facteur
+  module ActiveRecordMailboxModel
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :addressee, :polymorphic => true
+      has_many :messages, :class_name => "Facteur::Message"
+
+      validates_presence_of :name
+      validates_uniqueness_of :name, :scope => [:addressee_id, :addressee_type]
+    end
+  end
+end

data/lib/facteur/active_record_message_model.rb

@@ -0,0 +1,24 @@
+require 'active_record'
+
+module Facteur
+  module ActiveRecordMessageModel
+    extend ActiveSupport::Concern
+
+    included do
+      validates_presence_of :author_id, :mailbox_id, :body
+
+      belongs_to :mailbox,
+                 :class_name => "Facteur::Mailbox"
+      
+      belongs_to :author,
+                 :class_name => Facteur.addressee_model,
+                 :foreign_key => "author_id"
+                 
+      has_and_belongs_to_many :addressees, 
+                              :class_name => Facteur.addressee_model,
+                              :join_table => "messages_addressees",
+                              :association_foreign_key => "addressee_id"
+    end
+  end
+end
+

data/lib/facteur/addressee_model.rb

@@ -1,145 +1,44 @@
 module Facteur
   module AddresseeModel
-    def self.included(receiver)
-      receiver.class_exec do
-        include InstanceMethods
+    extend ActiveSupport::Concern
+
+    included do
+      Facteur.addressee_model = self.to_s
+      Facteur.send(:remove_const, :Mailbox) if Facteur.const_defined?(:Mailbox)
+      Facteur.send(:remove_const, :Message) if Facteur.const_defined?(:Message)
+      
+      if self.ancestors.map(&:to_s).include?("ActiveRecord::Base")
         
-        has_many :mailboxes, :as => :addressee
-        has_many :messages_sent, :class_name => "Message", :foreign_key => "author_id"
-        
-        # the addressee's mailboxes are created after its creation
-        after_create :create_mailboxes
-      end
-      
-      receiver.extend ClassMethods
-    end
-    
-    module ClassMethods
-      
-      # Define a mailbox. The following options are available:
-      # <tt>:default</tt>:: defines the default mailbox. You must choose one default mailbox
-      def mailbox(name, options={})
-        mailbox = {:name => name}
-        mailbox.merge! options
-        mailboxes << mailbox
-      end
-      
-      # Returns the mailboxes defined for the class
-      def mailboxes
-        @mailboxes ||= []
-      end
-      
-      def update_addressees_mailboxes
-        all.each do |addressee|
-          @mailboxes.each do |mailbox|
-            options = {}.merge(mailbox)
-            name = options.delete(:name)
-            addressee.create_mailbox(name, options)
-          end
+        Facteur.const_set(:Mailbox, Class.new(ActiveRecord::Base))
+        Facteur::Mailbox.class_exec do
+          include Facteur::ActiveRecordMailboxModel
         end
-      end
-    end
-    
-    module InstanceMethods
-      
-      # Sends a message to one or many addressees. The following options are available:
-      #
-      # <tt>:to</tt>:: the addressee or the list of addressees (mandatory)
-      # <tt>:in</tt>:: the name of the mailbox in which the message is posted (mandatory)
-      # <tt>:body</tt>:: the message's body (mandatory)
-      #
-      # Usage :
-      #
-      #     # send a message to one addressee
-      #     @john.send_message('message contents', :to => @peter, :in => :private_mailbox)
-      #
-      #     # send a message to many addressees
-      #     @john.send_message('message contents', :to => [@peter, @james], :in => :private_mailbox)
-      def send_message(message, options)
-        msg = nil
-        options[:body] = message
-        if options[:to].is_a? Array
-          options[:to].each do |addressee|
-            msg = send_message_to(addressee, options[:in], options[:body], options[:subject])
-          end
-        else
-          msg = send_message_to(options[:to], options[:in], options[:body], options[:subject])
+
+        Facteur.const_set(:Message, Class.new(ActiveRecord::Base))
+        Facteur::Message.class_exec do
+          include Facteur::ActiveRecordMessageModel
         end
-        msg
-      end
-      
-      # Creates a new mailbox. if a mailbox with the same name already exists, it fails and returns false. If succeeded, it creates an accessor for the new mail box and returns true.
-      # Example :
-      #
-      #     class User < ActiveRecord::base
-      #        include Facteur::AddresseeModel
-      #        
-      #        mailbox :private_mailbox
-      #     end
-      #
-      # The previous declaration will add : User#private_mailbox
-      #     
-      #     # supposing that a name field exists
-      #     user = User.new(:name => 'John')
-      #     user.create_mailbox :public_mailbox #=> return true
-      #     user.create_mailbox :private_mailbox #=> return false
-      def create_mailbox(name, options={})
-        mailbox = Mailbox.new(:name => name.to_s)
-        mailbox.addressee = self
-        mailbox.default = options[:default]
-        return false if mailbox.save == false
         
-        @default_mailbox = name if options[:default]                
-        true
-      end
-      
-      # Creates a new mailbox. if a mailbox with the same name already exists, it raises an exception. If succeeded, it creates an accessor for the new mail box and returns the created mailbox.
-      def create_mailbox!(name, options={})
-        if create_mailbox(name, options) == false
-          raise "Mailboxes names must be unique. Can't create '#{name}'"
-        end
-        self.send "#{name}"
-      end
+        include Facteur::ActiveRecordAddresseeModel
       
-      # generates the mailboxes accessors
-      def method_missing(method, *args, &block)
-        super if method == :to_ary
+      elsif self.ancestors.map(&:to_s).include?("Mongoid::Document")
         
-        begin
-          super
-        rescue NoMethodError
-          mailbox = Mailbox.find(:first, :conditions => {:name => method.to_s, :addressee_id => self.attributes["id"], :addressee_type => self.class.to_s})
-          return mailbox unless mailbox.nil?
-          super
+        Facteur.const_set(:Mailbox, Class.new)
+        Facteur::Mailbox.class_exec do
+          include Mongoid::Document
+          include Facteur::MongoidMailboxModel
         end
-        
-      end
-      
-      private
-      
-      # creates the mailboxes defined in the configuration
-      def create_mailboxes
-        self.class.mailboxes.each do |mailbox|
-          options = {}.merge(mailbox)
-          name = options.delete(:name)
-          create_mailbox!(name, options)
+
+        Facteur.const_set(:Message, Class.new)
+        Facteur::Message.class_exec do
+          include Mongoid::Document
+          include Facteur::MongoidMessageModel
         end
-      end
-      
-      # send a message to an addressee
-      def send_message_to(addressee, mailbox_name, contents, subject=nil)
-        return false if addressee.nil? or contents.nil?
         
-        mailbox_name = @default_mailbox if mailbox_name.nil?
-        return false if mailbox_name.nil?
+        include Facteur::MongoidAddresseeModel
         
-        message = Message.new
-        message.author = self
-        message.mailbox = addressee.send(mailbox_name)
-        message.body = contents
-        message.subject = subject
-        message.save
-        message
+      else
+        raise "Facteur only supports ActiveRecord and Mongoid"
       end
     end
   end

data/lib/facteur/base_addressee_model.rb

@@ -0,0 +1,163 @@
+module Facteur
+  module BaseAddresseeModel
+    extend ActiveSupport::Concern
+        
+    module ClassMethods
+      # Define a mailbox. The following options are available:
+      # <tt>:default</tt>:: defines the default mailbox. You must choose one default mailbox
+      def mailbox(name, options={})
+        mailbox = {:name => name}
+        mailbox.merge! options
+        mailboxes << mailbox
+      end
+      
+      # Returns the mailboxes defined for the class
+      def mailboxes
+        @mailboxes ||= []
+      end
+      
+      # check if a mailbox is defined
+      def has_mailbox?(name)
+        @mailboxes.each do |mailbox|
+          return true if mailbox[:name] == name
+        end
+        false
+      end
+      
+      # return the default mailbox name if set, else return nil
+      def default_mailbox
+        @mailboxes.select{ |mailbox| mailbox[:default] == true }.first[:name]
+      end
+    end
+    
+    module InstanceMethods
+      #  returns the messages sent by this addressee
+      def sent_messages
+        sent_messages_mailbox.messages
+      end
+      
+      # Sends a message to one or many addressees. The following options are available:
+      #
+      # <tt>:to</tt>:: the addressee or the list of addressees (mandatory)
+      # <tt>:in</tt>:: the name of the mailbox in which the message is posted (mandatory)
+      # <tt>:body</tt>:: the message's body (mandatory)
+      #
+      # Usage :
+      #
+      #     # send a message to one addressee
+      #     @john.send_message('message contents', :to => @peter, :in => :private_mailbox)
+      #
+      #     # send a message to many addressees
+      #     @john.send_message('message contents', :to => [@peter, @james], :in => :private_mailbox)
+      def send_message(message, options)
+        options[:body] = message
+        if options[:to].respond_to?(:each)
+          options[:to].each { |addressee| send_message_to(addressee, options[:in], options[:body], options[:subject]) }
+        else
+          send_message_to(options[:to], options[:in], options[:body], options[:subject])
+        end
+        
+        store_in_sent_messages(message, options)
+      end
+      
+      # Creates a new mailbox. if a mailbox with the same name already exists, it fails and returns false. If succeeded, it creates an accessor for the new mail box and returns true.
+      # Example :
+      #
+      #     class User < ActiveRecord::base
+      #        include Facteur::AddresseeModel
+      #        
+      #        mailbox :private_mailbox
+      #     end
+      #
+      # The previous declaration will add : User#private_mailbox
+      #     
+      #     # supposing that a name field exists
+      #     user = User.new(:name => 'John')
+      #     user.create_mailbox :public_mailbox #=> return true
+      #     user.create_mailbox :private_mailbox #=> return false
+      def create_mailbox(name, options={})
+        mailbox = mailboxes.build(:name => name.to_s, :default => options[:default])
+        return false if mailbox.save == false
+        mailbox
+      end
+      
+      # Creates a new mailbox. if a mailbox with the same name already exists, it raises an exception. If succeeded, it creates an accessor for the new mail box and returns the created mailbox.
+      def create_mailbox!(name, options={})
+        if create_mailbox(name, options) == false
+          raise "Mailboxes names must be unique. Can't create '#{name}'"
+        end
+        self.send "#{name}"
+      end
+      
+      # generates the mailboxes accessors
+      def method_missing(method, *args, &block)      
+        begin
+          super
+        rescue NoMethodError, NameError
+          mailbox = self.mailboxes.where(:name => method.to_s).first
+          if mailbox.nil?
+            super unless self.class.has_mailbox?(method)
+            
+            # if the unknown method matches one of the Model mailboxes, then the mailbox is created
+            create_mailbox(method, self.class.mailboxes.select{ |m| m[:name] == method }.first)
+          else
+            return mailbox
+          end
+        end
+      end
+      
+      # redefine the comparison method because for some weirds reasons, the original fails
+      def ==(comparison_object)
+        comparison_object.equal?(self) ||
+          (self.class.to_s == comparison_object.class.to_s &&
+            comparison_object.id == id && !comparison_object.new_record?)
+      end
+      
+      private
+      
+      # return the sent messages mailbox
+      def sent_messages_mailbox
+        mailbox = self.mailboxes.where(:name => "sent_messages_mailbox").first
+        mailbox || create_mailbox("sent_messages_mailbox")
+      end
+      
+      # creates the mailboxes defined in the configuration
+      def create_mailboxes
+        self.class.mailboxes.each do |mailbox|
+          options = {}.merge(mailbox)
+          name = options.delete(:name)
+          create_mailbox!(name, options)
+        end
+      end
+      
+      # send a message to an addressee
+      def send_message_to(addressee, mailbox_name, contents, subject=nil)
+        return false if addressee.nil? or contents.nil?
+      
+        mailbox_name = self.class.default_mailbox if mailbox_name.nil?
+        return false if mailbox_name.nil?
+      
+        message = addressee.send(mailbox_name).messages.build(:subject => subject, :body => contents)
+        message.author = self
+        message.save ? message : false
+      end
+      
+      # saves a message in the sent messages mailbox
+      def store_in_sent_messages(message, options)
+        # the addressees must be given
+        return false if options[:to].blank?
+        
+        sent_message = sent_messages_mailbox.messages.build(:subject => options[:subject], :body => options[:body])
+        sent_message.author = self
+        
+        if options[:to].respond_to?(:each)
+          options[:to].each { |addressee| sent_message.addressees << addressee }
+        else
+          sent_message.addressees << options[:to]
+        end
+        
+        sent_message.save ? sent_message : false
+      end
+    end
+  end
+end