activerecord-cached_at 2.0.4 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf203856f29f1e18a87be4892db7fd3396208cbb
-  data.tar.gz: 960fc526cd4f5ed35aa6ba3028c8ca367d850ac1
+  metadata.gz: 7b3d64e5e2adb795b942f664462d24ed6ed4d7f2
+  data.tar.gz: 95bef73c44b5dc5a34d066326a0f143e71a6aed1
 SHA512:
-  metadata.gz: 8fe18f63b67fd3b7a3e0159f1a1985670c141511e60dcc5b1ee1d05e9fa8ef81a8d8e4d7f0fda6c16bee4a5fef8e84f22d0f1908a1f22c821d65be29da1aa3fe
-  data.tar.gz: f6b97535599ac6c02afe3fe63713590065bea24c56e5d6ec7b385e4ad968025c63b75dab3e8ae046a933f972d013ef7dd43911fe9c1868e7b585cbf452e28c11
+  metadata.gz: a3cb5c3704956ee085247bbbf12f504feba96eed6604cdf73488055acbf71479d9e91e838433320a22ad14c1cd3b60fade816d7170809036814c7cf4bb60321b
+  data.tar.gz: ae7d263524467b04d8d90687f392a2e7db39714282e73f9bd8b89ab69f0b245c9f72c02289d848ba6e523ab8d0ea5d8628b72b09419ea2a4019bd302ba1b121f

data/lib/cached_at/association_extension.rb

@@ -0,0 +1,15 @@
+module CachedAt
+  module AssociationExtension
+
+    def self.build(model, reflection)
+      return unless reflection.options[:cached_at]
+    end
+    
+    def self.valid_options
+      [:cached_at]
+    end
+      
+  end
+end
+
+ActiveRecord::Associations::Builder::Association.extensions << CachedAt::AssociationExtension

data/lib/cached_at/associations/collection_association.rb

@@ -29,53 +29,38 @@ module CachedAt
         end
       end
     end
-    
-    def touch_records_added_cached_at(records, timestamp)
-      return if owner.new_record? || records.empty?
-      
-      if reflection.options[:cached_at]
-        if reflection.inverse_of.nil?
-          puts "WARNING: cannot updated cached at for relationship: #{klass.name}.#{name}, inverse_of not set"
-          return
-        end
-        
-        cache_column = "#{reflection.inverse_of.name}_cached_at"
-        if loaded?
-          target.each { |r| r.raw_write_attribute(cache_column, timestamp) }
-        end
-        
-        ids = records.inject([]) { |a, o| a += [o.send(klass.primary_key), o.send("#{klass.primary_key}_was")] }.compact.uniq
-        query = klass.where(klass.primary_key => ids)
-        query.update_all({ cache_column => timestamp })
-        traverse_relationships(klass, reflection.options[:cached_at], query, cache_column, timestamp)
-      end
-    end
-    
-    def touch_records_removed_cached_at(records, timestamp)
-      return if owner.new_record? || records.empty?
-      
+
+    def touch_records_cached_at(records, timestamp)
       return unless options[:cached_at]
 
       if reflection.inverse_of.nil?
-        puts "WARNING: cannot updated cached at for relationship: #{klass.name}.#{name}, inverse_of not set"
+        puts "WARNING: cannot updated cached at for relationship: #{owner.class.name}.#{name}, inverse_of not set"
         return
       end
-        
+
       cache_column = "#{reflection.inverse_of.name}_cached_at"
-      ids = records.inject([]) { |a, o| a += [o.send(klass.primary_key), o.send("#{klass.primary_key}_was")] }.compact.uniq
-      query = klass.where(klass.primary_key => ids)
-      traverse_relationships(klass, reflection.options[:cached_at], query, cache_column, timestamp)
+
+      records.each { |r| r.raw_write_attribute(cache_column, timestamp) unless r.destroyed? }
+
+      query = klass.where({ klass.primary_key => records.map(&:id) })
+      query.update_all({ cache_column => timestamp })
+      traverse_relationships(klass, options[:cached_at], query, cache_column, timestamp)
     end
-    
-    def concat_records(records, should_raise = false)
+
+    def add_to_target(record, skip_callbacks = false, &block)
       value = super
-      touch_records_added_cached_at(records, Time.now)
+      touch_records_cached_at([record], Time.now) if !(instance_variable_defined?(:@caching) && @caching)
       value
     end
-
-    def remove_records(existing_records, records, method)
-      touch_records_removed_cached_at(existing_records, Time.now)
-      super
+    
+    def replace_records(new_target, original_target)
+      @caching = true
+      changed_records = (target - new_target) | (new_target - target)
+      value = super
+      touch_records_cached_at(changed_records, Time.now) unless owner.new_record?
+      value
+    ensure
+      @caching = false
     end
 
     def delete_all(dependent = nil)

data/lib/cached_at/associations/has_many_through_association.rb

@@ -5,97 +5,56 @@ module CachedAt
       using_reflection = reflection.parent_reflection || reflection
       return unless using_reflection.options[:cached_at]
 
