message_train 0.6.17 → 0.7.1

data/app/models/message_train/conversation.rb

@@ -7,61 +7,90 @@ module MessageTrain
     has_many :attachments, through: :messages
 
     # Scopes
-    default_scope { order(updated_at: :desc) }
+    scope :by_ignored, ->(p, flag) { flag ? ignored(p) : unignored(p) }
+
     scope :ignored, ->(participant) { where(id: ignored_ids_for(participant)) }
+
     scope :unignored, (lambda do |participant|
       where.not(id: ignored_ids_for(participant))
     end)
+
     scope :with_drafts_by, (lambda do |participant|
-      joins(:messages).where(
-        message_train_messages: {
-          id: messages.drafts.with_receipts_by(participant)
-        }
-      )
+      messages.drafts.with_receipts_by(participant).conversations
     end)
+
     scope :with_ready_for, (lambda do |participant|
-      joins(:messages).where(
-        message_train_messages: {
-          id: messages.ready.with_receipts_for(participant)
-        }
-      )
+      messages.ready.with_receipts_for(participant).conversations
     end)
+
     scope :with_messages_for, (lambda do |participant|
-      joins(:messages).where(
-        message_train_messages: {
-          id: messages.with_receipts_for(participant)
-        }
-      )
+      messages.with_receipts_for(participant).conversations
+    end)
+
+    scope :without_trashed_for, (lambda do |participant|
+      where.not(id: messages.with_trashed_for(participant).conversations)
     end)
+
+    scope :without_deleted_for, (lambda do |participant|
+      where.not(id: messages.with_deleted_for(participant).conversations)
+    end)
+
     scope :with_messages_through, (lambda do |participant|
-      joins(:messages).where(
-        message_train_messages: {
-          id: messages.with_receipts_through(participant)
-        }
-      )
+      messages.with_receipts_through(participant).conversations
     end)
 
     scope :filter_by_receipt_method, (lambda do |receipt_method, participant|
-      where(
-        id: where(nil).messages.receipts.send(receipt_method, participant)
-              .conversation_ids
-      )
+      messages.receipts.send(receipt_method, participant).conversations
+    end)
+
+    scope :filter_by_division, (lambda do |division|
+      found = if division == :drafts
+                with_drafts_by(participant)
+              else
+                with_ready_for(participant)
+              end
+      found.by_ignored(participant, division == :ignored)
     end)
 
-    scope :ignored_ids_for, (lambda do |participant|
+    scope :filter_by_preposition, (lambda do |prep, *args|
+      messages.filter_by_receipt_method(prep, *args).conversations
+    end)
+
+    scope :filter_by_status_and_preposition, (lambda do |status, prep, *args|
+      case status
+      when :ready, :drafts
+        messages.send(status)
+                .filter_by_receipt_method(prep, *args)
+                .conversations
+      when :messages
+        filter_by_preposition(prep, *args)
+      else
+        filter_by_receipt_method("#{status}_#{prep}", *args)
+      end
+    end)
+
+    def self.ignored_ids_for(participant)
       MessageTrain::Ignore.find_all_by_participant(participant)
                           .pluck(:message_train_conversation_id)
-    end)
+    end
+
+    def self.messages
+      MessageTrain::Message.for_conversations(ids)
+    end
 
     def default_recipients_for(sender)
-      default_recipients = []
-      messages.with_receipts_for(sender).each do |conversation|
-        conversation.receipts.each do |receipt|
-          default_recipients << receipt.recipient
-        end
-      end
+      default_recipients = messages.with_receipts_for(sender).map do |c|
+        c.receipts.map(&:recipient)
+      end.flatten.uniq
       default_recipients.delete(sender)
-      default_recipients.flatten.uniq
+      default_recipients
+    end
+
+    def new_reply(args)
+      args[:reply_recipients] = default_recipients_for(args.delete(:box).parent)
+      args[:subject] = "Re: #{subject}"
+      args[:body] = "<blockquote>#{messages.last.body}</blockquote><p></p>"
+      messages.build(args)
     end
 
     def participant_ignore(participant)
