message_train 0.5.2 → 0.5.3

data/app/models/message_train/attachment.rb

@@ -1,35 +1,51 @@
 module MessageTrain
+  # Attachment model
   class Attachment < ActiveRecord::Base
     belongs_to :message, foreign_key: :message_train_message_id
-    has_attached_file :attachment, styles: lambda { |attachment|
-                                                    attachment.instance.image? ? {
-                                                      thumb: '235x',
-                                                      large: '800x'
-                                                    } : {}
-                                                  },
-                                  path: ':rails_root/public/system/:rails_env/:class/:attachment/:id_partition/:style_prefix:filename',
-                                  url: '/system/:rails_env/:class/:attachment/:id_partition/:style_prefix:filename',
-                                  convert_options: {
-                                      large: '-quality 75 -interlace Plane -strip',
-                                      thumb: '-quality 75 -strip',
-                                  }
+    has_attached_file(
+      :attachment,
+      styles: lambda do |attachment|
+        if attachment.instance.image?
+          {
+            thumb: '235x',
+            large: '800x'
+          }
+        else
+          {}
+        end
+      end,
+      path: ':rails_root/public/system/:rails_env/:class/:attachment/'\
+        ':id_partition/:style_prefix:filename',
+      url: '/system/:rails_env/:class/:attachment/'\
+        ':id_partition/:style_prefix:filename',
+      convert_options: {
+        large: '-quality 75 -interlace Plane -strip',
+        thumb: '-quality 75 -strip'
+      }
+    )
     validates_attachment_presence :attachment
-    validates_attachment_content_type :attachment, content_type: [
-                                        'application/pdf',
-                                        'application/vnd.ms-excel',
-                                        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-                                        'application/msword',
-                                        'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-                                        'application/rtf',
-                                        'text/plain',
-                                        /^(image|(x-)?application)\/(bmp|gif|jpeg|jpg|pjpeg|png|x-png)$/
-                                    ]
+    validates_attachment_content_type(
+      :attachment,
+      content_type: [
+        'application/pdf',
+        'application/vnd.ms-excel',
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        'application/msword',
+        'application/'\
+          'vnd.openxmlformats-officedocument.wordprocessingml.document',
+        'application/rtf',
+        'text/plain',
+        %r{^(image|(x-)?application)/(bmp|gif|jpeg|jpg|pjpeg|png|x-png)$}
+      ]
+    )
     def image?
-      (attachment_content_type =~ /^(image|(x-)?application)\/(bmp|gif|jpeg|jpg|pjpeg|png|x-png)$/) ? true : false
+      # rubocop:disable Style/LineLength
+      !(attachment_content_type =~ %r{^(image|(x-)?application)/(bmp|gif|jpeg|jpg|pjpeg|png|x-png)$}).nil?
+      # rubocop:enable Style/LineLength
     end
 
     Paperclip.interpolates :style_prefix do |attachment, style|
-      attachment.instance.image? ? "#{style.to_s}/" : ''
+      attachment.instance.image? ? "#{style}/" : ''
     end
   end
-end
+end

data/app/models/message_train/box.rb

@@ -1,8 +1,9 @@
 module MessageTrain
+  # Box model
   class Box
     include ActiveModel::Model
     attr_accessor :parent, :division, :participant, :errors, :results
-    alias_method :id, :division
+    alias id division
 
     def initialize(parent, division, participant = nil)
       @parent = parent
@@ -18,12 +19,6 @@ module MessageTrain
 
     def unread_count
       found = conversations(unread: true)
-      # # This fixed a bug that only Travis seemed to pick up, but it's code smell.
-      # if found.nil?
-      #   0
-      # else
-      #   found.count
-      # end
       found.count
     end
 
@@ -37,16 +32,16 @@ module MessageTrain
         found = found.with_trashed_for(participant)
       else
         found = found.with_untrashed_for(participant)
-        if division == :drafts
-          found = found.with_drafts_by(participant)
-        else
-          found = found.with_ready_for(participant)
-        end
-        if division == :ignored
-          found = found.ignored(participant)
-        else
-          found = found.unignored(participant)
-        end
+        found = if division == :drafts
+                  found.with_drafts_by(participant)
+                else
+                  found.with_ready_for(participant)
+                end
+        found = if division == :ignored
+                  found.ignored(participant)
+                else
+                  found.unignored(participant)
+                end
       end
       found
     end
