message_train 0.6.17 → 0.7.1

data/app/models/message_train/receipt.rb

@@ -3,29 +3,66 @@ module MessageTrain
   class Receipt < ActiveRecord::Base
     belongs_to :recipient, polymorphic: true
     belongs_to :received_through, polymorphic: true
-    belongs_to(
-      :message,
-      foreign_key: :message_train_message_id,
-      touch: true
-    )
+    belongs_to :message, foreign_key: :message_train_message_id, touch: true
+    delegate :conversation, to: :message
     validates_presence_of :recipient, :message
 
-    default_scope { order(updated_at: :desc) }
+    after_create :notify
+
     scope :sender_receipt, -> { where(sender: true) }
     scope :recipient_receipt, -> { where(sender: false) }
+    scope :for, ->(recipient) { where(recipient: recipient) }
     scope :by, ->(sender) { sender_receipt.for(sender) }
-    scope :for, (lambda do |recipient|
-      where(recipient: recipient)
-    end)
     scope :to, ->(recipient) { recipient_receipt.for(recipient) }
-    scope :through, (lambda do |received_through|
-      where(received_through: received_through)
-    end)
+    scope :through, ->(recipient) { where(received_through: recipient) }
     scope :trashed, ->(setting = true) { where(marked_trash: setting) }
     scope :read, ->(setting = true) { where(marked_read: setting) }
     scope :deleted, ->(setting = true) { where(marked_deleted: setting) }
+    scope :for_messages, ->(messages) { where(message: messages) }
+    scope :flagged, ->(flag, *args) { send(flag.to_sym, *args) }
 
-    after_create :notify
+    def self.message_ids
+      pluck(:message_train_message_id)
+    end
+
+    def self.messages
+      MessageTrain::Message.where(id: message_ids)
+    end
+
+    def self.conversation_ids
+      messages.conversation_ids
+    end
+
+    def self.conversations
+      MessageTrain::Conversation.where(id: conversation_ids)
+    end
+
+    def self.generate_for_sender(sender)
+      first_or_create!(recipient: sender, received_through: sender, sender: 1)
+    end
+
+    def self.send_to_or_through(recipient)
+      if recipient.class.collective?
+        send_through recipient, recipient.class.valid_recipients_method
+      else
+        send_to recipient
+      end
+    end
+
+    def self.send_to(recipient)
+      receipt = new recipient: recipient, received_through: recipient
+      return if receipt.conversation.participant_ignored?(recipient)
+      receipt.save
+    end
+
+    def self.send_through(recipient, end_recipient_method)
+      recipient.send(end_recipient_method).distinct.each do |end_recipient|
+        receipt = new recipient: end_recipient, received_through: recipient
+        next if receipt.conversation.participant_ignored?(end_recipient) ||
+                receipt.message.sender == end_recipient
+        receipt.save
+      end
+    end
 
     def mark(mark_to_set)
       if mark_to_set.to_s =~ /^un/
@@ -39,47 +76,35 @@ module MessageTrain
       update_attribute(column, setting)
     end
 
-    def self.message_ids
-      pluck(:message_train_message_id)
-    end
-
-    def self.messages
-      MessageTrain::Message.joins(:receipts)
-                           .where(message_train_receipts: { id: where(nil) })
+    def self.mark(mark_to_set)
+      where(nil).each { |receipt| receipt.mark(mark_to_set) }
     end
 
-    def self.conversation_ids
-      messages.conversation_ids
+    def self.method_missing(method_sym, *args, &block)
+      method_string = method_sym.to_s
+      if method_string =~ /\A(.*)_(by|to|for|through)\z/
+        first_sym = Regexp.last_match[1].to_sym
+        second_sym = Regexp.last_match[2].to_sym
+        return run_prepositional_method(first_sym, second_sym, *args)
+      elsif method_string =~ /\Aun(.*)\z/
+        first_sym = Regexp.last_match[1].to_sym
+        return run_un_method(first_sym)
+      end
+      super
     end
 
