message_train 0.5.2 → 0.5.3

data/app/controllers/message_train/participants_controller.rb

@@ -1,4 +1,5 @@
 module MessageTrain
+  # Participants controller
   class ParticipantsController < MessageTrain::ApplicationController
     before_filter :load_participants
     before_filter :load_participant, only: :show
@@ -19,30 +20,33 @@ module MessageTrain
 
     private
 
-      def load_participants
-        if params[:model].empty?
-          raise ActiveRecord::RecordNotFound
-        end
-        model_sym = params[:model].to_sym
-        model = MessageTrain.configuration.recipient_tables[model_sym].constantize
-        method = MessageTrain.configuration.address_book_methods[model_sym]
-        fallback_method = MessageTrain.configuration.address_book_method
-        current_participant = send(MessageTrain.configuration.current_user_method)
-        if !method.nil? && model.respond_to?(method)
-          @participants = model.send(method, current_participant)
-        elsif !fallback_method.nil? && model.respond_to?(fallback_method)
-          @participants = model.send(fallback_method, current_participant)
-        else
-          @participants = model.all
-        end
-        if params[:query].present?
-          field_name = MessageTrain.configuration.slug_columns[model_sym]
-          @participants = @participants.where("#{field_name} LIKE ?", "#{params[:query]}%")
-        end
+    def load_participants
+      params[:model].empty? && raise(ActiveRecord::RecordNotFound)
+      model_sym = params[:model].to_sym
+      model = MessageTrain.configuration.recipient_tables[model_sym].constantize
+      method = MessageTrain.configuration.address_book_methods[model_sym]
+      fallback_method = MessageTrain.configuration.address_book_method
+      current_participant = send(MessageTrain.configuration.current_user_method)
+      if !method.nil? && model.respond_to?(method)
+        @participants = model.send(method, current_participant)
+      elsif !fallback_method.nil? && model.respond_to?(fallback_method)
+        @participants = model.send(fallback_method, current_participant)
+      else
+        @participants = model.all
       end
-
-      def load_participant
-        @participant = @participants.find(params[:id])
+      if params[:query].present?
+        field_name = MessageTrain.configuration.slug_columns[model_sym]
+        pattern = Regexp.union('\\', '%', '_')
+        query = params[:query].gsub(pattern) { |x| ['\\', x].join }
+        @participants = @participants.where(
+          "#{field_name} LIKE ?",
+          "#{query}%"
+        )
       end
+    end
+
+    def load_participant
+      @participant = @participants.find(params[:id])
+    end
   end
 end

data/app/controllers/message_train/unsubscribes_controller.rb

@@ -1,6 +1,6 @@
 module MessageTrain
+  # Unsubscribes controller
   class UnsubscribesController < MessageTrain::ApplicationController
-
     # GET /unsubscribes
     def index
       @subscriptions = @box_user.subscriptions
@@ -16,28 +16,36 @@ module MessageTrain
         else
           flash[:error] = @unsubscribe.errors.full_messages.to_sentence
         end
-      else
-        unsub = unsubscribe_params
-        model = unsub[:from_type].constantize
-        @from = model.find(unsub[:from_id])
-        if @from == @box_user || @from.allows_receiving_by?(@box_user)
-          @unsubscribe = @box_user.unsubscribe_from(@from)
-          if @unsubscribe.errors.empty?
-            if @from == @box_user
-              flash[:notice] = :unsubscribe_message.l
-            else
-              name_column = MessageTrain.configuration.name_columns[@from.class.table_name.to_sym]
-              collective_name = @from.send(name_column)
-              collective_type = @from.class.name
-              flash[:notice] = :collective_unsubscribe_message.l(collective_name: collective_name, collective_type: collective_type)
-            end
+        redirect_to message_train.unsubscribes_url
+        return
+      end
+      unsub = unsubscribe_params
+      model = unsub[:from_type].constantize
+      @from = model.find(unsub[:from_id])
+      if @from == @box_user || @from.allows_receiving_by?(@box_user)
+        @unsubscribe = @box_user.unsubscribe_from(@from)
+        if @unsubscribe.errors.empty?
+          if @from == @box_user
+            flash[:notice] = :unsubscribe_message.l
           else