@@ -67,12 +62,15 @@ module MessageTrain
         previous_message = conversation.messages.last
         message = conversation.messages.build(args)
         message.subject = "Re: #{conversation.subject}"
-        message.body = "<blockquote>#{previous_message.body}</blockquote><p>&nbsp;</p>"
+        message.body = "<blockquote>#{previous_message.body}</blockquote>"\
+          '<p>&nbsp;</p>'
         recipient_arrays = {}
         conversation.default_recipients_for(parent).each do |recipient|
           table_name = recipient.class.table_name
           recipient_arrays[table_name] ||= []
-          recipient_arrays[table_name] << recipient.send(MessageTrain.configuration.slug_columns[table_name.to_sym])
+          recipient_arrays[table_name] << recipient.send(
+            MessageTrain.configuration.slug_columns[table_name.to_sym]
+          )
         end
         recipient_arrays.each do |key, array|
           message.recipients_to_save[key] = array.join(', ')
@@ -85,7 +83,12 @@ module MessageTrain
       message_to_send = MessageTrain::Message.new attributes
       message_to_send.sender = participant
       unless parent.valid_senders.include? participant
-        errors.add(message_to_send, :invalid_sender_for_thing.l(thing: "#{parent.class.name} #{parent.id}"))
+        errors.add(
+          message_to_send,
+          :invalid_sender_for_thing.l(
+            thing: "#{parent.class.name} #{parent.id}"
+          )
+        )
         return false
       end
       if message_to_send.save
@@ -95,78 +98,91 @@ module MessageTrain
           results.add(message_to_send, :message_sent.l)
         end
       else
-        errors.add(message_to_send, message_to_send.errors.full_messages.to_sentence)
+        errors.add(
+          message_to_send,
+          message_to_send.errors.full_messages.to_sentence
+        )
       end
       message_to_send
     end
 
-    def update_message(message_to_update, attributes)
+    def update_message(message, attributes)
       attributes.delete(:sender)
-      if message_to_update.sender == participant && parent.valid_senders.include?(participant)
-        message_to_update.update(attributes)
-        message_to_update.reload
-        if message_to_update.errors.empty?
-          if message_to_update.draft
-            results.add(message_to_update, :message_saved_as_draft.l)
+      if message.sender == participant && parent.valid_senders.include?(
+        participant
+      )
+        message.update(attributes)
+        message.reload
+        if message.errors.empty?
+          if message.draft
+            results.add(message, :message_saved_as_draft.l)
           else
-            results.add(message_to_update, :message_sent.l)
+            results.add(message, :message_sent.l)
           end
         else
-          errors.add(message_to_update, message_to_update.errors.full_messages.to_sentence)
+          errors.add(
+            message,
+            message.errors.full_messages.to_sentence
+          )
         end
-        message_to_update
+        message
       else
-        errors.add(message_to_update, :access_to_message_id_denied.l(id: message_to_update.id))
+        errors.add(
+          message,
+          :access_to_message_id_denied.l(id: message.id)
+        )
         false
       end
     end
 
     def ignore(object)
       case object.class.name
-        when 'Hash'
-          ignore object.values
-        when 'Array'
-          object.collect { |item| ignore(item) }.uniq == [true]
-        when 'String', 'Fixnum'
-          ignore(find_conversation(object.to_i))
-        when 'MessageTrain::Conversation'
-          if authorize(object)
-            object.set_ignored(participant)
-            # We can assume the previous line has succeeded at this point, because set_ignored raises
-            # an ActiveRecord error otherwise. Therefore we simply report success, since we got here.
-            results.add(object, :update_successful.l)
-          else
-            false
-          end
+      when 'Hash'
+        ignore object.values
+      when 'Array'
+        object.collect { |item| ignore(item) }.uniq == [true]
+      when 'String', 'Fixnum'
+        ignore(find_conversation(object.to_i))
+      when 'MessageTrain::Conversation'
+        if authorize(object)
+          object.participant_ignore(participant)
+          # We can assume the previous line has succeeded at this point,
+          # because participant_ignore raises an ActiveRecord error otherwise.
+          # Therefore we simply report success, since we got here.
+          results.add(object, :update_successful.l)
         else
