message_train 0.5.2 → 0.5.3

data/lib/message_train/mixin.rb

@@ -1,22 +1,33 @@
 module MessageTrain
+  # Mixin for including in a model
   module Mixin
     extend ActiveSupport::Concern
     class_methods do
       def message_train(options = {})
         table_sym = table_name.to_sym
 
-        relationships = options[:only] ? [options[:only]].flatten : [:sender, :recipient]
-        if options[:except]
-          relationships = relationships - [options[:except]].flatten
-        end
+        relationships = if options[:only]
+                          [options[:only]].flatten
+                        else
+                          [:sender, :recipient]
+                        end
+        options[:except] && relationships -= [options[:except]].flatten
 
         if relationships.include? :sender
           has_many :messages, as: :sender, class_name: 'MessageTrain::Message'
         end
 
         if relationships.include? :recipient
-          has_many :receipts, as: :recipient, class_name: 'MessageTrain::Receipt'
-          has_many :unsubscribes, as: :recipient, class_name: 'MessageTrain::Unsubscribe'
+          has_many(
+            :receipts,
+            as: :recipient,
+            class_name: 'MessageTrain::Receipt'
+          )
+          has_many(
+            :unsubscribes,
+            as: :recipient,
+            class_name: 'MessageTrain::Unsubscribe'
+          )
         end
 
         MessageTrain.configure(MessageTrain.configuration) do |config|
@@ -29,7 +40,9 @@ module MessageTrain
           end
 
           if options[:address_book_method].present?
-            config.address_book_methods[table_sym] = options[:address_book_method]
+            config.address_book_methods[table_sym] = options[
+              :address_book_method
+            ]
           end
 
           if relationships.include? :recipient
@@ -37,7 +50,9 @@ module MessageTrain
           end
 
           if options[:collectives_for_recipient].present?
-            config.collectives_for_recipient_methods[table_sym] = options[:collectives_for_recipient]
+            config.collectives_for_recipient_methods[table_sym] = options[
+              :collectives_for_recipient
+            ]
           end
 
           if options[:valid_senders].present?
@@ -45,166 +60,203 @@ module MessageTrain
           end
 
           if options[:valid_recipients].present?
-            config.valid_recipients_methods[table_sym] = options[:valid_recipients]
+            config.valid_recipients_methods[table_sym] = options[
+              :valid_recipients
+            ]
           end
         end
 
-        send(:define_method, :slug_part) {
+        send(:define_method, :slug_part) do
           send(MessageTrain.configuration.slug_columns[table_sym] || :slug)
-        }
+        end
 
-        send(:define_method, :path_part) {
-          if MessageTrain.configuration.valid_senders_methods[table_sym].present?
+        send(:define_method, :path_part) do
+          if MessageTrain.configuration.valid_senders_methods[
+            table_sym
+          ].present?
             # This must mean it's a collective
             "#{self.class.table_name}:#{slug_part}"
           end
-        }
+        end
 
-        send(:define_method, :valid_senders) {
-          valid_senders_method = MessageTrain.configuration.valid_senders_methods[self.class.table_name.to_sym] || :self_collection
-          send(valid_senders_method)
-        }
+        send(:define_method, :valid_senders) do
+          send(
+            MessageTrain.configuration.valid_senders_methods[
+              self.class.table_name.to_sym
+            ] || :self_collection
+          )
+        end
 
-        send(:define_method, :allows_sending_by?) { |sender|
+        send(:define_method, :allows_sending_by?) do |sender|
           valid_senders.include? sender
-        }
+        end
 
-        send(:define_method, :valid_recipients) {
-          valid_recipients_method = MessageTrain.configuration.valid_recipients_methods[self.class.table_name.to_sym] || :self_collection
-          send(valid_recipients_method)
-        }
+        send(:define_method, :valid_recipients) do
+          send(
+            MessageTrain.configuration.valid_recipients_methods[
+              self.class.table_name.to_sym
+            ] || :self_collection
+          )
+        end
 
-        send(:define_method, :allows_receiving_by?) { |recipient|
-          if valid_recipients.nil? or valid_recipients.empty?
+        send(:define_method, :allows_receiving_by?) do |recipient|
+          if valid_recipients.nil? || valid_recipients.empty?
             false
           else
             valid_recipients.include? recipient
           end
-        }
+        end
 