-            flash[:error] = @unsubscribe.errors.full_messages.to_sentence
+            name_column = MessageTrain.configuration.name_columns[
+              @from.class.table_name.to_sym
+            ]
+            collective_name = @from.send(name_column)
+            collective_type = @from.class.name
+            flash[:notice] = :collective_unsubscribe_message.l(
+              collective_name: collective_name,
+              collective_type: collective_type
+            )
           end
         else
-          flash[:error] = :you_are_not_in_that_collective_type.l(collective_type: model.name)
-          raise ActiveRecord::RecordNotFound
+          flash[:error] = @unsubscribe.errors.full_messages.to_sentence
         end
+      else
+        flash[:error] = :you_are_not_in_that_collective_type.l(
+          collective_type: model.name
+        )
+        raise ActiveRecord::RecordNotFound
       end
       redirect_to message_train.unsubscribes_url
     end
@@ -53,10 +61,15 @@ module MessageTrain
         if @from == @box_user
           message = :unsubscribe_removed_message.l
         else
-          name_column = MessageTrain.configuration.name_columns[@unsubscribe.from.class.table_name.to_sym]
+          name_column = MessageTrain.configuration.name_columns[
+            @unsubscribe.from.class.table_name.to_sym
+          ]
           collective_name = @unsubscribe.from.send(name_column)
           collective_type = @unsubscribe.from_type
-          message = :collective_unsubscribe_removed_message.l(collective_name: collective_name, collective_type: collective_type)
+          message = :collective_unsubscribe_removed_message.l(
+            collective_name: collective_name,
+            collective_type: collective_type
+          )
         end
         @unsubscribe.destroy
         flash[:notice] = message
@@ -64,9 +77,10 @@ module MessageTrain
       redirect_to message_train.unsubscribes_url
     end
 
-  private
+    private
 
-    # Never trust parameters from the scary internet, only allow the white list through.
+    # Never trust parameters from the scary internet, only allow the white list
+    # through.
     def unsubscribe_params
       params.require(:unsubscribe).permit(:from_type, :from_id)
     end

data/app/helpers/message_train/application_helper.rb

@@ -1,26 +1,24 @@
 module MessageTrain
+  # Application helper
   module ApplicationHelper
-
     def message_train_widget
       render partial: 'message_train/application/widget'
     end
 
     def fuzzy_date(date)
       time = Time.parse(date.strftime('%F %T'))
-      # Don't get confused: ">" here means "after", not "more than"
-      if time > 1.minute.ago
+      case Time.now - time
+      when 0..1.minute
         :just_now.l
-      elsif time > 1.day.ago
+      when 1.minute..1.day
         l(time, format: :fuzzy_today)
-      elsif time > 1.week.ago
+      when 1.day..1.week
         l(time, format: :fuzzy_this_week)
-      elsif time > 1.year.ago
+      when 1.week..1.year
         l(time, format: :fuzzy_date_without_year)
       else
         l(time, format: :fuzzy_date)
       end
-
     end
-
   end
 end

data/app/helpers/message_train/attachments_helper.rb

@@ -1,11 +1,16 @@
 module MessageTrain
+  # Attachments helper
   module AttachmentsHelper
     def attachment_icon(attachment)
-      html = ""
+      html = ''
       if attachment.image?
         html << image_tag(attachment.attachment.url(:thumb))
       else
-        html << content_tag(:span, '', class: 'glyphicon glyphicon-save-file glyphicon-thumbnail')
+        html << content_tag(
+          :span,
+          '',
+          class: 'glyphicon glyphicon-save-file glyphicon-thumbnail'
+        )
         html << tag(:br)
         html << attachment.attachment_file_name
       end
@@ -13,7 +18,10 @@ module MessageTrain
     end
 
     def attachment_link(attachment)
-      render partial: 'message_train/application/attachment_link', locals: { attachment: attachment }
+      render(
+        partial: 'message_train/application/attachment_link',
+        locals: { attachment: attachment }
+      )
     end
   end
-end
+end

data/app/helpers/message_train/boxes_helper.rb

@@ -1,35 +1,62 @@
 module MessageTrain
+  # Boxes helper
   module BoxesHelper
-
     def box_nav_item(box)
       text = box.title
       link = message_train.box_path(box.division)
       unread_count = box.unread_count