+          false
+        end
+      else
         errors.add(self, :cannot_ignore_type.l(type: object.class.name))
       end
     end
 
     def unignore(object)
       case object.class.name
-        when 'Hash'
-          unignore object.values
-        when 'Array'
-          object.collect { |item| unignore(item) }.uniq == [true]
-        when 'String', 'Fixnum'
-          unignore(find_conversation(object.to_i))
-        when 'MessageTrain::Conversation'
-          if authorize(object)
-            object.set_unignored(participant)
-            # We can assume the previous line has succeeded at this point, because set_unignored raises
-            # an ActiveRecord error otherwise. Therefore we simply report success, since we got here.
-            results.add(object, :update_successful.l)
-          else
-            false
-          end
+      when 'Hash'
+        unignore object.values
+      when 'Array'
+        object.collect { |item| unignore(item) }.uniq == [true]
+      when 'String', 'Fixnum'
+        unignore(find_conversation(object.to_i))
+      when 'MessageTrain::Conversation'
+        if authorize(object)
+          object.participant_unignore(participant)
+          # We can assume the previous line has succeeded at this point,
+          # because participant_unignore raises an ActiveRecord error
+          # otherwise. Therefore we simply report success, since we got here.
+          results.add(object, :update_successful.l)
         else
+          false
+        end
+      else
         errors.add(self, :cannot_unignore_type.l(type: object.class.name))
       end
     end
 
     def title
-      "box_title_#{division.to_s}".to_sym.l
+      "box_title_#{division}".to_sym.l
     end
 
     def message
@@ -186,25 +202,31 @@ module MessageTrain
         elsif key.to_s =~ /^(conversations|messages)$/
           data_type = object.class.name
           case data_type
-            when 'Hash'
-              mark(mark_to_set, { key => object.values } )
-            when 'Array'
-              object.collect { |item| mark(mark_to_set, key => item) }.uniq == [true]
-            when 'String', 'Fixnum'
-              model_name = "MessageTrain::#{key.to_s.classify}"
-              model = model_name.constantize
-              mark(mark_to_set, key => model.find_by_id!(object.to_i))
-            when 'MessageTrain::Conversation', 'MessageTrain::Message'
-              if authorize(object)
-                object.mark(mark_to_set, participant)
-                # We can assume the previous line has succeeded at this point, because mark raises
-                # an ActiveRecord error otherwise. Therefore we simply report success, since we got here.
-                results.add(object, :update_successful.l)
-              else
-                false
-              end
+          when 'Hash'
+            mark(mark_to_set, key => object.values)
+          when 'Array'
+            object.collect do |item|
+              mark(mark_to_set, key => item)
+            end.uniq == [true]
+          when 'String', 'Fixnum'
+            model_name = "MessageTrain::#{key.to_s.classify}"
+            model = model_name.constantize
+            mark(mark_to_set, key => model.find_by_id!(object.to_i))
+          when 'MessageTrain::Conversation', 'MessageTrain::Message'
+            if authorize(object)
+              object.mark(mark_to_set, participant)
+              # We can assume the previous line has succeeded at this point,
+              # because mark raises an ActiveRecord error otherwise.
+              # Therefore we simply report success, since we got here.
+              results.add(object, :update_successful.l)
             else
-              errors.add(self, :cannot_mark_with_data_type.l(data_type: data_type))
+              false
+            end
+          else
+            errors.add(
+              self,
+              :cannot_mark_with_data_type.l(data_type: data_type)
+            )
           end
         else
           errors.add(self, :cannot_mark_type.l(type: key.to_s))
@@ -214,23 +236,27 @@ module MessageTrain
 
     def authorize(object)
       case object.class.name
-        when 'MessageTrain::Conversation'
-          if object.includes_receipts_for? participant
-            true
-          else
-            errors.add(object, :access_to_conversation_id_denied.l(id: object.id))
-          end
-        when 'MessageTrain::Message'
-          if object.receipts.for(participant).any?
-            true
-          else
-            errors.add(object, :access_to_message_id_denied.l(id: object.id))
-          end
+      when 'MessageTrain::Conversation'
+        if object.includes_receipts_for? participant
+          true
+        else
+          errors.add(
+            object,
+            :access_to_conversation_id_denied.l(id: object.id)
+          )
+        end
+      when 'MessageTrain::Message'
+        if object.receipts.for(participant).any?
+          true
         else
