acts_as_chattable 0.0.1

data/gemfiles/Gemfile-3.0

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec :path => File.expand_path('../..', __FILE__)
+gem "activerecord", "~> 3.0.0"
+gem "activesupport", "~> 3.0.0"
+gem "railties", "~> 3.0.0"

data/gemfiles/Gemfile-3.1

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec :path => File.expand_path('../..', __FILE__)
+gem "activerecord", "~> 3.1.0"
+gem "activesupport", "~> 3.1.0"
+gem "railties", "~> 3.1.0"

data/gemfiles/Gemfile-3.2

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec :path => File.expand_path('../..', __FILE__)
+gem "activerecord", "~> 3.2.0"
+gem "activesupport", "~> 3.2.0"
+gem "railties", "~> 3.2.0"

data/gemfiles/Gemfile-4.0

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec :path => File.expand_path('../..', __FILE__)
+gem "activerecord", "~> 4.0.0"
+gem "activesupport", "~> 4.0.0"
+gem "railties", "~> 4.0.0"

data/lib/acts_as_chattable.rb

@@ -0,0 +1,17 @@
+module ActsAsChattable
+  autoload :Model,    'acts_as_chattable/model'
+  autoload :Message,  'acts_as_chattable/message'
+  autoload :Relation, 'acts_as_chattable/relation'
+  autoload :Rails3,   'acts_as_chattable/rails3'
+  autoload :Rails4,   'acts_as_chattable/rails4'
+
+  def self.rails_api
+    if Rails::VERSION::MAJOR >= 4
+      Rails4
+    else
+      Rails3
+    end
+  end
+end
+
+require 'acts_as_chattable/railtie'

data/lib/acts_as_chattable/message.rb

@@ -0,0 +1,75 @@
+module ActsAsChattable
+  class Message < ::ActiveRecord::Base
+    belongs_to :received_messageable, :polymorphic => true
+    belongs_to :sent_messageable,     :polymorphic => true
+
+    attr_accessor   :removed, :restored
+    cattr_accessor  :required
+
+    ActsAsChattable.rails_api.new(self).default_scope("created_at desc")
+
+    scope :are_from,          lambda { |*args| where(:sent_messageable_id => args.first, :sent_messageable_type => args.first.class.name) }
+    scope :are_to,            lambda { |*args| where(:received_messageable_id => args.first, :received_messageable_type => args.first.class.name) }
+    scope :connected_with,    lambda { |*args|  where("(sent_messageable_type = :sent_type and
+                                                sent_messageable_id = :sent_id and
+                                                sender_delete = :s_delete and sender_permanent_delete = :s_perm_delete) or
+                                                (received_messageable_type = :received_type and
+                                                received_messageable_id = :received_id and
+                                                recipient_delete = :r_delete and recipient_permanent_delete = :r_perm_delete)",
+                                                :sent_type      => args.first.class.resolve_active_record_ancestor.to_s,
+                                                :sent_id        => args.first.id,
+                                                :received_type  => args.first.class.resolve_active_record_ancestor.to_s,
+                                                :received_id    => args.first.id,
+                                                :r_delete       => args.last,
+                                                :s_delete       => args.last,
+                                                :r_perm_delete  => false,
+                                                :s_perm_delete  => false)
+                                     }
+    scope :readed,            lambda { where(:opened => true)  }
+    scope :unreaded,          lambda { where(:opened => false) }
+    scope :deleted,           lambda { where(:recipient_delete => true, :sender_delete => true) }
+
+    def open?
+      self.opened?
+    end
+
+    def open
+      update_attributes!(:opened => true)
+    end
+    alias :mark_as_read :open
+    alias :read         :open
+
+    def close
+      update_attributes!(:opened => false)
+    end
+    alias :mark_as_unread :close
+    alias :unread         :close
+
+    alias :from :sent_messageable
+    alias :to   :received_messageable
+
+    def real_receiver(user)
+      user == from ? to : from
+    end
+
+    def participant?(user)
+      (to == user) || (from == user)
+    end
+
+    def conversation
+      root.subtree
+    end
+
+    def delete
+      self.removed = true
+    end
+
+    def restore
+      self.restored = true
+    end
+
+    def people
+      conversation.map{ |x| x.from }.uniq!
+    end
+  end
+end

data/lib/acts_as_chattable/model.rb