-      if unread_count > 0
-        text << badge(unread_count.to_s.gsub(/\s+/, ""), 'info pull-right')
-      end
-      nav_item text.gsub(/[\n\t]/,'').html_safe, link
+      unread_count > 0 &&
+        text << badge(unread_count.to_s.gsub(/\s+/, ''), 'info pull-right')
+      nav_item text.gsub(/[\n\t]/, '').html_safe, link
     end
 
     def box_list_item(box, html_options = {})
-      render partial: 'message_train/boxes/list_item', locals: { box: box, html_options: html_options, unread_count: box.unread_count }
+      render(
+        partial: 'message_train/boxes/list_item',
+        locals: {
+          box: box,
+          html_options: html_options,
+          unread_count: box.unread_count
+        }
+      )
     end
 
     def boxes_widget(box_user)
-      render partial: 'message_train/boxes/widget', locals: { boxes: box_user.all_boxes }
+      render(
+        partial: 'message_train/boxes/widget',
+        locals: { boxes: box_user.all_boxes }
+      )
     end
 
-    def boxes_dropdown_list(box_user, options = {})
-      render partial: 'message_train/boxes/dropdown_list', locals: { boxes: box_user.all_boxes }
+    def boxes_dropdown_list(box_user)
+      render(
+        partial: 'message_train/boxes/dropdown_list',
+        locals: { boxes: box_user.all_boxes }
+      )
     end
 
     def box_participant_name(participant)
-      participant.send(MessageTrain.configuration.name_columns[participant.class.table_name.to_sym])
+      participant.send(
+        MessageTrain.configuration.name_columns[
+          participant.class.table_name.to_sym
+        ]
+      )
     end
 
     def box_participant_slug(participant)
-      participant.send(MessageTrain.configuration.slug_columns[participant.class.table_name.to_sym])
+      participant.send(
+        MessageTrain.configuration.slug_columns[
+          participant.class.table_name.to_sym
+        ]
+      )
     end
 
+    def box_participant_path(participant)
+      message_train.box_model_participant_path(
+        @box,
+        participant.class.table_name,
+        participant.id
+      )
+    end
   end
 end

data/app/helpers/message_train/collectives_helper.rb

@@ -1,8 +1,11 @@
 module MessageTrain
+  # Collectives helper
   module CollectivesHelper
-
     def collective_boxes_widget(collective, box_user)
-      render partial: 'message_train/collectives/widget', locals: { collective: collective, box_user: box_user }
+      render(
+        partial: 'message_train/collectives/widget',
+        locals: { collective: collective, box_user: box_user }
+      )
     end
 
     def collective_nav_item(box, box_user)
@@ -16,33 +19,56 @@ module MessageTrain
       end
       link = message_train.collective_box_path(box.parent.path_part, division)
       unread_count = box.unread_count
-      if unread_count > 0
-        text << badge(unread_count.to_s, 'info pull-right')
-      end
+      unread_count > 0 && text << badge(unread_count.to_s, 'info pull-right')
       nav_item text.html_safe, link
     end
 
     def collective_list_item(box, html_options = {})
-      render partial: 'message_train/collectives/list_item', locals: { box: box, html_options: html_options, unread_count: box.unread_count }
+      render(
+        partial: 'message_train/collectives/list_item',
+        locals: {
+          box: box,
+          html_options: html_options,
+          unread_count: box.unread_count
+        }
+      )
     end
 
     def collective_boxes_dropdown_list(box_user)
       total_unread_count = {}
       show = {}
       box_user.collective_boxes.each do |table_sym, collectives|
-        total_unread_count[table_sym] = collectives.collect { |collective_box| collective_box.unread_count }.sum
-        show[table_sym] = collectives.select { |collective_box| collective_box.parent.allows_sending_by?(box_user) || collective_box.parent.allows_receiving_by?(box_user) }.any?
+        total_unread_count[table_sym] = collectives.collect(&:unread_count).sum
+        show[table_sym] = collectives.select do |collective_box|
+          collective_box.parent.allows_sending_by?(box_user) ||
+            collective_box.parent.allows_receiving_by?(box_user)
+        end.any?
       end
-      render partial: 'message_train/collectives/dropdown_list', locals: { collective_boxes: box_user.collective_boxes, total_unread_count: total_unread_count, show: show, box_user: box_user }
+      render(
+        partial: 'message_train/collectives/dropdown_list',
+        locals: {
+          collective_boxes: box_user.collective_boxes,
+          total_unread_count: total_unread_count,
+          show: show,
+          box_user: box_user
+        }
+      )
     end
 
     def collective_name(collective)