-          errors.add(object, :cannot_authorize_type.l(type: object.class.name))
+          errors.add(object, :access_to_message_id_denied.l(id: object.id))
+        end
+      else
+        errors.add(object, :cannot_authorize_type.l(type: object.class.name))
       end
     end
 
+    # Box::Results class
     class Results
       attr_accessor :items, :box
 
@@ -242,43 +268,53 @@ module MessageTrain
       def add(object, message)
         item = {}
         case object.class.name
-          when 'MessageTrain::Box'
-            item[:css_id] = 'box'
+        when 'MessageTrain::Box'
+          item[:css_id] = 'box'
+          route_args = {
+            controller: 'message_train/boxes',
+            action: :show,
+            division: object.division
+          }
+          if box.parent != box.participant
+            collective = box.parent
+            table_part = collective.class.table_name
+            slug_part = collective.send(
+              MessageTrain.configuration.slug_columns[
+                collective.class.table_name.to_sym
+              ]
+            )
+            route_args[:collective_id] = "#{table_part}:#{slug_part}"
+          end
+          item[:path] = MessageTrain::Engine.routes.path_for(route_args)
+        when 'MessageTrain::Conversation', 'MessageTrain::Message'
+          if object.new_record?
+            item[:css_id] = "#{object.class.table_name.singularize}"
+            item[:path] = nil
+          else
+            item[:css_id] = "#{object.class.table_name.singularize}_"\
+              "#{object.id.to_s}"
             route_args = {
-                controller: 'message_train/boxes',
+                controller: object.class.table_name
+                                  .gsub('message_train_', 'message_train/'),
                 action: :show,
-                division: object.division
+                box_division: box.division,
+                id: object.id
             }
             if box.parent != box.participant
               collective = box.parent
               table_part = collective.class.table_name
-              slug_part = collective.send(MessageTrain.configuration.slug_columns[collective.class.table_name.to_sym])
+              slug_part = collective.send(
+                MessageTrain.configuration.slug_columns[
+                  collective.class.table_name.to_sym
+                ]
+              )
               route_args[:collective_id] = "#{table_part}:#{slug_part}"
             end
             item[:path] = MessageTrain::Engine.routes.path_for(route_args)
-          when 'MessageTrain::Conversation', 'MessageTrain::Message'
-            if object.new_record?
-              item[:css_id] = "#{object.class.table_name.singularize}"
-              item[:path] = nil
-            else
-              item[:css_id] = "#{object.class.table_name.singularize}_#{object.id.to_s}"
-              route_args = {
-                  controller: object.class.table_name.gsub('message_train_', 'message_train/'),
-                  action: :show,
-                  box_division: box.division,
-                  id: object.id
-              }
-              if box.parent != box.participant
-                collective = box.parent
-                table_part = collective.class.table_name
-                slug_part = collective.send(MessageTrain.configuration.slug_columns[collective.class.table_name.to_sym])
-                route_args[:collective_id] = "#{table_part}:#{slug_part}"
-              end
-              item[:path] = MessageTrain::Engine.routes.path_for(route_args)
-            end
-          else
-            item[:css_id] = "#{object.class.name.singularize.downcase}"
-            item[:path] = nil
+          end
+        else
+          item[:css_id] = object.class.name.singularize.downcase
+          item[:path] = nil
         end
         item[:message] = message
         items << item
@@ -289,6 +325,7 @@ module MessageTrain
         items
       end
     end
+    # Box::Errors class
     class Errors < Results
       def add(object, message)
         super object, message

data/app/models/message_train/conversation.rb

@@ -1,4 +1,5 @@
 module MessageTrain
+  # Conversation model
   class Conversation < ActiveRecord::Base
     has_many :messages, foreign_key: :message_train_conversation_id
     has_many :ignores, foreign_key: :message_train_conversation_id
@@ -7,12 +8,50 @@ module MessageTrain
 
     # Scopes
     default_scope { order(updated_at: :desc) }