@@ -0,0 +1,159 @@
+module ActsAsChattable
+  module Model
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      mattr_accessor :messages_class_name
+
+      # Method make ActiveRecord::Base object chattable
+      # @param [Symbol] :table_name - table name for messages
+      # @param [String] :class_name - message class name
+      # @param [Array, Symbol] :required - required fields in message
+      # @param [Symbol] :dependent - dependent option from ActiveRecord has_many method
+      def acts_as_chattable(options = {})
+        default_options = {
+          :table_name => "messages",
+          :class_name => "ActsAsChattable::Message",
+          :required => [:body],
+          :dependent => :nullify
+        }
+        options = default_options.merge(options)
+
+        has_many  :received_messages_relation,
+                  :as => :received_messageable,
+                  :class_name => options[:class_name],
+                  :dependent => options[:dependent]
+        has_many  :sent_messages_relation,
+                  :as => :sent_messageable,
+                  :class_name => options[:class_name],
+                  :dependent => options[:dependent]
+
+        self.messages_class_name = options[:class_name].constantize
+
+        if self.messages_class_name.respond_to?(:table_name=)
+          self.messages_class_name.table_name = options[:table_name]
+        else
+          self.messages_class_name.set_table_name(options[:table_name])
+          ActiveSupport::Deprecation.warn("Calling set_table_name is deprecated. Please use `self.table_name = 'the_name'` instead.")
+        end
+
+        self.messages_class_name.required = Array.wrap(options[:required])
+        self.messages_class_name.validates_presence_of self.messages_class_name.required
+
+        include ActsAsChattable::Model::InstanceMethods
+    end
+
+    # Method recognize real object class
+    # @return [ActiveRecord::Base] class or relation object
+    def resolve_active_record_ancestor
+      self.reflect_on_association(:received_messages_relation).active_record
+    end
+
+    end
+
+    module InstanceMethods
+      # @return [ActiveRecord::Relation] all messages connected with user
+      def messages(trash = false)
+        result = self.class.messages_class_name.connected_with(self, trash)
+        result.relation_context = self
+
+        result
+      end
+
+      # @return [ActiveRecord::Relation] returns all messages from inbox
+      def received_messages
+        result = ActsAsChattable.rails_api.new(received_messages_relation)
+        result = result.scoped.where(:recipient_delete => false)
+        result.relation_context = self
+
+        result
+      end
+
+      # @return [ActiveRecord::Relation] returns all messages from outbox
+      def sent_messages
+        result = ActsAsChattable.rails_api.new(sent_messages_relation)
+        result = result.scoped.where(:sender_delete => false)
+        result.relation_context = self
+
+        result
+      end
+
+      # @return [ActiveRecord::Relation] returns all messages from trash
+      def deleted_messages
+        messages true
+      end
+
+      # Method sens message to another user
+      # @param [ActiveRecord::Base] to
+      # @param [String] topic
+      # @param [String] body
+      #
+      # @return [ActsAsChattable::Message] the message object
+      def send_message(to, *args)
+        message_attributes = {}
+
+        case args.first
+          when String
+            self.class.messages_class_name.required.each_with_index do |attribute, index|
+              message_attributes[attribute] = args[index]
+            end
+          when Hash
+            message_attributes = args.first
+        end
+
+        message = self.class.messages_class_name.new message_attributes
+        message.received_messageable = to
+        message.sent_messageable = self
+        message.save
+
+        message
+      end
+
+      # Method send message to another user
+      # and raise exception in case of validation errors
+      # @param [ActiveRecord::Base] to
+      # @param [String] topic
+      # @param [String] body
+      #
+      # @return [ActsAsChattable::Message] the message object
+      def send_message!(to, *args)
+        send_message(to, *args).save!
+      end
+
+      # Mark message as deleted
+      def delete_message(message)
+        current_user = self
+
+        case current_user
+          when message.to
+            attribute = message.recipient_delete ? :recipient_permanent_delete : :recipient_delete
+          when message.from
+            attribute = message.sender_delete ? :sender_permanent_delete : :sender_delete
+          else
+            raise "#{current_user} can't delete this message"
+        end
+
+        message.update_attributes!(attribute => true)
+      end
+
+      # Mark message as restored
+      def restore_message(message)
+        current_user = self
+
+        case current_user
+          when message.to
+            attribute = :recipient_delete
+          when message.from
+            attribute = :sender_delete
+          else
+            raise "#{current_user} can't restore this message"
+        end
+
+        message.update_attributes!(attribute => false)
+      end
+    end
+  end
+end

