active_touch 4.0.3 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee45dc1ba07f11a104b79342edd73c93e6294a36
-  data.tar.gz: d49f37861e80157adcba452556d1da23f459436d
+  metadata.gz: a7a498646a1de31a72530822ab3cbef4a9c28525
+  data.tar.gz: c2e260ebfc0eb50ebe3c6b10350e2a2362d5bcaa
 SHA512:
-  metadata.gz: 3b428e480c2e25b9b76508a9dee60d3390fed7c72780f1bd4a519e45df89e4101597c9757da72f22cd7664f28e29ed831b5b874bc9f1d7cf4bd306f423cd51dd
-  data.tar.gz: 922d0caa9b5d1ac346700ebc648801bfdca2345e9acf24976534c56fe247c9e22f637a957d803ef9fd748fa59a8dca25082eda9eea51c633396ca7fd80e6e4a0
+  metadata.gz: 8cbf64dee01ab998ef025dab0fd43de1806c46bc86a59e54c2045b766ffb523dfa789af9388a8a078f7c1d4b6746d37deba1356d73d80f23b75bb24de8ff5705
+  data.tar.gz: 5a5492a98e21fb775b4c39ad02927bc0bd26e785dcafea5f735679f50568de78f484735fba94ea35c613632110ce098db074fd4c6fac5144e9094cd70edd6b47

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    active_touch (4.0.2)
+    active_touch (4.0.3)
       rails (>= 4.0, < 6.0)
 
 GEM

data/lib/active_touch/configuration.rb

@@ -13,13 +13,15 @@ module ActiveTouch
   end
 
   class Configuration
-    attr_accessor :async, :ignored_attributes, :queue, :timestamp_attribute
+    attr_accessor :async, :ignored_attributes, :queue, :timestamp_attribute, :touch_in_transaction, :touch_updates
 
     def initialize
       @async = false
       @ignored_attributes = [:updated_at]
       @queue = 'default'
       @timestamp_attribute = :updated_at
+      @touch_in_transaction = true
+      @touch_updates = {}
     end
   end
 

data/lib/active_touch/define_touch.rb

@@ -11,52 +11,90 @@ module ActiveTouch
       @klass = klass
       @association = association
       @options = default_options.merge(options)
-      @update_touch_method = "touch_#{SecureRandom.uuid}"
-      @destroy_touch_method = "touch_#{SecureRandom.uuid}"
+      @before_commit_method = "touch_#{SecureRandom.uuid}"
+      @after_commit_method = "touch_#{SecureRandom.uuid}"
+      @before_destroy_method = "touch_#{SecureRandom.uuid}"
     end
 
     def define
-      define_update_touch_method
-      add_active_record_callback(:after_commit, @update_touch_method)
+      if @options[:touch_in_transaction]
+        define_before_commit_method
+        add_active_record_callback(:before_commit, @before_commit_method)
+      end
+
+      if !@options[:touch_in_transaction] || !@options[:after_touch].nil?
+        define_after_commit_method
+        add_active_record_callback(:after_commit, @after_commit_method)
+      end
 
-      define_destroy_touch_method
-      add_active_record_callback(:after_destroy, @destroy_touch_method)
+      define_before_destroy
+      add_active_record_callback(:after_destroy, @before_destroy_method)
 
       add_to_network
     end
 
-    def define_update_touch_method
+    def define_before_commit_method
+      association = @association
+      options = @options
+
+      @klass.send :define_method, @before_commit_method do |*args|
+        changed_attributes = self.previous_changes.keys.map(&:to_sym)
+        watched_changes = (options[:watch] & changed_attributes)
+
+        # watched values changed and conditional procs evaluate to true
+        if watched_changes.any? && options[:if].call(self) && !options[:unless].call(self)
+          Rails.logger.debug "Touch Before Commit: #{self.class}(#{self.id}) => #{association} due to changes in #{watched_changes}"
+          TouchJob.perform_now(self, association.to_s, touch_updates: options[:touch_updates])
+        end
+      end
+    end
+
+    def define_after_commit_method
       association = @association
       options = @options
 
-      @klass.send :define_method, @update_touch_method do |*args|
+      @klass.send :define_method, @after_commit_method do |*args|
         changed_attributes = self.previous_changes.keys.map(&:to_sym)
         watched_changes = (options[:watch] & changed_attributes)
 
         # watched values changed and conditional procs evaluate to true
         if watched_changes.any? && options[:if].call(self) && !options[:unless].call(self)
-          Rails.logger.debug "Touch: #{self.class}(#{self.id}) => #{association} due to changes in #{watched_changes}"
+          Rails.logger.debug "Touch After Commit: #{self.class}(#{self.id}) => #{association} due to changes in #{watched_changes}"
 
           if options[:async]
             TouchJob
                 .set(queue: ActiveTouch.configuration.queue)