-        send(:define_method, :self_collection) { # This turns a single record into an active record collection.
+        send(:define_method, :self_collection) do
+          # This turns a single record into an active record collection.
           model = self.class
-          model.where(id: self.id)
-        }
+          model.where(id: id)
+        end
 
         if relationships.include? :recipient
-          send(:define_method, :box) { |*args|
+          send(:define_method, :box) do |*args|
             case args.count
-              when 0
-                division = :in
-                participant = self
-              when 1
-                division = args[0] || :in
-                participant = self
-              when 2
-                division = args[0] || :in
-                participant = args[1] || self
-              else
-                raise :wrong_number_of_arguments_for_thing_expected_right_got_wrong.l(right: '0..2', wrong: args.count.to_s, thing: self.class.name)
+            when 0
+              division = :in
+              participant = self
+            when 1
+              division = args[0] || :in
+              participant = self
+            when 2
+              division = args[0] || :in
+              participant = args[1] || self
+            else
+              raise :wrong_number_of_arguments_right_wrong.l(
+                right: '0..2',
+                wrong: args.count.to_s,
+                thing: self.class.name
+              )
             end
             @box ||= MessageTrain::Box.new(self, division, participant)
-          }
+          end
 
-          send(:define_method, :collective_boxes) { |*args|
+          send(:define_method, :collective_boxes) do |*args|
             case args.count
-              when 0
-                division = :in
-                participant = self
-              when 1
-                division = args[0] || :in
-                participant = self
-              when 2
-                division = args[0] || :in
-                participant = args[1] || self
-              else # Treat all but the division as a hash of options
-                raise :wrong_number_of_arguments_for_thing_expected_right_got_wrong.l(right: '0..2', wrong: args.count.to_s, thing: self.class.name)
+            when 0
+              division = :in
+              participant = self
+            when 1
+              division = args[0] || :in
+              participant = self
+            when 2
+              division = args[0] || :in
+              participant = args[1] || self
+            else # Treat all but the division as a hash of options
+              raise :wrong_number_of_arguments_right_wrong.l(
+                right: '0..2',
+                wrong: args.count.to_s,
+                thing: self.class.name
+              )
             end
-            collective_box_tables = MessageTrain.configuration.collectives_for_recipient_methods
+            cb_tables = MessageTrain.configuration
+                                    .collectives_for_recipient_methods
             collective_boxes = {}
-            unless collective_box_tables.empty?
-              collective_box_tables.each do |table_sym, collectives_method|
-                class_name = MessageTrain.configuration.recipient_tables[table_sym]
+            unless cb_tables.empty?
+              cb_tables.each do |my_table_symbol, collectives_method|
+                class_name = MessageTrain.configuration
+                                         .recipient_tables[my_table_symbol]
                 model = class_name.constantize
                 collectives = model.send(collectives_method, participant)
-                unless collectives.empty?
-                  collectives.each do |collective|
-                    collective_boxes[table_sym] ||= []
-                    collective_boxes[table_sym] << collective.box(division, participant)
-                  end
+                next if collectives.empty?
+                collectives.each do |collective|
+                  collective_boxes[my_table_symbol] ||= []
+                  collective_boxes[my_table_symbol] << collective.box(
+                    division,
+                    participant
+                  )
                 end
               end
             end
             collective_boxes
-          }
+          end
 
-          send(:define_method, :all_boxes) { |*args|
+          send(:define_method, :all_boxes) do |*args|
             case args.count
-              when 0
-                participant = self
-              when 1
-                participant = args[0] || self
-              else # Treat all but the division as a hash of options
-                raise :wrong_number_of_arguments_for_thing_expected_right_got_wrong.l(right: '0..1', wrong: args.count.to_s, thing: self.class.name)
+            when 0
+              participant = self
+            when 1
+              participant = args[0] || self
+            else # Treat all but the division as a hash of options
+              raise :wrong_number_of_arguments_right_wrong.l(
+                right: '0..1',
+                wrong: args.count.to_s,
+                thing: self.class.name
+              )
             end
             divisions = [:in, :sent, :all, :drafts, :trash, :ignored]
-            divisions.collect { |division| MessageTrain::Box.new(self, division, participant) }
-          }
+            divisions.collect do |division|
+              MessageTrain::Box.new(self, division, participant)
+            end
+          end
         end
 