data/lib/acts_as_chattable/rails3.rb

@@ -0,0 +1,15 @@
+module ActsAsChattable
+  class Rails3
+    def initialize(subject)
+      @subject = subject
+    end
+
+    def default_scope(order_by)
+      @subject.send(:default_scope, order(order_by))
+    end
+
+    def method_missing(name, *args)
+      @subject.send(name, *args)
+    end
+  end
+end

data/lib/acts_as_chattable/rails4.rb

@@ -0,0 +1,19 @@
+module ActsAsChattable
+  class Rails4
+    def initialize(subject)
+      @subject = subject
+    end
+
+    def default_scope(order_by)
+      @subject.default_scope { order(order_by) }
+    end
+
+    def scoped
+      @subject.scope
+    end
+
+    def method_missing(name, *args)
+      @subject.send(name, *args)
+    end
+  end
+end

data/lib/acts_as_chattable/railtie.rb

@@ -0,0 +1,14 @@
+require 'active_record/railtie'
+require 'active_support/core_ext'
+
+module ActsAsChattable
+  class Railtie < Rails::Railtie
+    if defined?(ActiveRecord::Base)
+      ActiveRecord::Base.send :include, ActsAsChattable::Model
+    end
+
+    if defined?(ActiveRecord::Relation)
+      ActiveRecord::Relation.send :include, ActsAsChattable::Relation
+    end
+  end
+end

data/lib/acts_as_chattable/relation.rb

@@ -0,0 +1,17 @@
+module ActsAsChattable
+  module Relation
+    attr_accessor :relation_context
+
+    def process(context = self.relation_context, &block)
+      self.each do |message|
+        block.call(message) if block_given?
+        context.delete_message(message)   if message.removed
+        context.restore_message(message)  if message.restored
+      end
+    end
+
+    def conversations
+      map { |r| r.root.subtree.order("id desc").first }.uniq
+    end
+  end
+end

data/lib/generators/acts_as_chattable/migration/migration_generator.rb

@@ -0,0 +1,21 @@
+require 'rails/generators/migration'
+require 'rails/generators/active_record'
+
+module ActsAsChattable
+  class MigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    namespace "acts_as_chattable:migration"
+
+    source_root File.join(File.dirname(__FILE__), 'templates')
+
+    def self.next_migration_number(dirname)
+      ActiveRecord::Generators::Base.next_migration_number(dirname)
+    end
+
+    def create_migration_file
+      migration_template 'migration.rb', 'db/migrate/create_messages_table.rb' rescue nil
+      migration_template 'migration_permanent.rb', 'db/migrate/add_recipient_permanent_delete_and_sender_permanent_delete_to_messages.rb' rescue nil
+    end
+  end
+end

data/lib/generators/acts_as_chattable/migration/templates/migration.rb

@@ -0,0 +1,20 @@
+class CreateMessagesTable < ActiveRecord::Migration
+  def self.up
+    create_table :messages do |t|
+      t.text :body
+      t.string :attachment
+      t.references :received_messageable, :polymorphic => true
+      t.references :sent_messageable, :polymorphic => true
+      t.boolean :opened, :default => false
+      t.boolean :recipient_delete, :default => false
+      t.boolean :sender_delete, :default => false
+      t.timestamps
+    end
+
+    add_index :messages, [:sent_messageable_id, :received_messageable_id], :name => "acts_as_chattable_ids"
+  end
+
+  def self.down
+    drop_table :messages
+  end
+end

data/lib/generators/acts_as_chattable/migration/templates/migration_permanent.rb

@@ -0,0 +1,11 @@
+class AddRecipientPermanentDeleteAndSenderPermanentDeleteToMessages < ActiveRecord::Migration
+  def self.up
+    add_column :messages, :recipient_permanent_delete, :boolean, :default => false
+    add_column :messages, :sender_permanent_delete, :boolean, :default => false
+  end
+
+  def self.down
+    remove_column :messages, :recipient_permanent_delete
+    remove_column :messages, :sender_permanent_delete
+  end
+end

data/spec/acts_as_chattable_spec.rb