@@ -73,88 +102,56 @@ module MessageTrain
     end
 
     def participant_ignored?(participant)
-      if ignores.empty?
-        false
-      else
-        !ignores.find_all_by_participant(participant).empty?
-      end
+      ignores.empty? ? false : ignores.find_all_by_participant(participant).any?
     end
 
     def mark(mark, participant)
       messages.mark(mark, participant)
     end
 
-    def self.messages
-      MessageTrain::Message.joins(:conversation).where(conversation: where(nil))
-    end
-
-    def method_missing(method_sym, *arguments, &block)
-      # the first argument is a Symbol, so you need to_s it if you want to
-      # pattern match
-      if method_sym.to_s =~ /^includes_((.*)_(by|to|for|through))\?$/
-        case Regexp.last_match[2]
-        when 'ready', 'drafts'
-          if Regexp.last_match[3] == 'by'
-            messages.send(Regexp.last_match[2]).by(arguments.first).any?
-          else
-            messages.send(Regexp.last_match[2]).receipts.send(
-              "receipts_#{Regexp.last_match[3]}".to_sym,
-              arguments.first
-            ).any?
-          end
-        else
-          receipts.send(Regexp.last_match[1].to_sym, arguments.first).any?
-        end
-      else
-        super
-      end
+    def method_missing(method_sym, *args, &block)
+      string = method_sym.to_s
+      return super unless string =~ /\Aincludes_(.*)_(by|to|for|through)\?\z/
+      includes_matches_with_preposition?(
+        Regexp.last_match[1].to_sym, Regexp.last_match[2].to_sym, *args
+      )
     end
 
-    def self.method_missing(method_sym, *arguments, &block)
-      # the first argument is a Symbol, so you need to_s it if you want to
-      # pattern match
-      if method_sym.to_s =~ /^with_((.*)_(by|to|for|through))$/
-        case Regexp.last_match[2]
-        when 'ready', 'drafts'
-          messages.send(
-            Regexp.last_match[2]
-          ).filter_by_receipt_method(
-            "receipts_#{Regexp.last_match[3]}".to_sym,
-            arguments.first
-          ).conversations
-        when 'messages'
-          messages.filter_by_receipt_method(
-            "receipts_#{Regexp.last_match[3]}".to_sym,
-            arguments.first
-          ).conversations
-        else
-          filter_by_receipt_method(
-            Regexp.last_match[1].to_sym,
-            arguments.first
-          )
-        end
-      else
-        super
+    def includes_matches_with_preposition?(flag, prep, *args)
+      unless [:ready, :drafts].include? flag
+        return includes_matching_receipts?("#{flag}_#{prep}".to_sym, *args)
       end
+      return includes_matching_messages_by?(flag, *args) if prep == 'by'
+      includes_matching_messages_with_prep?(flag, prep, *args)
     end
 
-    # It's important to know Object defines respond_to to take two parameters:
-    # the method to check, and whether to include private methods
-    # http://www.ruby-doc.org/core/classes/Object.html#M000333
-    def respond_to?(method_sym, include_private = false)
-      if method_sym.to_s =~ /^includes_((.*)_(by|to|for|through))\?$/
-        true
-      else
-        super
-      end
+    def includes_matching_receipts?(match_method_sym, *args)
+      receipts.send(match_method_sym, *args).any?
     end
 
-    def self.respond_to?(method_sym, include_private = false)
-      if method_sym.to_s =~ /^with_(.*)_(by|to|for|through)$/
-        true
-      else
-        super
-      end
+    def respond_to_missing?(method_sym, include_private = false)
+      method_sym.to_s =~ /\Aincludes_.*_(by|to|for|through)\?\z/ || super
+    end
+
+    def self.method_missing(method_sym, *args, &block)
+      return super unless method_sym.to_s =~ /^with_(.*)_(by|to|for|through)$/
+      status = Regexp.last_match[1].to_sym
+      preposition = Regexp.last_match[2].to_sym
+      filter_by_status_and_preposition(status, preposition, *args)
+    end
+
+    def self.respond_to_missing?(method_sym, include_private = false)
+      method_sym.to_s =~ /^with_(.*)_(by|to|for|through)$/ || super
+    end
+
+    protected
+
+    def includes_matching_messages_by?(flag, *args)
+      messages.send(flag).by(*args).any?
+    end
+
+    def includes_matching_messages_with_prep?(flag, preposition, *args)
+      messages.send(flag).receipts.flagged(preposition, *args).any?
     end
   end
 end