-    scope :ignored, ->(participant) { where(id: ignored_ids_for(participant))}
-    scope :unignored, ->(participant) { where.not(id: ignored_ids_for(participant)) }
-    scope :with_drafts_by, ->(participant) { joins(:messages).where(message_train_messages: { id: messages.drafts.with_receipts_by(participant) }) }
-    scope :with_ready_for, ->(participant) { joins(:messages).where(message_train_messages: { id: messages.ready.with_receipts_for(participant) }) }
-    scope :with_messages_for, ->(participant) { joins(:messages).where(message_train_messages: { id: messages.with_receipts_for(participant) }) }
-    scope :with_messages_through, ->(participant) { joins(:messages).where(message_train_messages: { id: messages.with_receipts_through(participant) }) }
+    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)
+        }
+      )
+    end)
+    scope :with_ready_for, (lambda do |participant|
+      joins(:messages).where(
+        message_train_messages: {
+          id: messages.ready.with_receipts_for(participant)
+        }
+      )
+    end)
+    scope :with_messages_for, (lambda do |participant|
+      joins(:messages).where(
+        message_train_messages: {
+          id: messages.with_receipts_for(participant)
+        }
+      )
+    end)
+    scope :with_messages_through, (lambda do |participant|
+      joins(:messages).where(
+        message_train_messages: {
+          id: messages.with_receipts_through(participant)
+        }
+      )
+    end)
+
+    scope :filter_by_receipt_method, (lambda do |receipt_method, participant|
+      where(
+        id: where(nil).messages.receipts.send(receipt_method, participant)
+              .conversation_ids
+      )
+    end)
+
+    scope :ignored_ids_for, (lambda do |participant|
+      MessageTrain::Ignore.find_all_by_participant(participant)
+                          .pluck(:message_train_conversation_id)
+    end)
 
     def default_recipients_for(sender)
       default_recipients = []
@@ -25,15 +64,15 @@ module MessageTrain
       default_recipients.flatten.uniq
     end
 
-    def set_ignored(participant)
+    def participant_ignore(participant)
       ignores.first_or_create!(participant: participant)
     end
 
-    def set_unignored(participant)
+    def participant_unignore(participant)
       ignores.where(participant: participant).destroy_all
     end
 
-    def is_ignored?(participant)
+    def participant_ignored?(participant)
       if ignores.empty?
         false
       else
@@ -42,10 +81,6 @@ module MessageTrain
     end
 
     def mark(mark, participant)
-      # # This fixed a bug that only Travis seemed to pick up, but it's code smell.
-      # if messages.nil?
-      #   return false
-      # end
       messages.mark(mark, participant)
     end
 
@@ -54,17 +89,21 @@ module MessageTrain
     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
+      # 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 $2
-          when 'ready', 'drafts'
-            if $3 == 'by'
-              !messages.send($2).by(arguments.first).empty?
-            else
-              !messages.send($2).receipts.send("receipts_#{$3}".to_sym, arguments.first).empty?
-            end
+        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
-            !receipts.send($1.to_sym, arguments.first).empty?
+            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
@@ -72,22 +111,35 @@ module MessageTrain
     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
+      # 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 $2
-          when 'ready', 'drafts'
-            self.messages.send($2).filter_by_receipt_method("receipts_#{$3}".to_sym, arguments.first).conversations
-          when 'messages'
-            self.messages.filter_by_receipt_method("receipts_#{$3}".to_sym, arguments.first).conversations
-          else
-            self.filter_by_receipt_method($1.to_sym, arguments.first)
+        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
       end
     end
 
-    # It's important to know Object defines respond_to to take two parameters: the method to check, and whether to include private methods
+    # 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))\?$/
@@ -104,14 +156,5 @@ module MessageTrain
         super
       end
     end
-
-    private
-      scope :filter_by_receipt_method, ->(receipt_method, participant) {
-        where(id: where(nil).messages.receipts.send(receipt_method, participant).conversation_ids)
-      }
-
-      def self.ignored_ids_for(participant)
-        MessageTrain::Ignore.find_all_by_participant(participant).pluck(:message_train_conversation_id)
-      end
   end
-end
+end