-        send(:define_method, :conversations) { |*args|
+        send(:define_method, :conversations) do |*args|
           case args.count
-            when 0
-              division = :in
-              participant = self
-            when 1
-              division = args[0] || :in
-              participant = self
-            when 2
-              division = args[0] || :in
-              participant = args[1] || self
-            else # Treat all but the division as a hash of options
-              raise :wrong_number_of_arguments_for_thing_expected_right_got_wrong.l(right: '0..2', wrong: args.count.to_s, thing: self.class.name)
+          when 0
+            division = :in
+            participant = self
+          when 1
+            division = args[0] || :in
+            participant = self
+          when 2
+            division = args[0] || :in
+            participant = args[1] || self
+          else # Treat all but the division as a hash of options
+            raise :wrong_number_of_arguments_right_wrong.l(
+              right: '0..2',
+              wrong: args.count.to_s,
+              thing: self.class.name
+            )
           end
-          my_conversations = MessageTrain::Conversation.with_messages_through(self)
+          my_conversations = MessageTrain::Conversation.with_messages_through(
+            self
+          )
           case division
-            when :in
-              my_conversations.with_untrashed_to(participant)
-            when :sent
-              my_conversations.with_untrashed_by(participant)
-            when :all
-              my_conversations.with_untrashed_for(participant)
-            when :drafts
-              my_conversations.with_drafts_by(participant)
-            when :trash
-              my_conversations.with_trashed_for(participant)
-            when :ignored
-              my_conversations.ignored(participant)
-            else
-              nil
+          when :in
+            my_conversations.with_untrashed_to(participant)
+          when :sent
+            my_conversations.with_untrashed_by(participant)
+          when :all
+            my_conversations.with_untrashed_for(participant)
+          when :drafts
+            my_conversations.with_drafts_by(participant)
+          when :trash
+            my_conversations.with_trashed_for(participant)
+          when :ignored
+            my_conversations.ignored(participant)
           end
-        }
+        end
 
-        send(:define_method, :boxes_for_participant) { |participant|
+        send(:define_method, :boxes_for_participant) do |participant|
           original_order = [:in, :sent, :all, :drafts, :trash, :ignored]
           divisions = [:all, :trash]
-          if self.respond_to?(:messages) || allows_sending_by?(participant)
+          if respond_to?(:messages) || allows_sending_by?(participant)
             divisions += [:sent, :drafts]
           end
-          if allows_receiving_by?(participant)
-            divisions += [:in, :ignored]
-          end
+          allows_receiving_by?(participant) && divisions += [:in, :ignored]
           divisions.sort_by! { |x| original_order.index x }
-          divisions.collect { |division| MessageTrain::Box.new(self, division, participant) }
-        }
+          divisions.collect do |division|
+            MessageTrain::Box.new(self, division, participant)
+          end
+        end
 
-        send(:define_method, :all_conversations) { |*args|
+        send(:define_method, :all_conversations) do |*args|
           case args.count
-            when 0
-              participant = self
-            when 1
-              participant = args[0] || self
-            else # Treat all but the division as a hash of options
-              raise :wrong_number_of_arguments_for_thing_expected_right_got_wrong.l(right: '0..1', wrong: args.count.to_s, thing: self.class.name)
+          when 0
+            participant = self
+          when 1
+            participant = args[0] || self
+          else # Treat all but the division as a hash of options
+            raise :wrong_number_of_arguments_right_wrong.l(
+              right: '0..1',
+              wrong: args.count.to_s,
+              thing: self.class.name
+            )
           end
           results = MessageTrain::Conversation.with_messages_through(self)
           if results.empty?
@@ -212,16 +264,20 @@ module MessageTrain
           else
             results.with_messages_for(participant)
           end
-        }
+        end
 
-        send(:define_method, :all_messages) { |*args|
+        send(:define_method, :all_messages) do |*args|
           case args.count
-            when 0
-              participant = self
-            when 1
-              participant = args[0] || self
-            else # Treat all but the division as a hash of options
-              raise :wrong_number_of_arguments_for_thing_expected_right_got_wrong.l(right: '0..1', wrong: args.count.to_s, thing: self.class.name)
+          when 0
+            participant = self
+          when 1
+            participant = args[0] || self
+          else # Treat all but the division as a hash of options
+            raise :wrong_number_of_arguments_right_wrong.l(
+              right: '0..1',
+              wrong: args.count.to_s,
+              thing: self.class.name
+            )
           end
           results = MessageTrain::Message.with_receipts_through(self)
           if results.empty?
@@ -229,46 +285,51 @@ module MessageTrain
           else
             results.with_receipts_for(participant)
           end
-        }
+        end
 