data/app/models/message_train/ignore.rb

@@ -1,6 +1,22 @@
 module MessageTrain
   # Ignore model
   class Ignore < ActiveRecord::Base
+    IGNORE_METHODS = {
+      'Hash' => :ignore_hash,
+      'Array' => :ignore_array,
+      'String' => :ignore_id,
+      'Fixnum' => :ignore_id,
+      'MessageTrain::Conversation' => :ignore_conversation
+    }.freeze
+
+    UNIGNORE_METHODS = {
+      'Hash' => :unignore_hash,
+      'Array' => :unignore_array,
+      'String' => :unignore_id,
+      'Fixnum' => :unignore_id,
+      'MessageTrain::Conversation' => :unignore_conversation
+    }.freeze
+
     belongs_to :participant, polymorphic: true
     belongs_to(
       :conversation,
@@ -14,11 +30,74 @@ module MessageTrain
       where(participant: participant)
     end)
 
-    def self.conversations
+    scope :conversations, (lambda do
       MessageTrain::Conversation.joins(:ignores)
-                                .where(
-                                  message_train_ignores: { id: where(nil) }
-                                )
+        .where(message_train_ignores: { id: where(nil) })
+    end)
+
+    def self.ignore(object, box)
+      method = IGNORE_METHODS[object.class.name]
+      return ignoring_error(object, box) if method.nil?
+      send(method, object, box)
+    end
+
+    def self.unignore(object, box)
+      method = UNIGNORE_METHODS[object.class.name]
+      return unignoring_error(object, box) if method.nil?
+      send(method, object, box)
+    end
+
+    def self.ignore_hash(object, box)
+      ignore object.values, box
+    end
+
+    def self.ignore_array(object, box)
+      object.collect { |item| ignore(item, box) }.uniq == [true]
+    end
+
+    def self.ignore_id(object, box)
+      ignore(box.find_conversation(object.to_i), box)
+    end
+
+    def self.ignore_conversation(object, box)
+      if box.authorize(object)
+        object.participant_ignore(box.participant)
+        box.results.add(object, :update_successful.l)
+      else
+        false
+      end
+    end
+
+    def self.ignoring_error(object, box)
+      box.errors.add(self, :cannot_ignore_type.l(type: object.class.name))
+      object
+    end
+
+    def self.unignore_hash(object, box)
+      unignore object.values, box
+    end
+
+    def self.unignore_array(object, box)
+      object.collect { |item| unignore(item, box) }.uniq == [true]
+    end
+
+    def self.unignore_id(object, box)
+      unignore(box.find_conversation(object.to_i), box)
+    end
+
+    def self.unignore_conversation(object, box)
+      if box.authorize(object)
+        object.participant_unignore(box.participant)
+        box.results.add(object, :update_successful.l)
+        object
+      else
+        false
+      end
+    end
+
+    def self.unignoring_error(object, box)
+      box.errors.add(self, :cannot_unignore_type.l(type: object.class.name))
+      object
     end
   end
 end

data/app/models/message_train/message.rb

@@ -4,15 +4,20 @@ module MessageTrain
     # Serializations
     serialize :recipients_to_save, Hash
 
+    attr_accessor :box
+
     # Relationships
     belongs_to(
       :conversation,
       foreign_key: :message_train_conversation_id,
+      class_name: 'MessageTrain::Conversation',
       touch: true
     )
     belongs_to :sender, polymorphic: true
     has_many :attachments, foreign_key: :message_train_message_id
     has_many :receipts, foreign_key: :message_train_message_id