-      collective.send(MessageTrain.configuration.name_columns[collective.class.table_name.to_sym])
+      collective.send(
+        MessageTrain.configuration.name_columns[
+          collective.class.table_name.to_sym
+        ]
+      )
     end
 
     def collective_slug(collective)
-      collective.send(MessageTrain.configuration.slug_columns[collective.class.table_name.to_sym])
+      collective.send(
+        MessageTrain.configuration.slug_columns[
+          collective.class.table_name.to_sym
+        ]
+      )
     end
-
   end
 end

data/app/helpers/message_train/conversations_helper.rb

@@ -1,4 +1,5 @@
 module MessageTrain
+  # Conversations helper
   module ConversationsHelper
     def conversation_senders(conversation)
       names = []
@@ -11,71 +12,78 @@ module MessageTrain
     def conversation_class(box, conversation)
       css_classes = []
 
-      if conversation.includes_unread_for?(@box_user)
-        css_classes << 'unread'
-      else
-        css_classes << 'read'
-      end
+      css_classes << if conversation.includes_unread_for?(@box_user)
+                       'unread'
+                     else
+                       'read'
+                     end
 
-      if conversation.includes_drafts_by?(@box_user)
-        css_classes << 'draft'
-      end
+      conversation.includes_drafts_by?(@box_user) && css_classes << 'draft'
 
-      unless conversation.includes_undeleted_for?(@box_user)
-        css_classes << 'hide'
-      end
+      !conversation.includes_undeleted_for?(@box_user) && css_classes << 'hide'
 
       if box.division == :trash
-        unless conversation.includes_trashed_for?(@box_user)
+        !conversation.includes_trashed_for?(@box_user) &&
           css_classes << 'hide'
-        end
       else
-        unless conversation.includes_untrashed_for?(@box_user)
+        !conversation.includes_untrashed_for?(@box_user) &&
           css_classes << 'hide'
-        end
         if box.division == :ignored
-          unless conversation.is_ignored?(@box_user)
-            css_classes << 'hide'
-          end
+          !conversation.participant_ignored?(@box_user) && css_classes << 'hide'
         else
-          if conversation.is_ignored?(@box_user)
-            css_classes << 'hide'
-          end
+          conversation.participant_ignored?(@box_user) && css_classes << 'hide'
         end
       end
       css_classes.uniq.join(' ')
     end
 
     def conversation_trashed_toggle(conversation, collective = nil)
-      render partial: 'message_train/conversations/trashed_toggle', locals: { conversation: conversation, collective: collective }
+      render(
+        partial: 'message_train/conversations/trashed_toggle',
+        locals: { conversation: conversation, collective: collective }
+      )
     end
 
     def conversation_read_toggle(conversation, collective = nil)
-      render partial: 'message_train/conversations/read_toggle', locals: { conversation: conversation, collective: collective }
+      render(
+        partial: 'message_train/conversations/read_toggle',
+        locals: { conversation: conversation, collective: collective }
+      )
     end
 
     def conversation_ignored_toggle(conversation, collective = nil)
-      render partial: 'message_train/conversations/ignored_toggle', locals: { conversation: conversation, collective: collective }
+      render(
+        partial: 'message_train/conversations/ignored_toggle',
+        locals: { conversation: conversation, collective: collective }
+      )
     end
 
     def conversation_deleted_toggle(conversation, collective = nil)
-      render partial: 'message_train/conversations/deleted_toggle', locals: { conversation: conversation, collective: collective }
+      render(
+        partial: 'message_train/conversations/deleted_toggle',
+        locals: { conversation: conversation, collective: collective }
+      )
     end
 
-  private
+    private
 
-    def conversation_toggle(conversation, icon, mark_to_set, method, title, options = {})
+    # rubocop:disable Metrics/ParameterLists
+    def conversation_toggle(conv, icon, mark, method, title, options = {})
       options[:remote] = true
       options[:method] = method
       options[:title] = title