-        send(:define_method, :unsubscribed_from_all?) {
+        send(:define_method, :unsubscribed_from_all?) do
           unsubscribes.where(from: nil).exists?
-        }
+        end
 
-        send(:define_method, :unsubscribed_from?) { |from|
-          unsubscribed_from_all? or unsubscribes.where(from: from).exists?
-        }
+        send(:define_method, :unsubscribed_from?) do |from|
+          unsubscribed_from_all? || unsubscribes.where(from: from).exists?
+        end
 
-        send(:define_method, :unsubscribe_from) { |from|
+        send(:define_method, :unsubscribe_from) do |from|
           unsubscribes.find_or_create_by(from: from)
-        }
+        end
 
-        send(:define_method, :subscriptions) {
+        send(:define_method, :subscriptions) do
           subscriptions = []
           subscriptions << {
-              from: self,
-              from_type: self.class.name,
-              from_id: self.id,
-              from_name: :messages_directly_to_myself.l,
-              unsubscribe: self.unsubscribes.find_by(from: self)
+            from: self,
+            from_type: self.class.name,
+            from_id: id,
+            from_name: :messages_directly_to_myself.l,
+            unsubscribe: unsubscribes.find_by(from: self)
           }
           collective_boxes.values.each do |boxes|
             boxes.each do |box|
-              if box.parent.allows_receiving_by?(self)
-                collective_name = box.parent.send(MessageTrain.configuration.name_columns[box.parent.class.table_name.to_sym])
-                subscriptions << {
-                    from: box.parent,
-                    from_type: box.parent.class.name,
-                    from_id: box.parent.id,
-                    from_name: :messages_to_collective.l(collective: collective_name),
-                    unsubscribe: self.unsubscribes.find_by(from: box.parent)
-                }
-              end
+              next unless box.parent.allows_receiving_by?(self)
+              collective_name = box.parent.send(
+                MessageTrain.configuration.name_columns[
+                  box.parent.class.table_name.to_sym
+                ]
+              )
+              subscriptions << {
+                from: box.parent,
+                from_type: box.parent.class.name,
+                from_id: box.parent.id,
+                from_name: :messages_to_collective.l(
+                  collective: collective_name
+                ),
+                unsubscribe: unsubscribes.find_by(from: box.parent)
+              }
             end
           end
           subscriptions
-        }
+        end
       end
     end
   end
-end
+end

data/lib/message_train/version.rb

@@ -1,3 +1,4 @@
+# Message Train module
 module MessageTrain
   VERSION = File.read(File.expand_path('../../../VERSION', __FILE__))
 

data/lib/message_train.rb

@@ -1,9 +1,10 @@
+# MessageTrain module
 module MessageTrain
-  require "active_record/railtie"
-  require "action_controller/railtie"
-  require "action_mailer/railtie"
-  require "action_view/railtie"
-  require "sprockets/railtie"
+  require 'active_record/railtie'
+  require 'action_controller/railtie'
+  require 'action_mailer/railtie'
+  require 'action_view/railtie'
+  require 'sprockets/railtie'
 
   require 'rails-i18n'
 
@@ -17,4 +18,4 @@ module MessageTrain
   require 'bootstrap_leather'
 end
 
-ActiveRecord::Base.send(:include, MessageTrain::Mixin)
+ActiveRecord::Base.send(:include, MessageTrain::Mixin)

