message_train 0.6.17 → 0.7.1

data/app/helpers/message_train/messages_helper.rb

@@ -3,20 +3,9 @@ module MessageTrain
   module MessagesHelper
     def message_class(box, message)
       css_classes = []
-
-      css_classes << if message.is_unread_for?(@box_user)
-                       'unread panel-info'
-                     else
-                       'read'
-                     end
-
-      message.draft && css_classes << 'draft'
-
-      if box.division == :trash
-        !message.is_trashed_for?(@box_user) && css_classes << 'hide'
-      else
-        !message.is_untrashed_for?(@box_user) && css_classes << 'hide'
-      end
+      css_classes << message_css_for_read_state(message)
+      css_classes << message_css_for_draft_state(message)
+      css_classes << message_css_for_hide_state(box, message)
       css_classes.join(' ')
     end
 
@@ -48,20 +37,44 @@ module MessageTrain
     private
 
     def message_toggle(message, icon, mark_to_set, title, options = {})
-      options[:remote] = true
-      options[:id] = "mark_#{mark_to_set}_#{message.id}"
-      options[:class] = 'mark-link'
-      options[:method] = :put
-      options[:title] = title
       render(
         partial: 'message_train/messages/toggle',
         locals: {
           message: message,
           icon: icon,
           mark_to_set: mark_to_set,
-          options: options
+          options: message_toggle_options(message, mark_to_set, title, options)
         }
       )
     end
+
+    def message_toggle_options(message, mark_to_set, title, options = {})
+      options[:remote] = true
+      options[:id] = "mark_#{mark_to_set}_#{message.id}"
+      options[:class] = 'mark-link'
+      options[:method] = :put
+      options[:title] = title
+      options
+    end
+
+    def message_css_for_hide_state(box, message)
+      if box.division == :trash
+        'hide' unless message.is_trashed_for?(@box_user)
+      else
+        'hide' unless message.is_untrashed_for?(@box_user)
+      end
+    end
+
+    def message_css_for_draft_state(message)
+      'draft' if message.draft
+    end
+
+    def message_css_for_read_state(message)
+      if message.is_unread_for?(@box_user)
+        'unread panel-info'
+      else
+        'read'
+      end
+    end
   end
 end

data/app/mailers/message_train/receipt_mailer.rb

@@ -6,22 +6,32 @@ module MessageTrain
       @recipient = receipt.recipient
       @through = receipt.received_through
       if @recipient == @through
-        @heading = :new_message_on_site_name.l(
-          site_name: MessageTrain.configuration.site_name
-        )
+        set_self_heading
       else
-        @through_name = @through.send(
-          MessageTrain.configuration.name_columns[
-            @through.class.table_name.to_sym
-          ]
-        )
-        @heading = :new_message_through_on_site_name.l(
-          site_name: MessageTrain.configuration.site_name,
-          through: @through_name
-        )
+        set_through_heading
       end
       @subject = "#{@heading}: #{@receipt.message.subject}"
       mail(to: @recipient.email, subject: @subject)
     end
+
+    private
+
+    def set_self_heading
+      @heading = :new_message_on_site_name.l(
+        site_name: MessageTrain.configuration.site_name
+      )
+    end
+
+    def set_through_heading
+      @through_name = @through.send(
+        MessageTrain.configuration.name_columns[
+          @through.class.table_name.to_sym
+        ]
+      )
+      @heading = :new_message_through_on_site_name.l(
+        site_name: MessageTrain.configuration.site_name,
+        through: @through_name
+      )
+    end
   end
 end

data/app/models/message_train/attachment.rb

@@ -39,9 +39,9 @@ module MessageTrain
       ]
     )
     def image?
-      # rubocop:disable Style/LineLength
+      # rubocop:disable Metrics/LineLength
       !(attachment_content_type =~ %r{^(image|(x-)?application)/(bmp|gif|jpeg|jpg|pjpeg|png|x-png)$}).nil?
-      # rubocop:enable Style/LineLength
+      # rubocop:enable Metrics/LineLength
     end
 
     Paperclip.interpolates :style_prefix do |attachment, style|

data/app/models/message_train/box.rb

@@ -1,6 +1,19 @@
 module MessageTrain
   # Box model
   class Box