-    def self.conversations
-      MessageTrain::Conversation.joins(:receipts)
-                                .where(
-                                  message_train_receipts: { id: where(nil) }
-                                )
+    def self.run_prepositional_method(first_sym, second_sym, *args)
+      return send(second_sym, *args) if first_sym == :receipts
+      send(first_sym).send(second_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 =~ /^receipts_(by|to|for|through)$/
-        send(Regexp.last_match[1].to_sym, arguments.first)
-      elsif method_sym.to_s =~ /^(.*)_(by|to|for|through)$/
-        send(Regexp.last_match[1].to_sym)
-          .send(Regexp.last_match[2].to_sym, arguments.first)
-      elsif method_sym.to_s =~ /^un(.*)$/
-        send(Regexp.last_match[1].to_sym, false)
-      else
-        super
-      end
+    def self.run_un_method(first_sym)
+      send(first_sym, false)
     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 self.respond_to?(method_sym, include_private = false)
-      if method_sym.to_s =~ /^(.*)_(by|to|for|through)$/ ||
-         method_sym.to_s =~ /^un(.*)$/
+    def self.respond_to_missing?(method_sym, include_private = false)
+      if method_sym.to_s =~ /\A(.*)_(by|to|for|through)\z/ ||
+         method_sym.to_s =~ /\Aun(.*)\z/
         true
       else
         super
@@ -89,9 +114,8 @@ module MessageTrain
     private
 
     def notify
-      unless sender? || recipient.unsubscribed_from?(received_through)
-        ReceiptMailer.notification_email(self).deliver_later
-      end
+      return if sender? || recipient.unsubscribed_from?(received_through)
+      ReceiptMailer.notification_email(self).deliver_now
     end
   end
 end

data/app/views/message_train/boxes/show.html.haml

@@ -1,12 +1,16 @@
-- if @collective.nil?
-  - add_title @box.title
-  - marking_path = message_train.box_path(@box.division)
-- else
-  - add_title collective_name(@collective) + ' ' + @box.title
-  - marking_path = message_train.collective_box_path(@collective.path_part, @box.division)
+:ruby
+  if @collective.nil?
+    add_title @box.title
+    marking_path = message_train.box_path(@box.division)
+  else
+    add_title collective_name(@collective) + ' ' + @box.title
+    marking_path = message_train.collective_box_path(@collective.path_part, @box.division)
+  end
 - cache ['message-train', 'boxes-show', @box_user, @box] do
   = form_tag marking_path, method: :put, remote: true, id: 'box', data: { type: :json } do
-    - unless @conversations.empty?
+    - if @conversations.empty?
+      %em= :box_is_empty.l
+    - else
       #box-actions.box-actions
         .btn-group.check-all
           %button.btn.btn-default{ type: 'button' }

data/config/locales/en.yml

@@ -22,6 +22,7 @@ en:
   at_time_through_received_a_message: "At %{time}, %{through} received a message: <a href=\"%{path}\">%{subject}</a>"
   attachment_preview: 'Attachment Preview'
   attachments: 'Attachments'
+  box_is_empty: 'This box is empty.'
   box_title_in: 'Inbox'
   box_title_sent: 'Sent'
   box_title_all: 'All'

data/config/routes.rb

@@ -30,26 +30,20 @@ MessageTrain::Engine.routes.draw do
   end
 
   match(
-    '/box(/*path)' => redirect do |_p, req|
-      req.flash[:error] = :you_must_sign_in_or_sign_up_to_continue.l
-      MessageTrain.configuration.user_sign_in_path
-    end,
+    '/box(/*path)',
+    to: 'boxes#redirect_to_sign_in',
     via: [:get, :put, :post, :delete]
   )
 
   match(
-    '/collectives(/*path)' => redirect do |_p, req|
-      req.flash[:error] = :you_must_sign_in_or_sign_up_to_continue.l
-      MessageTrain.configuration.user_sign_in_path
-    end,
+    '/collectives(/*path)',
+    to: 'boxes#redirect_to_sign_in',
     via: [:get, :put, :post, :delete]
   )
 
   match(
-    '/unsubscribes(/*path)' => redirect do |_p, req|
-      req.flash[:error] = :you_must_sign_in_or_sign_up_to_continue.l
-      MessageTrain.configuration.user_sign_in_path
-    end,
+    '/unsubscribes(/*path)',
+    to: 'unsubscribes#redirect_to_sign_in',
     via: [:get, :put, :post, :delete]
   )
 end

data/lib/message_train.rb

@@ -13,9 +13,11 @@ module MessageTrain
   require 'message_train/localization'
   require 'message_train/version'
   require 'message_train/mixin'
+  require 'message_train/class_methods'
+  require 'message_train/instance_methods'
 
   require 'haml-rails'
   require 'bootstrap_leather'
 end
 
-ActiveRecord::Base.send(:include, MessageTrain::Mixin)
+ActiveRecord::Base.send(:extend, MessageTrain::Mixin)

data/lib/message_train/class_methods.rb

@@ -0,0 +1,51 @@
+module MessageTrain
+  # Extended when message_train mixin is run
+  module ClassMethods
+    def message_train_address_book(for_participant)
+      method = MessageTrain.configuration.address_book_methods[
+        message_train_table_sym
+      ]
+      method ||= MessageTrain.configuration.address_book_method
+      if method.present? && respond_to?(method)
+        send(method, for_participant)
+      else
+        all
+      end
+    end
+
+    def find_by_message_train_slug(slug)
+      find_by(slug_column => slug.strip)
+    end
+
+    def where_slug_starts_with(string)
+      return where(nil) unless string.present?
+      pattern = Regexp.union('\\', '%', '_')
+      string = string.gsub(pattern) { |x| ['\\', x].join }
+      where("#{slug_column} LIKE ?", "#{string}%")
+    end
+
+    def slug_column
+      MessageTrain.configuration.slug_columns[message_train_table_sym] || :slug
+    end
+
+    def name_column
+      MessageTrain.configuration.name_columns[message_train_table_sym] || :name
+    end
+
+    def valid_senders_method
+      MessageTrain.configuration
+                  .valid_senders_methods[message_train_table_sym] ||
+        :self_collection
+    end
+
+    def valid_recipients_method
+      MessageTrain.configuration
+                  .valid_recipients_methods[message_train_table_sym] ||
+        :self_collection
+    end
+
+    def collective?
+      valid_senders_method != :self_collection
+    end
+  end
+end

data/lib/message_train/configuration.rb

@@ -1,12 +1,34 @@
 # MessageTrain module
 module MessageTrain
+  # @conversions[:mixin_option] = :configuration_name
+  @conversions = {}
+  @conversions[:slug_column] = :slug_columns
+  @conversions[:name_column] = :name_columns
+  @conversions[:collectives_for_recipient] = :collectives_for_recipient_methods
+  @conversions[:valid_recipients] = :valid_recipients_methods
+  @conversions[:valid_senders] = :valid_senders_methods
+  @conversions[:address_book_method] = :address_book_methods
+
   def self.configure(configuration = MessageTrain::Configuration.new)
-    block_given? && yield(configuration)
-    @@configuration = configuration
+    yield(configuration) if block_given?
+    @configuration = configuration
   end
 
   def self.configuration
-    @@configuration ||= MessageTrain::Configuration.new
+    @configuration ||= MessageTrain::Configuration.new
+  end
+
+  def self.configure_table(table_sym, name, options)
+    configure(@configuration) do |config|
+      config.recipient_tables[table_sym] = name
+      @conversions.each do |mixin_option_sym, configuration_name_sym|
+        value = options[mixin_option_sym]
+        next unless value.present?
+        setting = config.send(configuration_name_sym)
+        setting[table_sym] = value
+        config.send("#{configuration_name_sym}=", setting)
+      end
+    end
   end
 
   # MessageTrain configuration
@@ -26,6 +48,8 @@ module MessageTrain
                   :from_email,
                   :site_name
 
+    # rubocop:disable Metrics/MethodLength
+    # Don't see any way to shorten this
     def initialize
       self.recipient_tables = {}
       self.slug_columns = { users: :slug }
@@ -42,5 +66,6 @@ module MessageTrain
       self.from_email = ''
       self.site_name = 'Example Site Name'
     end
+    # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/message_train/instance_methods.rb

@@ -0,0 +1,209 @@
+module MessageTrain
+  # Included in method when message_train mixin is run
+  module InstanceMethods
+    def self.included(base)
+      base.send :include, InstanceMethods::GeneralMethods
+      base.message_train_relationships.include?(:recipient) &&
+        base.send(:include, InstanceMethods::RecipientMethods)
+    end
+
+    # Included by InstanceMethods when message_train mixin is run
+    module GeneralMethods
+      BOX_DEFINITIONS = {
+        in: :with_untrashed_to,
+        sent: :with_untrashed_by,
+        all: :with_untrashed_for,
+        drafts: :with_drafts_by,
+        trash: :with_trashed_for,
+        ignored: :ignored
+      }.freeze
+
+      BOX_OMISSION_DEFINITIONS = {
+        trash: :without_trashed_for,
+        drafts: :with_ready_for,
+        ignored: :unignored
+      }.freeze
+
+      def path_part
+        return unless self.class.collective?
+        # This must mean it's a collective
+        "#{self.class.table_name}:#{message_train_slug}"
+      end
+
+      def valid_senders
+        send(self.class.valid_senders_method)
+      end
+
+      def allows_sending_by?(sender)
+        valid_senders.include? sender
+      end
+
+      def valid_recipients
+        send(self.class.valid_recipients_method)
+      end
+
+      def allows_access_by?(recipient)
+        allows_receiving_by?(recipient) || allows_sending_by?(recipient)
+      end
+
+      def allows_receiving_by?(recipient)
+        return false if valid_recipients.empty?
+        valid_recipients.include? recipient
+      end
+
+      def self_collection
+        # This turns a single record into an active record collection.
+        self.class.where(id: id)
+      end
+
+      def conversations(*args)
+        division = args[0] || :in
+        participant = args[1] || self
+        definition_method = BOX_DEFINITIONS[division]
+        return if definition_method.nil?
+        conversations = defined_conversations(definition_method, participant)
+        BOX_OMISSION_DEFINITIONS.each do |division_key, omission_method|
+          next if division_key == division # Because not to be omitted
+          conversations = conversations.send(omission_method, participant)
+        end
+        conversations
+      end
+
+      def defined_conversations(definition, participant)
+        MessageTrain::Conversation.with_messages_through(self)
+                                  .without_deleted_for(participant)
+                                  .send(definition, participant)
+      end
+
+      def boxes_for_participant(participant)
+        original_order = [:in, :sent, :all, :drafts, :trash, :ignored]
+        divisions = [:all, :trash]
+        if respond_to?(:messages) || allows_sending_by?(participant)
+          divisions += [:sent, :drafts]
+        end
+        divisions += [:in, :ignored] if allows_receiving_by?(participant)
+        divisions.sort_by! { |x| original_order.index x }
+        divisions.collect { |d| MessageTrain::Box.new(self, d, participant) }
+      end
+
+      def all_conversations(*args)
+        participant = args[0] || self
+        results = MessageTrain::Conversation.with_messages_through(self)
+        return [] if results.empty?
+        results.with_messages_for(participant)
+      end
+
+      def all_messages(*args)
+        participant = args[0] || self
+        results = MessageTrain::Message.with_receipts_through(self)
+        return [] if results.empty?
+        results.with_receipts_for(participant)
+      end
+
+      def unsubscribed_from_all?
+        unsubscribes.where(from: nil).exists?
+      end
+
+      def unsubscribed_from?(from)
+        unsubscribed_from_all? || unsubscribes.where(from: from).exists?
+      end
+
+      def unsubscribe_from(from)
+        unsubscribes.find_or_create_by(from: from)
+      end
+
+      def subscriptions
+        subscriptions = [self_subscription]
+        subscriptions += collective_boxes.values.map do |boxes|
+          boxes.map { |box| subscription(box) }
+        end
+        subscriptions.flatten.compact
+      end
+    end
+
+    # Included by InstanceMethods when message_train mixin is run, if this is a
+    # recipient
+    module RecipientMethods
+      def box(*args)
+        division = args[0] || :in
+        participant = args[1] || self
+        @box ||= MessageTrain::Box.new(self, division, participant)
+      end
+
+      def collective_boxes(*args)
+        division = args[0] || :in
+        participant = args[1] || self
+        cb_tables = MessageTrain.configuration
+                                .collectives_for_recipient_methods
+        return {} if cb_tables.empty?
+        Hash[cb_tables.map do |key, value|
+          box = table_collective_box(key, value, division, participant)
+          [key, box]
+        end]
+      end
+
+      def collective_boxes_unread_counts
+        Hash[collective_boxes.map do |key, collectives|
+          [key, collectives.collect(&:unread_count).sum]
+        end]
+      end
+
+      def collective_boxes_show_flags
+        Hash[collective_boxes.map do |key, collectives|
+          flag = collectives.select do |collective_box|
+            collective_box.parent.allows_access_by?(self)
+          end.any?
+          [key, flag]
+        end]
+      end
+
+      def table_collective_box(
+        table_sym, collectives_method, division, participant
+      )
+        model = MessageTrain.configuration
+                            .recipient_tables[table_sym]
+                            .constantize
+        collectives = model.send(collectives_method, participant)
+        collectives.map { |x| x.box(division, participant) }.compact
+      end
+
+      def all_boxes(*args)
+        participant = args[0] || self
+        divisions = [:in, :sent, :all, :drafts, :trash, :ignored]
+        divisions.collect do |division|
+          MessageTrain::Box.new(self, division, participant)
+        end
+      end
+
+      def message_train_name
+        send(self.class.name_column)
+      end
+
+      def message_train_slug
+        send(self.class.slug_column)
+      end
+
+      protected
+
+      def self_subscription
+        {
+          from: self, from_type: self.class.name, from_id: id,
+          from_name: :messages_directly_to_myself.l,
+          unsubscribe: unsubscribes.find_by(from: self)
+        }
+      end
+
+      def subscription(box)
+        parent = box.parent
+        return unless parent.allows_receiving_by?(self)
+        {
+          from: parent, from_type: parent.class.name, from_id: parent.id,
+          from_name: :messages_to_collective.l(
+            collective: parent.message_train_name
+          ),
+          unsubscribe: unsubscribes.find_by(from: parent)
+        }
+      end
+    end
+  end
+end