+    delegate :participant_ignored?, to: :conversation
+    delegate :send_receipts, to: :receipts
 
     # Validations
     validates_presence_of :sender, :subject
@@ -25,172 +30,116 @@ module MessageTrain
 
     # Nested Attributes
     accepts_nested_attributes_for(
-      :attachments,
-      reject_if: :all_blank,
-      allow_destroy: true
+      :attachments, reject_if: :all_blank, allow_destroy: true
     )
 
     # Scopes
-    default_scope { order(updated_at: :desc) }
     scope :ready, -> { where(draft: false) }
     scope :drafts, -> { where(draft: true) }
     scope :by, ->(participant) { where(sender: participant) }
     scope :drafts_by, ->(participant) { drafts.by(participant) }
     scope :filter_by_receipt_method, (lambda do |receipt_method, participant|
-      where(
-        id: where(nil).receipts.send(receipt_method, participant).message_ids
-      )
+      receipts.send(receipt_method, participant).messages
     end)
+    scope :for_conversations, ->(c) { where conversation: c }
 
-    def mark(mark_to_set, participant)
-      receipt_to_mark = receipts.for(participant).first
-      receipt_to_mark.present? && receipt_to_mark.mark(mark_to_set)
+    def self.conversation_ids
+      pluck(:message_train_conversation_id)
     end
 
-    def self.mark(mark_to_set, participant)
-      find_each do |message|
-        message.mark(mark_to_set, participant)
-      end
+    def self.conversations
+      MessageTrain::Conversation.where(id: conversation_ids)
     end
 
-    def recipients
-      recips = []
-      receipts.recipient_receipt.each do |message|
-        recips << message.received_through
-      end
-      recips.uniq
+    def self.receipts
+      MessageTrain::Receipt.for_messages(ids)
     end
 
-    def self.conversation_ids
-      pluck(:message_train_conversation_id)
+    def mark(mark_to_set, participant)
+      receipts.for(participant).mark(mark_to_set)
     end
 
-    def self.receipts
-      MessageTrain::Receipt.joins(:message)
-                           .where(message_train_messages: { id: where(nil) })
+    def self.mark(mark_to_set, participant)
+      find_each { |message| message.mark(mark_to_set, participant) }
     end
 
-    def self.conversations
-      MessageTrain::Conversation.joins(:messages)
-                                .where(
-                                  message_train_messages: { id: where(nil) }
-                                )
+    def recipients
+      receipts.recipient_receipt.map(&:received_through).uniq
     end
 
-    def method_missing(method_sym, *arguments, &block)
-      # the first argument is a Symbol, so you need to_s it if you want to
-      # pattern match
-      if method_sym.to_s =~ /^is_((.*)_(by|to|for|through))\?$/
-        !receipts.send(Regexp.last_match[1].to_sym, arguments.first).empty?
-      elsif method_sym.to_s =~ /^mark_(.*)_for$/
-        receipts.for(arguments.first).first.mark(Regexp.last_match[1].to_sym)
-      else
-        super
+    def reply_recipients=(recipients)
+      recipient_arrays = {}
+      recipients.each do |recipient|
+        table_name = recipient.class.table_name
+        recipient_arrays[table_name] ||= []
+        recipient_arrays[table_name] << recipient.message_train_slug
+      end
+      recipient_arrays.each do |key, array|
+        recipients_to_save[key] = array.join(', ')
       end
     end
 
-    def self.method_missing(method_sym, *arguments, &block)
-      # the first argument is a Symbol, so you need to_s it if you want to
-      # pattern match
-      if method_sym.to_s =~ /^with_(.*_(by|to|for|through))$/
-        filter_by_receipt_method(Regexp.last_match[1].to_sym, arguments.first)
-      else
-        super
+    def method_missing(method_sym, *args, &block)
+      if method_sym.to_s =~ /^is_((.*)_(by|to|for|through))\?$/
+        return receipts.flagged(Regexp.last_match[1], *args).any?
+      end
+      if method_sym.to_s =~ /^mark_(.*)_for$/
+        return mark(Regexp.last_match[1], *args)
       end
+      super
     end
 