data/message_train.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: message_train 0.5.2 ruby lib
+# stub: message_train 0.5.3 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "message_train"
-  s.version = "0.5.2"
+  s.version = "0.5.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Karen Lundgren"]
-  s.date = "2016-03-01"
+  s.date = "2016-03-02"
   s.description = "Rails 4 Engine providing private/public messaging for any object, such as Users or Groups"
   s.email = "karen.e.lundgren@gmail.com"
   s.extra_rdoc_files = [
@@ -21,8 +21,10 @@ Gem::Specification.new do |s|
   s.files = [
     ".document",
     ".rspec",
+    ".rubocop.yml",
     ".ruby-gemset",
     ".ruby-version",
+    ".scss-lint.yml",
     ".simplecov",
     ".travis.yml",
     "Gemfile",
@@ -202,7 +204,6 @@ Gem::Specification.new do |s|
     "spec/dummy/config/routes.rb",
     "spec/dummy/config/secrets.yml",
     "spec/dummy/config/settings.yml",
-    "spec/dummy/config/unused/temporary_i18n_debugging.rb",
     "spec/dummy/db/migrate/20150721140013_devise_create_users.rb",
     "spec/dummy/db/migrate/20150721141009_rolify_create_roles.rb",
     "spec/dummy/db/migrate/20150721141128_create_groups.rb",
@@ -258,18 +259,18 @@ Gem::Specification.new do |s|
     "spec/models/user_spec.rb",
     "spec/rails_helper.rb",
     "spec/spec_helper.rb",
-    "spec/support/attachments.rb",
     "spec/support/controller_behaviors.rb",
     "spec/support/controller_macros.rb",
-    "spec/support/conversations.rb",
     "spec/support/factory_girl.rb",
     "spec/support/feature_behaviors.rb",
-    "spec/support/groups.rb",
-    "spec/support/loaded_site.rb",
-    "spec/support/messages.rb",
-    "spec/support/roles.rb",
+    "spec/support/loaded_site/attachments.rb",
+    "spec/support/loaded_site/conversations.rb",
+    "spec/support/loaded_site/groups.rb",
+    "spec/support/loaded_site/loaded_site.rb",
+    "spec/support/loaded_site/messages.rb",
+    "spec/support/loaded_site/roles.rb",
+    "spec/support/loaded_site/users.rb",
     "spec/support/shared_connection.rb",
-    "spec/support/users.rb",
     "spec/support/utilities.rb"
   ]
   s.homepage = "http://www.gemvein.com/museum/cases/message_train"
@@ -302,6 +303,10 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<sdoc>, ["~> 0.4.1"])
       s.add_development_dependency(%q<bundler>, ["~> 1.0"])
       s.add_development_dependency(%q<jeweler>, ["~> 2.0"])
+      s.add_development_dependency(%q<pre-commit>, ["~> 0.27"])
+      s.add_development_dependency(%q<rubocop>, ["~> 0.37"])
+      s.add_development_dependency(%q<coffeelint>, ["~> 1.14"])
+      s.add_development_dependency(%q<scss_lint>, ["~> 0.47.0"])
       s.add_development_dependency(%q<sqlite3>, ["~> 1.3"])
       s.add_development_dependency(%q<devise>, ["~> 3.5"])
       s.add_development_dependency(%q<rolify>, ["~> 4"])
@@ -335,6 +340,10 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<sdoc>, ["~> 0.4.1"])
       s.add_dependency(%q<bundler>, ["~> 1.0"])
       s.add_dependency(%q<jeweler>, ["~> 2.0"])
+      s.add_dependency(%q<pre-commit>, ["~> 0.27"])
+      s.add_dependency(%q<rubocop>, ["~> 0.37"])
+      s.add_dependency(%q<coffeelint>, ["~> 1.14"])
+      s.add_dependency(%q<scss_lint>, ["~> 0.47.0"])
       s.add_dependency(%q<sqlite3>, ["~> 1.3"])
       s.add_dependency(%q<devise>, ["~> 3.5"])
       s.add_dependency(%q<rolify>, ["~> 4"])
@@ -369,6 +378,10 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<sdoc>, ["~> 0.4.1"])
     s.add_dependency(%q<bundler>, ["~> 1.0"])
     s.add_dependency(%q<jeweler>, ["~> 2.0"])
+    s.add_dependency(%q<pre-commit>, ["~> 0.27"])
+    s.add_dependency(%q<rubocop>, ["~> 0.37"])
+    s.add_dependency(%q<coffeelint>, ["~> 1.14"])
+    s.add_dependency(%q<scss_lint>, ["~> 0.47.0"])
     s.add_dependency(%q<sqlite3>, ["~> 1.3"])
     s.add_dependency(%q<devise>, ["~> 3.5"])
     s.add_dependency(%q<rolify>, ["~> 4"])