+      return if method == :create && !using_reflection.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
+
       if using_reflection.inverse_of.nil?
         puts "WARNING: cannot updated cached at for relationship: #{owner.class.name}.#{using_reflection.name}, inverse_of not set"
         return
       end
       
       cache_column = "#{using_reflection.inverse_of.name}_cached_at"
-      ids = [owner.send(using_reflection.association_primary_key), owner.send("#{using_reflection.association_primary_key}_was")].compact.uniq
-
-      
-      arel_table = klass._reflections[using_reflection.inverse_of.options[:through].to_s].klass.arel_table
-      query = klass.joins(using_reflection.inverse_of.options[:through])
-      query = if using_reflection.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
-        query.where(arel_table[using_reflection.foreign_key].in(ids))
-      else
-        query.where(arel_table[using_reflection.inverse_of.foreign_key].in(ids))
-      end
 
+      query = nil
       if loaded?
         target.each { |r| r.raw_write_attribute(cache_column, timestamp) }
+        query = klass.where(klass.primary_key => target.map(&:id))
+      else
+        ids = [owner.send(using_reflection.association_primary_key), owner.send("#{using_reflection.association_primary_key}_was")].compact.uniq
+        arel_table = klass._reflections[using_reflection.inverse_of.options[:through].to_s].klass.arel_table
+        query = klass.joins(using_reflection.inverse_of.options[:through])
+        query = if using_reflection.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
+          query.where(arel_table[using_reflection.foreign_key].in(ids))
+        else
+          query.where(arel_table[using_reflection.inverse_of.foreign_key].in(ids))
+        end
       end
-      
+
       query.update_all({ cache_column => timestamp })
       traverse_relationships(klass, options[:cached_at], query, cache_column, timestamp)
     end
     
-    def touch_records_added_cached_at(records, timestamp)
-      return if owner.new_record? || records.empty?
-
+    def touch_records_cached_at(records, timestamp)
       using_reflection = reflection.parent_reflection || reflection
-
+      
       if using_reflection.options[:cached_at]
-
         if using_reflection.inverse_of.nil?
           puts "WARNING: cannot updated cached at for relationship: #{klass.name}.#{name}, inverse_of not set"
           return
         end
 
         cache_column = "#{using_reflection.inverse_of.name}_cached_at"
-        ids = records.inject([]) { |a, o| a += [o.send(klass.primary_key), o.send("#{klass.primary_key}_was")] }.compact.uniq
-        query = klass.where(klass.primary_key => ids)
         records.each { |r| r.raw_write_attribute(cache_column, timestamp) }
+        query = klass.where(klass.primary_key => records.map(&:id))
         query.update_all({ cache_column => timestamp })
         traverse_relationships(klass, using_reflection.options[:cached_at], query, cache_column, timestamp)
       end
-
+      
       if using_reflection.inverse_of&.options.try(:[], :cached_at) || using_reflection.inverse_of&.parent_reflection&.options.try(:[], :cached_at)
         cache_column = "#{using_reflection.name}_cached_at"
         owner.update_column(cache_column, timestamp) unless owner.new_record?
       end
     end
-    
-    def touch_records_removed_cached_at(records, timestamp)
-      return if records.empty?
-      
-      using_reflection = reflection.parent_reflection || reflection
-      inverse_reflection = using_reflection.inverse_of&.parent_reflection || using_reflection.inverse_of
-      
-      if using_reflection.options[:cached_at]
-        if inverse_reflection.nil?
-          puts "WARNING: cannot updated cached at for relationship: #{klass.name}.#{name}, inverse_of not set"
-          return
-        end
-        
-        cache_column = "#{inverse_reflection.name}_cached_at"
-        ids = records.inject([]) { |a, o| a += [o.send(klass.primary_key), o.send("#{klass.primary_key}_was")] }.compact.uniq
-        query = klass.where(klass.primary_key => ids)
-        records.each { |r| r.raw_write_attribute(cache_column, timestamp) }
-        query.update_all({ cache_column => timestamp })
-        traverse_relationships(klass, reflection.options[:cached_at], query, cache_column, timestamp)
-      end
-      
-      if !inverse_reflection.nil? && inverse_reflection.options[:cached_at]
-        cache_column = "#{using_reflection.name}_cached_at"
-        owner.raw_write_attribute(cache_column, timestamp)
-        ids = records.inject([]) { |a, o| a += [o.send(klass.primary_key), o.send("#{klass.primary_key}_was")] }.compact.uniq
-        
-        arel_table = if inverse_reflection.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
-          inverse_reflection.klass.const_get(:"HABTM_#{using_reflection.name.to_s.camelize}").arel_table
-        else
-          using_reflection.inverse_of.klass._reflections[using_reflection.inverse_of.options[:through].to_s].klass.arel_table
-        end
-
-        query = using_reflection.inverse_of.klass.where(using_reflection.inverse_of.klass.primary_key => owner.id)
-        query.update_all({ cache_column => timestamp })
-        puts "#{owner.class.name}.#{cache_column} = #{timestamp}"
-        owner.raw_write_attribute(cache_column, timestamp)
-        traverse_relationships(klass, reflection.options[:cached_at], query, cache_column, timestamp)
-      end
-    end
 