-    # It's important to know Object defines respond_to to take two parameters:
-    # the method to check, and whether to include private methods
-    # http://www.ruby-doc.org/core/classes/Object.html#M000333
-    def respond_to?(method_sym, include_private = false)
-      if method_sym.to_s =~ /^is_.*_(by|to|for|through)\?$/ ||
-         method_sym.to_s =~ /^mark_.*_for\?$/
-        true
-      else
-        super
-      end
+    def self.method_missing(method_sym, *args, &block)
+      return super unless method_sym.to_s =~ /^with_(.*_(by|to|for|through))$/
+      filter_by_receipt_method(Regexp.last_match[1].to_sym, args.first)
     end
 
-    def self.respond_to?(method_sym, include_private = false)
-      if method_sym.to_s =~ /^.*_(by|to|for|through)$/
-        true
-      else
-        super
-      end
+    def respond_to_missing?(method_sym, inc_private = false)
+      return true if method_sym.to_s =~ /^is_.*_(by|to|for|through)\?$/ ||
+                     method_sym.to_s =~ /^mark_.*_for\?$/
+      super
+    end
+
+    def self.respond_to_missing?(method_sym, inc_private = false)
+      method_sym.to_s =~ /^.*_(by|to|for|through)$/ ? true : super
     end
 
     private
 
     def create_conversation_if_blank
-      if conversation.nil?
-        self.conversation = Conversation.create(subject: subject)
-      end
+      return if conversation.present?
+      self.conversation = Conversation.create(subject: subject)
     end
 
     def generate_sender_receipt
-      receipts.first_or_create!(
-        recipient: sender,
-        received_through: sender,
-        sender: true
-      )
+      receipts.generate_for_sender(sender)
     end
 
     def generate_receipts_or_set_draft
-      unless draft
-        recipients_to_save.each do |table, slugs|
-          slugs = slugs.split(',')
-          sender.class.table_name == table && (slugs -= [sender.slug])
-          slugs.each do |slug|
-            send_receipts(table, slug)
-          end
-        end
-        reload
-        if recipients.empty?
-          update_attribute :draft, true
-        else
-          conversation.update_attribute(:updated_at, Time.now)
-        end
-      end
+      return if draft
+      recipients_to_save.each { |table, slugs| save_recipients(table, slugs) }
+      recipients.empty? ? update_attribute(:draft, true) : conversation.touch
+    end
+
+    def save_recipients(table, slugs)
+      slugs = slugs.split(',')
+      slugs -= [sender.slug] if sender.class.table_name == table
+      slugs.each { |slug| send_receipts(table, slug) }
     end
 
     def set_conversation_subject_if_alone
-      if conversation.messages.count == 1
-        conversation.update_attribute(:subject, subject)
-      end
+      return if conversation.messages.count != 1
+      conversation.update_attribute(:subject, subject)
     end
 
     def send_receipts(table, slug)
-      model_name = table.classify
-      model = model_name.constantize
-      slug = slug.strip
-      slug_column = MessageTrain.configuration
-                                .slug_columns[table.to_sym] || :slug
-      if model.exists?(slug_column => slug)
-        recipient = model.find_by(slug_column => slug)
-        end_recipient_method = MessageTrain.configuration
-                                           .valid_recipients_methods[
-                                             table.to_sym
-                                           ]
-        if end_recipient_method.nil?
-          unless conversation.participant_ignored?(recipient)
-            receipts.create!(
-              recipient: recipient,
-              received_through: recipient
-            )
-          end
-        else
-          recipient.send(end_recipient_method).uniq.each do |end_recipient|
-            next if conversation.participant_ignored?(end_recipient) ||
-                    end_recipient == sender
-            receipts.create!(
-              recipient: end_recipient,
-              received_through: recipient
-            )
-          end
-        end
-      else
+      model = table.classify.constantize
+      recipient = model.find_by_message_train_slug(slug)
+      unless recipient.present?
         errors.add :recipients_to_save, :name_not_found.l(name: slug)
+        return
       end
+      receipts.send_to_or_through(recipient)
     end
   end
 end