+    MARK_METHODS = {
+      'Hash' => :mark_hash,
+      'Array' => :mark_array,
+      'String' => :mark_id,
+      'Fixnum' => :mark_id,
+      'MessageTrain::Conversation' => :mark_communication
+    }.freeze
+
+    AUTHORIZE_METHODS = {
+      'MessageTrain::Conversation' => :authorize_conversation,
+      'MessageTrain::Message' => :authorize_message
+    }.freeze
+
     include ActiveModel::Model
     attr_accessor :parent, :division, :participant, :errors, :results
     alias id division
@@ -18,8 +31,7 @@ module MessageTrain
     end
 
     def unread_count
-      found = conversations(unread: true)
-      found.count
+      conversations(read: false).count
     end
 
     def conversations(options = {})
@@ -28,21 +40,6 @@ module MessageTrain
       if options[:read] == false || options[:unread]
         found = found.with_unread_for(participant)
       end
-      if division == :trash
-        found = found.with_trashed_for(participant)
-      else
-        found = found.with_untrashed_for(participant)
-        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
 
@@ -54,131 +51,76 @@ module MessageTrain
       parent.all_messages(participant).find(id)
     end
 
-    def new_message(args = {})
-      if args[:message_train_conversation_id].nil?
-        message = MessageTrain::Message.new(args)
+    def send_message(attributes)
+      message = MessageTrain::Message.new attributes
+      return false unless authorize_send_message(message)
+      message.sender = participant
+      return message_send_error(message) unless message.save
+      message_send_success(message)
+    end
+
+    def message_send_error(message)
+      errors.add(message, message.errors.full_messages.to_sentence)
+      message
+    end
+
+    def message_send_success(message)
+      if message.draft
+        results.add(message, :message_saved_as_draft.l)
       else
-        conversation = find_conversation(args[:message_train_conversation_id])
-        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>'
-        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]
-          )
-        end
-        recipient_arrays.each do |key, array|
-          message.recipients_to_save[key] = array.join(', ')
-        end
+        results.add(message, :message_sent.l)
       end
       message
     end
 
-    def send_message(attributes)
-      message_to_send = MessageTrain::Message.new attributes
-      message_to_send.sender = participant
+    def authorize_send_message(message)
       unless parent.valid_senders.include? participant
         errors.add(
-          message_to_send,
+          message,
           :invalid_sender_for_thing.l(
             thing: "#{parent.class.name} #{parent.id}"
           )
         )
         return false
       end
-      if message_to_send.save
-        if message_to_send.draft
-          results.add(message_to_send, :message_saved_as_draft.l)
-        else
-          results.add(message_to_send, :message_sent.l)
-        end
-      else
-        errors.add(
-          message_to_send,
-          message_to_send.errors.full_messages.to_sentence
-        )
-      end
-      message_to_send
+      true
     end
 
     def update_message(message, attributes)
+      !message.draft && raise(ActiveRecord::RecordNotFound)
       attributes.delete(:sender)
-      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, :message_sent.l)
-          end
-        else
-          errors.add(
-            message,
-            message.errors.full_messages.to_sentence
-          )
-        end
-        message
-      else
-        errors.add(
-          message,
-          :access_to_message_id_denied.l(id: message.id)
-        )
-        false
-      end
+      return false unless authorize_update_message(message)
+      message.update(attributes)
+      message.reload
+      return message_update_error(message) if message.errors.any?
+      message_update_success(message)
     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.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
+    def message_update_success(message)
+      if message.draft
+        results.add(message, :message_saved_as_draft.l)
       else
-        errors.add(self, :cannot_ignore_type.l(type: object.class.name))
+        results.add(message, :message_sent.l)
       end
+      message
     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.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))
+    def message_update_error(message)
+      errors.add(message, message.errors.full_messages.to_sentence)
+      message
+    end
+
+    def authorize_update_message(message)
+      unless message.sender == participant &&
+             parent.valid_senders.include?(participant)
+        return message_access_denied(message)
       end
+      true
+    end
+
+    def message_access_denied(message)
+      errors.add(message, :access_to_message_id_denied.l(id: message.id))
+      false
     end
 
     def title
@@ -186,74 +128,73 @@ module MessageTrain
     end
 
     def message
-      if !errors.all.empty?
-        errors.all.collect { |x| x[:message] }.uniq.to_sentence
-      elsif results.all.empty?
-        :nothing_to_do.l
-      else
-        results.all.collect { |x| x[:message] }.uniq.to_sentence
-      end
+      what_happened = errors.any? ? errors : results
+      return :nothing_to_do.l unless what_happened.any?
+      what_happened.all.map { |x| x[:message] }.uniq.to_sentence
     end
 
     def mark(mark_to_set, objects)
       objects.each do |key, object|