-      options[:class] ||= ""
-      options[:class] += " " + mark_to_set.to_s + "-toggle"
-      render partial: 'message_train/conversations/toggle', locals: {
-                                                            conversation: conversation,
-                                                            icon: icon,
-                                                            mark_to_set: mark_to_set,
-                                                            options: options
-                                                        }
+      options[:class] ||= ''
+      options[:class] += " #{mark}-toggle"
+      render(
+        partial: 'message_train/conversations/toggle',
+        locals: {
+          conversation: conv,
+          icon: icon,
+          mark_to_set: mark,
+          options: options
+        }
+      )
     end
+    # rubocop:enable Metrics/ParameterLists
   end
 end

data/app/helpers/message_train/messages_helper.rb

@@ -1,60 +1,67 @@
 module MessageTrain
+  # Messages helper
   module MessagesHelper
     def message_class(box, message)
       css_classes = []
 
-      if message.is_unread_for?(@box_user)
-        css_classes << 'unread panel-info'
-      else
-        css_classes << 'read'
-      end
+      css_classes << if message.is_unread_for?(@box_user)
+                       'unread panel-info'
+                     else
+                       'read'
+                     end
 
-      if message.draft
-        css_classes << 'draft'
-      end
+      message.draft && css_classes << 'draft'
 
       if box.division == :trash
-        unless message.is_trashed_for?(@box_user)
-          css_classes << 'hide'
-        end
+        !message.is_trashed_for?(@box_user) && css_classes << 'hide'
       else
-        unless message.is_untrashed_for?(@box_user)
-          css_classes << 'hide'
-        end
+        !message.is_untrashed_for?(@box_user) && css_classes << 'hide'
       end
       css_classes.join(' ')
     end
 
     def message_trashed_toggle(message)
-      render partial: 'message_train/messages/trashed_toggle', locals: { message: message }
+      render(
+        partial: 'message_train/messages/trashed_toggle',
+        locals: { message: message }
+      )
     end
 
     def message_read_toggle(message)
-      render partial: 'message_train/messages/read_toggle', locals: { message: message }
+      render(
+        partial: 'message_train/messages/read_toggle',
+        locals: { message: message }
+      )
     end
 
     def message_deleted_toggle(message)
-      render partial: 'message_train/messages/deleted_toggle', locals: { message: message }
+      render(
+        partial: 'message_train/messages/deleted_toggle',
+        locals: { message: message }
+      )
     end
 
     def message_recipients(message)
       message.recipients.collect { |x| box_participant_name(x) }.to_sentence
     end
 
-  private
+    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[: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
-                                                     }
+      render(
+        partial: 'message_train/messages/toggle',
+        locals: {
+          message: message,
+          icon: icon,
+          mark_to_set: mark_to_set,
+          options: options
+        }
+      )
     end
   end
 end

data/app/mailers/message_train/application_mailer.rb

@@ -1,8 +1,11 @@
 module MessageTrain
+  # Application mailer
   class ApplicationMailer < ActionMailer::Base
-    default from: MessageTrain.configuration.from_email,
-        charset:       "utf-8",
-        content_type:  "text/html"
+    default(
+      from: MessageTrain.configuration.from_email,
+      charset: 'utf-8',
+      content_type: 'text/html'
+    )
     layout 'mailer'
   end
-end
+end

data/app/mailers/message_train/previews/receipt_mailer_preview.rb

@@ -1,10 +1,9 @@
 module MessageTrain
+  # Receipt mailer preview
   class ReceiptMailerPreview < ActionMailer::Preview
-
     def notification_email
       receipt = MessageTrain::Receipt.last
       ReceiptMailer.notification_email(receipt)
     end
-
   end
-end
+end

data/app/mailers/message_train/receipt_mailer.rb

@@ -1,17 +1,27 @@
 module MessageTrain
+  # Receipt mailer
   class ReceiptMailer < ApplicationMailer
     def notification_email(receipt)
       @receipt = receipt
       @recipient = receipt.recipient
       @through = receipt.received_through
       if @recipient == @through
-        @heading = :new_message_on_site_name.l(site_name: MessageTrain.configuration.site_name)
+        @heading = :new_message_on_site_name.l(
+          site_name: MessageTrain.configuration.site_name
+        )
       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)
+        @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
       @subject = "#{@heading}: #{@receipt.message.subject}"
       mail(to: @recipient.email, subject: @subject)
     end
   end
-end
+end