-    
   end
 end
 

data/lib/cached_at/base.rb

@@ -1,3 +1,4 @@
+require File.expand_path(File.join(__FILE__, '../association_extension'))
 require File.expand_path(File.join(__FILE__, '../associations/association'))
 require File.expand_path(File.join(__FILE__, '../associations/has_one_association'))
 require File.expand_path(File.join(__FILE__, '../associations/belongs_to_association'))
@@ -8,23 +9,11 @@ module CachedAt
   module Base
     extend ActiveSupport::Concern
 
-    module AssociationExtension
-      
-      def self.build(model, reflection)
-        return unless reflection.options[:cached_at]
-      end
-  
-      def self.valid_options
-        [:cached_at]
-      end
-      
-    end
-
     included do
       before_save       :update_belongs_to_cached_at_keys
       before_destroy    { update_relations_cached_at(method: :destroy) }
-      after_touch       { update_relations_cached_at_from_cached_at(method: :touch) }
 
+      after_touch       { update_relations_cached_at_from_cached_at(method: :touch) }
       after_save     :update_relations_cached_at_from_cached_at
     end
 
@@ -38,23 +27,45 @@ module CachedAt
     end
     
     def update_relations_cached_at(timestamp: nil, method: nil)
-      return if (method == nil && changes.empty?) && method != :destroy && method != :touch
+      method = instance_variable_defined?(:@new_record_before_save) && @new_record_before_save ? :create : :update if method.nil?
+      
+      return if method == :create && changes.empty?
+      return if method == :update && changes.empty?
+      
       timestamp ||= current_time_from_proper_timezone
 
       self._reflections.each do |name, reflection|
-        begin
-          association(name.to_sym).touch_cached_at(timestamp, method)
-        rescue ActiveRecord::HasManyThroughAssociationNotFoundError, 
-               ActiveRecord::HasOneAssociationPolymorphicThroughError,
-               ActiveRecord::HasManyThroughAssociationPolymorphicThroughError,
-               ActiveRecord::HasManyThroughSourceAssociationNotFoundError,
-               ActiveRecord::HasManyThroughAssociationPointlessSourceTypeError,
-               ActiveRecord::HasManyThroughAssociationPolymorphicSourceError,
-               ActiveRecord::HasOneThroughCantAssociateThroughCollection
-               # these error get raised if the reflection is invalid... so we'll
-               # skip them. Should warn the user, but this casuse the Rails test
-               # to fail....
+
+        through_connections = if reflection.polymorphic?
+          []
+        else
+          reflection.klass._reflections.values.select do |r|
+            r.options[:cached_at] && r.options[:through] == reflection.inverse_of&.name
+          end
+        end
+
+        
+        next unless reflection.options[:cached_at] || reflection&.parent_reflection&.class == ActiveRecord::Reflection::HasAndBelongsToManyReflection || !through_connections.empty?
+        next if instance_variable_defined?(:@relationships_cached_at_touched) && (!@relationships_cached_at_touched.nil? && @relationships_cached_at_touched[reflection.name])
+        next if reflection.is_a?(ActiveRecord::Reflection::HasManyReflection) && method == :create
+
+        assoc = association(name.to_sym)
+        assoc.touch_cached_at(timestamp, method)
+        
+        through_connections.each do |r|
+          #TODO: move into association
+          cache_column = "#{r.inverse_of.name}_cached_at"
+          
+          r.klass.where(r.association_primary_key => self.send(r.foreign_key)).update_all({
+            cache_column => timestamp
+          })
+          
+          source_assoc = association(r.source_reflection_name.to_sym)
+          if source_assoc.loaded?
+            source_assoc.target.raw_write_attribute(cache_column, timestamp)
+          end
         end
+        
       end
     end
 
@@ -69,13 +80,12 @@ module CachedAt
           elsif (self.changes[reflection.foreign_key] || self.new_record? || (self.association(reflection.name).loaded? && self.send(reflection.name) && self.send(reflection.name).id.nil?)) && self.send(reflection.name).try(:cached_at)
             self.assign_attributes({ cache_column => self.send(reflection.name).cached_at })
           end
-
         end
+        
       end
     end
     
   end
 end
 
-ActiveRecord::Associations::Builder::Association.extensions << CachedAt::Base::AssociationExtension
 ActiveRecord::Base.include(CachedAt::Base)

data/lib/cached_at/version.rb

@@ -1,3 +1,3 @@
 module CachedAt
-  VERSION = '2.0.4'
+  VERSION = '2.0.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-cached_at
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.0.5
 platform: ruby
 authors:
 - Jon Bracy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-05 00:00:00.000000000 Z
+date: 2017-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -135,6 +135,7 @@ files:
 - ext/active_record/connection_adapters/abstract/schema_definitions.rb
 - ext/active_record/connection_adapters/abstract/schema_statements.rb
 - lib/cached_at.rb
+- lib/cached_at/association_extension.rb
 - lib/cached_at/associations/association.rb
 - lib/cached_at/associations/belongs_to_association.rb
 - lib/cached_at/associations/collection_association.rb