-        if !object.present?
-          # Allow skipping empty objects
-        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 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
-              false
-            end
-          else
-            errors.add(
-              self,
-              :cannot_mark_with_data_type.l(data_type: data_type)
-            )
-          end
-        else
+        next unless object.present? # Allow skipping empty objects
+        unless key.to_s =~ /^(conversations|messages)$/
           errors.add(self, :cannot_mark_type.l(type: key.to_s))
+          next
         end
+        mark_object mark_to_set, key, object
       end
     end
 
+    def mark_hash(mark_to_set, key, object)
+      mark(mark_to_set, key => object.values)
+    end
+
+    def mark_array(mark_to_set, key, object)
+      object.collect { |item| mark(mark_to_set, key => item) }
+            .uniq == [true]
+    end
+
+    def mark_id(mark_to_set, key, object)
+      model = "MessageTrain::#{key.to_s.classify}".constantize
+      mark_communication(mark_to_set, key, model.find_by_id!(object.to_i))
+    end
+
+    def mark_communication(mark_to_set, _key, object)
+      return unless authorize(object)
+      object.mark(mark_to_set, participant)
+      results.add(object, :update_successful.l)
+    end
+
+    def marking_error(object)
+      errors.add(
+        self, :cannot_mark_with_data_type.l(data_type: object.class.name)
+      )
+      object
+    end
+
+    def mark_object(mark_to_set, key, object)
+      method = MARK_METHODS[object.class.name]
+      return marking_error(object) if method.nil?
+      send(method, mark_to_set, key, object)
+    end
+
     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
-      else
-        errors.add(object, :cannot_authorize_type.l(type: object.class.name))
-      end
+      method = AUTHORIZE_METHODS[object.class.name]
+      return authorize_error(object) if method.nil?
+      send(method, object)
+    end
+
+    def authorize_error(object)
+      errors.add(object, :cannot_authorize_type.l(type: object.class.name))
+    end
+
+    def authorize_conversation(object)
+      object.includes_receipts_for?(participant) ||
+        errors.add(object, :access_to_conversation_id_denied.l(id: object.id))
+    end
+
+    def authorize_message(object)
+      object.receipts.for(participant).any? ||
+        errors.add(object, :access_to_message_id_denied.l(id: object.id))
     end
 
     # Box::Results class
@@ -266,64 +207,77 @@ module MessageTrain
       end
 
       def add(object, message)
-        item = {}
-        case object.class.name
-        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: 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
-        item[:message] = message
-        items << item
+        items << case object.class.name
+                 when 'MessageTrain::Box'
+                   result_for_box(object, message)
+                 when 'MessageTrain::Conversation', 'MessageTrain::Message'
+                   result_for_communication(object, message)
+                 else
+                   result_for_misc_object(object, message)
+                 end
         true
       end
 
+      def result_for_misc_object(object, message)
+        css_id = object.class.name.singularize.downcase
+        { css_id: css_id, path: nil, message: message }
+      end
+
+      def result_for_communication(object, message)
+        return result_for_new(object, message) if object.new_record?
+        path = MessageTrain::Engine.routes.path_for(object_route_args(object))
+        css_id = "#{object.class.table_name.singularize}_#{object.id}"
+        { message: message, css_id: css_id, path: path }
+      end
+
+      def object_route_args(object)
+        table_name = object.class.table_name
+        {
+          controller: table_name.gsub('message_train_', 'message_train/'),
+          action: :show,
+          box_division: box.division,
+          id: object.id,
+          collective_id: collective_id_for_box(box)
+        }
+      end
+
+      def result_for_new(object, message)
+        {
+          message: message,
+          css_id: object.class.table_name.singularize,
+          path: nil
+        }
+      end
+
+      def result_for_box(object, message)
+        path = MessageTrain::Engine.routes.path_for(box_route_args(object))
+        { css_id: 'box', message: message, path: path }
+      end
+
+      def box_route_args(object)
+        {
+          controller: 'message_train/boxes',
+          action: :show,
+          division: object.division,
+          collective_id: collective_id_for_box(box)
+        }
+      end
+
+      def collective_id_for_box(box)
+        return if box.parent == box.participant
+        collective = box.parent
+        table_part = collective.class.table_name
+        slug_part = collective.message_train_slug
+        "#{table_part}:#{slug_part}"
+      end
+
       def all
         items
       end
+
+      def any?
+        items.any?
+      end
     end
     # Box::Errors class
     class Errors < Results