-                .perform_later(self, association.to_s, options[:after_touch].to_s)
+                .perform_later(self, association.to_s, {
+                    after_touch: options[:after_touch].to_s,
+                    is_destroy: false,
+                    is_touched: options[:touch_in_transaction],
+                    touch_updates: options[:touch_updates]
+                })
 
           else
-            TouchJob.perform_now(self, association.to_s, options[:after_touch].to_s)
+            TouchJob.perform_now(self, association.to_s, {
+                after_touch: options[:after_touch].to_s,
+                is_destroy: false,
+                is_touched: options[:touch_in_transaction],
+                touch_updates: options[:touch_updates]
+            })
           end
 
         end
       end
     end
 
-    def define_destroy_touch_method
+    def define_before_destroy
       association = @association
       options = @options
 
-      @klass.send :define_method, @destroy_touch_method do |*args|
-        Rails.logger.debug "Touch: #{self.class}(#{self.id}) => #{association} due to destroy"
-        TouchJob.perform_now(self, association.to_s, options[:after_touch].to_s, true)
+      @klass.send :define_method, @before_destroy_method do |*args|
+        Rails.logger.debug "Touch Before Destroy: #{self.class}(#{self.id}) => #{association} due to destroy"
+        TouchJob.perform_now(self, association.to_s, {
+            after_touch: options[:after_touch].to_s,
+            is_destroy: true,
+            touch_updates: options[:touch_updates]
+        })
       end
     end
 
@@ -71,11 +109,13 @@ module ActiveTouch
 
     def default_options
       {
+          touch_in_transaction: ActiveTouch.configuration.touch_in_transaction,
           async: ActiveTouch.configuration.async,
           watch: @klass.column_names.map(&:to_sym) - ActiveTouch.configuration.ignored_attributes,
           after_touch: nil,
           if: Proc.new { true },
-          unless: Proc.new { false }
+          unless: Proc.new { false },
+          touch_updates: ActiveTouch.configuration.touch_updates
       }
     end
 

data/lib/active_touch/touch.rb

@@ -1,28 +1,26 @@
 module ActiveTouch
   class Touch
 
-    attr_accessor :record, :association, :after_touch, :is_destroy
+    attr_accessor :record, :association, :after_touch, :is_destroy, :is_touched, :touch_updates
 
-    def initialize(record, association, after_touch, is_destroy = false)
+    def initialize(record, association, options = {})
       @record = record
       @association = association
-      @after_touch = after_touch
-      @is_destroy = is_destroy
+      @after_touch = options[:after_touch]
+      @is_destroy = options[:is_destroy]
+      @is_touched = options[:is_touched]
+      @touch_updates = (options[:touch_updates] || {})
     end
 
     def run
-      if associated.is_a? ActiveRecord::Base
-        unless ActiveTouch.configuration.timestamp_attribute.nil?
-          associated.update_columns(ActiveTouch.configuration.timestamp_attribute => record.updated_at)
-        end
+      touch_updates[ActiveTouch.configuration.timestamp_attribute] = record.updated_at
 
+      if associated.is_a? ActiveRecord::Base
+        associated.update_columns(touch_updates) if !ActiveTouch.configuration.timestamp_attribute.nil? && !is_touched
         associated.send(after_touch) unless after_touch.blank?
 
       elsif !associated.nil? && !associated.empty?
-        unless ActiveTouch.configuration.timestamp_attribute.nil?
-          associated.update_all(ActiveTouch.configuration.timestamp_attribute => record.updated_at)
-        end
-
+        associated.update_all(touch_updates) if !ActiveTouch.configuration.timestamp_attribute.nil? && !is_touched
         associated.each { |associate| associate.send(after_touch) } unless after_touch.blank?
       end
     end

data/lib/active_touch/touch_job.rb

@@ -1,8 +1,8 @@
 module ActiveTouch
   class TouchJob < ActiveJob::Base
 
-    def perform(record, association, after_touch, is_destroy = false)
-      Touch.new(record, association, after_touch, is_destroy).run
+    def perform(record, association, options = {})
+      Touch.new(record, association, options).run
     end
 
   end

data/lib/active_touch/version.rb

@@ -1,3 +1,3 @@
 module ActiveTouch
-  VERSION = '4.0.3'
+  VERSION = '4.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_touch
 version: !ruby/object:Gem::Version
-  version: 4.0.3
+  version: 4.1.0
 platform: ruby
 authors:
 - Kevin Pheasey
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-22 00:00:00.000000000 Z
+date: 2016-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -106,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: A more robust touch for ActiveRecord associations.