@@ -0,0 +1,253 @@
+require 'spec_helper'
+
+describe "ActsAsChattable" do
+  before do
+    User.acts_as_chattable
+    @message = send_message
+  end
+
+  describe "send messages" do
+    it "alice should have one message" do
+      @alice.messages.count.should == 1
+    end
+
+    it "alice should have one message from bob" do
+      @alice.messages.are_from(@bob).count.should == 1
+    end
+
+    it "bob should have one message" do
+      @bob.messages.count.should == 1
+    end
+
+    it "bob should have one message to alice in outbox" do
+      @bob.sent_messages.are_to(@alice).count.should == 1
+    end
+
+    it "bob should have one open message from alice" do
+      @alice.messages.are_from(@bob).process { |m| m.open }
+      @alice.messages.readed.count.should == 1
+    end
+  end
+
+  describe "send messages with bang" do
+    it "should return message object" do
+      @alice.send_message!(@bob, :body => "body", :attachment => "test").should 
+        be_kind_of ActsAsChattable::Message
+    end
+  end
+
+  describe "inheritance models" do
+    it "men send message to alice" do
+      send_message(@men, @alice)
+      @men.sent_messages.size.should be_equal(1)
+      @alice.received_messages.size.should be_equal(2)
+    end
+
+    it "messages method should receive all messages connected with user" do
+      send_message(@men, @alice)
+      @men.messages.size.should be_equal(1)
+    end
+
+    it "men send message and receive from alice" do
+      send_message(@men, @alice)
+      send_message(@alice, @men)
+
+      @men.messages.size.should be_equal(2)
+      @men.sent_messages.size.should be_equal(1)
+      @men.received_messages.size.should be_equal(1)
+    end
+  end
+
+  describe "delete messages" do
+
+    it "bob should have one deleted message from alice" do
+      @bob.messages.process do |m|
+        m.delete
+      end
+
+      @bob.messages.each do |m|
+        m.recipient_delete.should == true
+        m.sender_delete.should == false
+      end
+
+      @bob.deleted_messages.count.should == 1
+      @bob.messages.count.should == 0
+    end
+
+    it "received_messages and sent_messages should work with .process method" do
+      @bob.sent_messages.count.should == 1
+      @alice.received_messages.count.should == 1
+
+      @bob.sent_messages.process { |m| m.delete }
+      @bob.sent_messages.count.should == 0
+      @alice.received_messages.count.should == 1
+
+      @alice.received_messages.process { |m| m.delete }
+      @alice.received_messages.count.should == 0
+    end
+
+    it "message should permanent delete" do
+      @alice.messages.process { |m| m.delete }
+      @alice.messages.count.should == 0
+
+      @alice.deleted_messages.count.should == 1
+      @alice.deleted_messages.process { |m| m.delete }
+      @alice.deleted_messages.count.should == 0
+
+      @message.reload
+      @message.recipient_permanent_delete.should == true
+
+      @bob.sent_messages.count.should == 1
+    end
+
+    it "pat should not able to delete message" do
+      lambda { @pat.delete_message(@message) }.should raise_error
+    end
+  end
+
+  describe "restore message" do
+    it "alice should restore message" do
+      @alice.received_messages.process { |m| m.delete }
+      @alice.restore_message(@message.reload)
+      @alice.received_messages.count.should == 1
+    end
+
+    it "should works with relation" do
+      @alice.received_messages.process { |m| m.delete }
+      @alice.received_messages.count.should == 0
+      @alice.deleted_messages.process { |m| m.restore }
+      @alice.received_messages.count.should == 1
+    end
+
+    it "pat should not able to restore message" do
+      lambda { @pat.restore_message(@message) }.should raise_error
+    end
+  end
+
+  describe "read/unread feature" do
+    it "alice should have one unread message from bob" do
+      @alice.messages.are_from(@bob).unreaded.count.should == 1
+      @alice.messages.are_from(@bob).readed.count.should == 0
+    end
+
+    it "alice should able to read message from bob" do
+      @alice.messages.are_from(@bob).first.read
+      @alice.messages.are_from(@bob).unreaded.count.should == 0
+    end
+
+    it "alice should able to unread message from bob" do
+      @alice.messages.are_from(@bob).first.read
+      @alice.messages.are_from(@bob).first.unread
+      @alice.messages.are_from(@bob).unreaded.count.should == 1
+    end
+
+    it "alice should able to get datetime when he read bob message" do
+      @alice.messages.are_from(@bob).first.read
+      read_datetime = @alice.messages.are_from(@bob).first.updated_at
+      @alice.messages.are_from(@bob).reorder("updated_at asc").first.updated_at.should == read_datetime
+    end
+  end
+
+  it "finds proper message" do
+    @bob.messages.find(@message.id) == @message
+  end
+
+  it "message should have proper body" do
+    @bob.messages.count.should == 1
+    @bob.messages.first.body == "Body"
+  end
+
+  # describe "conversation" do
+  #   it "bob send message to alice, and alice reply to bob message and show proper tree" do
+  #     @reply_message =  @alice.reply_to(@message, "Re: Topic", "Body")
+
+  #     @reply_message.conversation.size.should == 2
+  #     @reply_message.conversation.last.topic.should == "Topic"
+  #     @reply_message.conversation.first.topic.should == "Re: Topic"
+  #   end
+
+  #   it "bob send message to alice, alice answer, and bob answer for alice answer" do
+  #     @reply_message = @alice.reply_to(@message, "Re: Topic", "Body")
+  #     @reply_reply_message = @bob.reply_to(@reply_message, "Re: Re: Topic", "Body")
+
+  #     [@message, @reply_message, @reply_reply_message].each do |m|
+  #       m.conversation.size.should == 3
+  #     end
+
+  #     @message.conversation.first.should == @reply_reply_message
+  #     @reply_reply_message.conversation.first.should == @reply_reply_message
+  #   end
+  # end
+
+  # describe "conversations" do
+  #   before do
+  #     @reply_message = @message.reply("Re: Topic", "Body")
+  #     @reply_reply_message = @reply_message.reply("Re: Re: Topic", "Body")
+  #   end
+
+  #   it "bob send message to alice and alice reply" do
+  #     @bob.messages.conversations.should == [@reply_reply_message]
+  #     @reply_message.conversation.should == [@reply_reply_message, @reply_message, @message]
+  #   end
+
+  #   it "show conversations in proper order" do
+  #     @sec_message = @bob.send_message(@alice, "Hi", "Alice!")
+  #     @sec_reply = @sec_message.reply("Re: Hi", "Fine!")
+  #     @bob.received_messages.conversations.map(&:id).should == [@sec_reply.id, @reply_reply_message.id]
+  #     @sec_reply.conversation.to_a.should == [@sec_reply, @sec_message]
+  #   end
+  # end
+
+  # describe "search text from messages" do
+  #   before do
+  #     @reply_message = @message.reply("Re: Topic", "Body : I am fine")
+  #     @reply_reply_message = @reply_message.reply("Re: Re: Topic", "Fine too")
+  #   end
+
+  #   it "bob should be able to search text from messages" do
+  #     recordset = @bob.messages.search("I am fine")
+  #     recordset.count.should == 1
+  #     recordset.should_not be_nil
+  #   end
+  # end
+
+  # describe "send messages with hash" do
+  #   it "send message with hash" do
+  #     @message = @bob.send_message(@alice, {:body => "Body", :topic => "Topic"})
+  #     @message.topic.should == "Topic"
+  #     @message.body.should == "Body"
+  #   end
+  # end
+
+  it "messages should return in right order :created_at" do
+    @message = send_message(@bob, @alice, "Example", "Example Body")
+    @alice.messages.last.body.should == "Body"
+  end
+
+  it "received_messages should return unloaded messages" do
+    @alice.received_messages.loaded?.should be_false
+  end
+
+  it "sent_messages should return unloaded messages" do
+    @bob.sent_messages.loaded?.should be_false
+  end
+
+  describe "send messages between two different models (the same id)" do
+    it "should have the same id" do
+      @alice.id.should be_equal(@admin.id)
+    end
+
+    it "bob send message to admin (different model) with the same id" do
+      @bob.send_message(@alice, "hello", "alice")
+      @alice.messages.are_to(@alice).size.should be_equal(2)
+      @alice.messages.are_to(@admin).size.should be_equal(0)
+    end
+
+    it "admin send message to bob" do
+      @admin.send_message(@bob, "hello", "bob")
+      @bob.messages.are_from(@admin).size.should be_equal(1)
+      @bob.messages.are_from(@alice).size.should be_equal(0)
+    end
+  end
+
+end