activerecord-cached_at 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 172ead451c54fddc715cc2caa791a8eb64ee2854
-  data.tar.gz: aba2523bd6cd9e8934438397c908696b3ed127af
+  metadata.gz: d2078ad2e295f56f2163f9f813cc3bd87796c0bf
+  data.tar.gz: 90fb34c29372d3cb83ed043777ac3cb137c79961
 SHA512:
-  metadata.gz: 0af8779024a2f87a249614f37498173e80311c5132e02db7e56c100f3d4fca326c560f451f3c428b7e3f0074e4d94184dbc95adf7eebf00edf1c293108298766
-  data.tar.gz: 2e452b8fc450c01ffe41fafbcd2f81554fa983b89a8ebdb3d7a5a9ea2fcb4e1278634bd04e404ea2cc1d8a04dfd5478d3694f20f8eda0ea0709869df26f59172
+  metadata.gz: 6507b89f69f5172ee7d1e8c0f30b64e72764ad6b4a3f853765eeb139df0ae55612f8671acb11fed693593fd7b39d1a4bfb17c4b51c4da67640bd7e0f61ba6969
+  data.tar.gz: 35b31f8fcafc9a939328da0b163fdf964ceec28d1f627e80c2d0581de642515d19bb11f1300e4e84e59d8fbd51253faf8bda8cd44795c57ca8e96128ff085af8

data/README.md

@@ -1,2 +1,28 @@
-# activerecord-cached_at
-Allows ActiveRecord and Rails to use a `cached_at` column for the `cache_key` if available
+# ActiveRecord - CachedAt
+
+This gem causes ActiveRecord to update a `cached_at` column if present, like the
+`updated_at` column.
+
+When calculating a `cache_key` for a model it will also consider the `cached_at`
+column to determin the key of a model.
+
+Any `ActiveRecord::Migration` that calls `timestamps` will include a `cached_at`
+column.
+
+TODO: Document about relationship caches
+
+## Installation
+
+Add the following line to your `Gemfile`:
+
+    gem 'activerecord-cached_at', require: 'cached_at'
+
+If you just need the `ActiveRecord::Base#cache_key` and associated helpers and
+aren't updating the models you can just require the helpers:
+
+    gem 'activerecord-cached_at', require: 'cached_at/helpers'
+
+
+## TODO:
+
+ Add a `cache_key` method to the Model class that gets `MAX(cached_at)`

data/ext/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  module ConnectionAdapters #:nodoc:
+
+    class TableDefinition
+      def timestamps(*args)
+        options = args.extract_options!
+
+        options[:null] = false if options[:null].nil?
+
+        column(:created_at, :datetime, options)
+        column(:updated_at, :datetime, options)
+        column(:cached_at, :datetime, options)
+      end
+    end
+
+  end
+end

data/ext/active_record/connection_adapters/abstract/schema_statements.rb

@@ -0,0 +1,21 @@
+module ActiveRecord
+  module ConnectionAdapters #:nodoc:
+
+    module SchemaStatements
+      def add_timestamps(table_name, options = {})
+        options[:null] = false if options[:null].nil?
+
+        add_column table_name, :created_at, :datetime, options
+        add_column table_name, :updated_at, :datetime, options
+        add_column table_name, :cached_at, :datetime, options
+      end
+
+      def remove_timestamps(table_name, options = {})
+        remove_column table_name, :updated_at
+        remove_column table_name, :created_at
+        remove_column table_name, :cached_at
+      end
+    end
+
+  end
+end

data/lib/cached_at.rb

@@ -0,0 +1,7 @@
+require 'active_record'
+
+require File.expand_path(File.join(__FILE__, '../cached_at/base'))
+require File.expand_path(File.join(__FILE__, '../cached_at/helpers'))
+require File.expand_path(File.join(__FILE__, '../cached_at/timestamp'))
+require File.expand_path(File.join(__FILE__, '../cached_at/connection_adapters/abstract/schema_definitions'))
+require File.expand_path(File.join(__FILE__, '../cached_at/connection_adapters/abstract/schema_statements'))

data/lib/cached_at/associations/association.rb

@@ -0,0 +1,41 @@
+module CachedAt
+  module Association
+    
+    def traverse_relationships(klass, relationships, query, cache_column, timestamp)
+      if relationships.is_a?(Symbol)
+        reflection = klass.reflect_on_association(relationships)
+        case reflection
+        when ActiveRecord::Reflection::BelongsToReflection
+          cache_column = "#{reflection.inverse_of.name}_#{cache_column}"
+          reflection.klass.joins(reflection.inverse_of.name).merge(query).update_all({
+            cache_column => timestamp
+          })
+        when ActiveRecord::Reflection::HasManyReflection
+          cache_column = "#{reflection.inverse_of.name}_#{cache_column}"
+          reflection.klass.joins(reflection.inverse_of.name).merge(query).update_all({
+            cache_column => timestamp
+          })
+        when ActiveRecord::Reflection::HasAndBelongsToManyReflection
+          query = reflection.klass.joins(reflection.inverse_of.name).merge(query)
+          puts '!!!!!!!!!!!!!!!!!'
+        when ActiveRecord::Reflection::ThroughReflection
+          cache_column = "#{reflection.inverse_of.name}_#{cache_column}"
+          reflection.klass.joins(reflection.inverse_of.name).merge(query).update_all({
+            cache_column => timestamp
+          })
+        end
+      elsif relationships.is_a?(Hash)
+        relationships.each do |key, value|
+          traverse_relationships(klass, key, query, cache_column, timestamp)
+        end
+      elsif relationships.is_a?(Array)
+        relationships.each do |value|
+          traverse_relationships(klass, value, query, cache_column, timestamp)
+        end
+      end
+    end
+    
+  end
+end
+
+ActiveRecord::Associations::Association.include(CachedAt::Association)

data/lib/cached_at/associations/belongs_to_association.rb

@@ -0,0 +1,67 @@
+module CachedAt
+  module BelongsToAssociation
+  
+    def touch_cached_at(timestamp, method)
+      return unless options[:cached_at]
+
+      if !options[:inverse_of]
+        puts "WARNING: cannot updated cached at for relationship: #{owner.class.name}.#{name}, inverse_of not set"
+        return
+      end
+      
+      types = {}
+
+      cache_column = "#{options[:inverse_of]}_cached_at"
+      if options[:polymorphic]
+        oldtype = owner.send("#{reflection.foreign_type}_was")
+        oldid = owner.send("#{reflection.foreign_key}_was")
+        newtype = owner.send(reflection.foreign_type)
+        newid = owner.send(reflection.foreign_key)
+        if !oldtype.nil? && oldtype == newtype
+          model_klass = oldtype.constantize
+          query = model_klass.where({ (options[:primary_key] || 'id') => [oldid, newid] })
+          query.update_all({ cache_column => timestamp })
+          traverse_relationships(model_klass, options[:cached_at], query, cache_column, timestamp)
+        else
+          if oldtype
+            model_klass = oldtype.constantize
+            query = model_klass.where({ (options[:primary_key] || 'id') => oldid })
+            query.update_all({ cache_column => timestamp })
+            traverse_relationships(model_klass, options[:cached_at], query, cache_column, timestamp)
+          end
+          
+          if newtype
+            model_klass = newtype.constantize
+            query = model_klass.where({ (options[:primary_key] || 'id') => newid })
+            query.update_all({ cache_column => timestamp })
+            traverse_relationships(model_klass, options[:cached_at], query, cache_column, timestamp)
+          end
+        end
+      else
+        ids = [owner.send(reflection.foreign_key), owner.send("#{reflection.foreign_key}_was")].compact.uniq
+        query = klass.where({ reflection.association_primary_key => ids })
+        query.update_all({ cache_column => timestamp })
+        traverse_relationships(klass, options[:cached_at], query, cache_column, timestamp)
+      end
+      
+      if loaded? && target
+        target.raw_write_attribute(cache_column, timestamp)
+      end
+    end
+    
+    def replace(record)
+      if options[:cached_at] && options[:inverse_of]
+        timestamp = Time.now
+        cache_column = "#{options[:inverse_of]}_cached_at"
+        if loaded? && target
+          target.raw_write_attribute(cache_column, timestamp)
+        end
+      end
+      
+      super
+    end
+    
+  end
+end
+
+ActiveRecord::Associations::BelongsToAssociation.prepend(CachedAt::BelongsToAssociation)

data/lib/cached_at/associations/collection_association.rb

@@ -0,0 +1,89 @@
+module CachedAt
+  module CollectionAssociation
+  
+    def touch_cached_at(timestamp, method)
+      return unless options[:cached_at]
+
+      if reflection.inverse_of.nil?
+        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 = [owner.send(reflection.association_primary_key), owner.send("#{reflection.association_primary_key}_was")].compact.uniq
+      query = klass.where({ reflection.foreign_key => ids })
+    
+      if loaded?
+        target.each { |r| r.raw_write_attribute(cache_column, timestamp) }
+      end
+      
+      if method != :destroy
+        query.update_all({ cache_column => timestamp })
+        traverse_relationships(klass, options[:cached_at], query, cache_column, timestamp)
+      else
+        if options[:dependent].nil?
+          query.update_all({ cache_column => timestamp })
+          traverse_relationships(klass, options[:cached_at], query, cache_column, timestamp)
+        else
+          traverse_relationships(klass, options[:cached_at], query, cache_column, timestamp)
+        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?
+      
+      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"
+        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)
+    end
+    
+    def concat_records(records, should_raise = false)
+      value = super
+      touch_records_added_cached_at(records, Time.now)
+      value
+    end
+
+    def remove_records(existing_records, records, method)
+      touch_records_removed_cached_at(existing_records, Time.now)
+      super
+    end
+
+    def delete_all(dependent = nil)
+      touch_cached_at(Time.now, :destroy)
+      super
+    end
+    
+  end
+end
+
+ActiveRecord::Associations::CollectionAssociation.prepend(CachedAt::CollectionAssociation)

data/lib/cached_at/associations/has_many_through_association.rb

@@ -0,0 +1,103 @@
+module CachedAt
+  module HasManyThroughAssociation
+  
+    def touch_cached_at(timestamp, method)
+      using_reflection = reflection.parent_reflection || reflection
+      return unless using_reflection.options[:cached_at]
+
+      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
+
+      if loaded?
+        target.each { |r| r.raw_write_attribute(cache_column, timestamp) }
+      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 records.empty?
+
+      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)
+        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)
+        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 = if inverse_reflection.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
+          using_reflection.inverse_of.klass.joins(inverse_reflection.join_table)
+        else
+          using_reflection.inverse_of.klass.joins(using_reflection.inverse_of.options[:through])
+        end
+
+        query.where(arel_table[using_reflection.inverse_of.foreign_key].in(ids))
+        query.update_all({ cache_column => timestamp })
+        traverse_relationships(klass, reflection.options[:cached_at], query, cache_column, timestamp)
+      end
+    end
+
+    
+  end
+end
+
+ActiveRecord::Associations::HasManyThroughAssociation.prepend(CachedAt::HasManyThroughAssociation)

data/lib/cached_at/associations/has_one_association.rb

@@ -0,0 +1,52 @@
+module CachedAt
+  module HasOneAssociation
+  
+    def touch_cached_at(timestamp, method)
+      return unless options[:cached_at]
+      
+      if reflection.inverse_of.nil?
+        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 = [owner.send(reflection.association_primary_key), owner.send("#{reflection.association_primary_key}_was")].compact.uniq
+      query = klass.where({ reflection.foreign_key => ids })
+  
+      case options[:dependent]
+      when nil
+        query.update_all({ cache_column => timestamp })
+        traverse_relationships(klass, options[:cached_at], query, cache_column, timestamp)
+      when :destroy
+        # don't need to worry about :destroy, that will touch the other caches
+      when :delete, :nullify
+        traverse_relationships(klass, options[:cached_at], query, cache_column, timestamp)
+      end
+      
+      if loaded? && target
+        target.raw_write_attribute(cache_column, timestamp)
+      end
+    end
+    
+    def delete(method = options[:dependent])
+      if load_target
+        case method
+        when :delete
+          target.delete
+        when :destroy
+          target.destroy
+        when :nullify
+          updates = {reflection.foreign_key => nil}
+          if reflection.options[:cached_at]
+            cache_column = "#{reflection.inverse_of.name}_cached_at"
+            updates[cache_column] = Time.now
+          end
+          target.update_columns(updates) if target.persisted?
+        end
+      end
+    end
+    
+  end
+end
+
+ActiveRecord::Associations::HasOneAssociation.prepend(CachedAt::HasOneAssociation)

data/lib/cached_at/base.rb

@@ -0,0 +1,69 @@
+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'))
+require File.expand_path(File.join(__FILE__, '../associations/collection_association'))
+require File.expand_path(File.join(__FILE__, '../associations/has_many_through_association'))
+
+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_save     :update_relations_cached_at_from_cached_at
+    end
+
+    private
+    
+    def update_relations_cached_at_from_cached_at(method: nil)
+      update_relations_cached_at({
+        timestamp: (self.class.column_names.include?('cached_at') ? cached_at : nil),
+        method: method
+      })
+    end
+    
+    def update_relations_cached_at(timestamp: nil, method: nil)
+      return if (method == nil && changes.empty?) && method != :destroy && method != :touch
+      timestamp ||= current_time_from_proper_timezone
+
+      self._reflections.each do |name, reflection|
+        association(name.to_sym).touch_cached_at(timestamp, method)
+      end
+    end
+
+    def update_belongs_to_cached_at_keys
+      self.class.reflect_on_all_associations.each do |reflection|
+        next unless reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection)
+        cache_column = "#{reflection.name}_cached_at"
+
+        if self.attribute_names.include?(cache_column)
+          if self.changes.has_key?(reflection.foreign_key) && self.changes[reflection.foreign_key][1].nil?
+            self.assign_attributes({ cache_column => current_time_from_proper_timezone })
+          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/connection_adapters/abstract/schema_definitions.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  module ConnectionAdapters #:nodoc:
+    
+    class TableDefinition
+      def timestamps(*args)
+        options = args.extract_options!
+        
+        options[:null] = false if options[:null].nil?
+        
+        column(:created_at, :datetime, options)
+        column(:updated_at, :datetime, options)
+        column(:cached_at, :datetime, options)
+      end
+    end
+    
+  end
+end

data/{ext/active_record/timestamp.rb → lib/cached_at/connection_adapters/abstract/schema_statements.rb}

@@ -1,36 +1,10 @@
-module ActiveRecord
-  module Timestamp
-  private
-    def timestamp_attributes_for_update
-      [:updated_at, :updated_on, :cached_at]
-    end
-
-    def timestamp_attributes_for_create
-      [:created_at, :created_on, :cached_at]
-    end
-  end
-end
-
-
 module ActiveRecord
   module ConnectionAdapters #:nodoc:
-    
-    class TableDefinition
-      def timestamps(*args)
-        options = args.extract_options!
 
-        options[:null] = false if options[:null].nil?
-
-        column(:created_at, :datetime, options)
-        column(:updated_at, :datetime, options)
-        column(:cached_at, :datetime, options)
-      end
-    end
-    
     module SchemaStatements
       def add_timestamps(table_name, options = {})
         options[:null] = false if options[:null].nil?
-
+        
         add_column table_name, :created_at, :datetime, options
         add_column table_name, :updated_at, :datetime, options
         add_column table_name, :cached_at, :datetime, options
@@ -42,6 +16,6 @@ module ActiveRecord
         remove_column table_name, :cached_at
       end
     end
-    
+
   end
 end

data/lib/cached_at/helpers.rb

@@ -0,0 +1,87 @@
+module CachedAt
+  module Base
+    module Helpers
+      extend ActiveSupport::Concern
+    
+      class_methods do
+
+        def can_cache?(includes)
+          cache_columns = ['cached_at'] + cached_at_columns_for_includes(includes)
+
+          (cache_columns - column_names).empty?
+        end
+
+        def cached_at_columns_for_includes(includes, prefix=nil)
+          if includes.is_a?(Array)
+            includes.inject([]) { |s, k| s + cached_at_columns_for_includes(k, prefix) }
+          elsif includes.is_a?(Hash)
+            includes.map { |k, v|
+              value = ["#{prefix}#{k}_cached_at"]
+              if v != true
+                value << cached_at_columns_for_includes(v, "#{prefix}#{k}_")
+              end
+              value
+            }.flatten
+          else
+            ["#{prefix}#{includes}_cached_at"]
+          end
+        end
+
+      end
+
+      def cache_key(includes = nil)
+        if includes.nil? || includes.empty?
+          super
+        else
+          timestamp_keys = ['cached_at'] + self.class.cached_at_columns_for_includes(includes)
+          timestamp = max_updated_column_timestamp(timestamp_keys).utc.to_s(cache_timestamp_format)
+          digest ||= Digest::MD5.new()
+          digest << paramaterize_cache_includes(includes)
+          "#{model_name.cache_key}/#{id}+#{digest.hexdigest}@#{timestamp}"
+        end
+      end
+
+      # TODO
+      # def association_cache_key(association_name, includes = nil)
+      # end
+    
+      private
+
+      def paramaterize_cache_includes(includes, paramaterized_cache_key = nil)
+        paramaterized_cache_key ||= ""
+
+        if includes.is_a?(Hash)
+          includes.keys.sort.each_with_index do |key, i|
+            paramaterized_cache_key << ',' unless i == 0
+            paramaterized_cache_key << key.to_s
+            if includes[key].is_a?(Hash) || includes[key].is_a?(Array)
+              paramaterized_cache_key << "["
+              paramaterize_cache_includes(includes[key], paramaterized_cache_key)
+              paramaterized_cache_key << "]"
+            elsif includes[key] != true
+              paramaterized_cache_key << "["
+              paramaterized_cache_key << includes[key].to_s
+              paramaterized_cache_key << "]"
+            end
+          end
+        elsif includes.is_a?(Array)
+          includes.sort.each_with_index do |value, i|
+            paramaterized_cache_key << ',' unless i == 0
+            if value.is_a?(Hash) || value.is_a?(Array)
+              paramaterize_cache_includes(value, paramaterized_cache_key)
+            else
+              paramaterized_cache_key << value.to_s
+            end
+          end
+        else
+          paramaterized_cache_key << includes.to_s
+        end
+
+        paramaterized_cache_key
+      end
+
+    end
+  end
+end
+
+ActiveRecord::Base.include(CachedAt::Base::Helpers)

data/lib/cached_at/timestamp.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module Timestamp
+
+    private
+    
+    def timestamp_attributes_for_update
+      [:updated_at, :cached_at]
+    end
+
+    def timestamp_attributes_for_create
+      [:created_at, :udpated_at, :cached_at] + self.class.column_names.select{|c| c.end_with?('_cached_at') }.map(&:to_sym)
+    end
+    
+  end
+end

data/lib/cached_at/version.rb

@@ -0,0 +1,3 @@
+module CachedAt
+  VERSION = '2.0.0'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-cached_at
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Jon Bracy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-12 00:00:00.000000000 Z
+date: 2017-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: 5.0.0.beta1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: 5.0.0.beta1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Allows ActiveRecord and Rails to use a `cached_at` column for the `cache_key`
   if available
 email:
@@ -118,9 +132,20 @@ extra_rdoc_files:
 - README.md
 files:
 - README.md
-- ext/active_record/timestamp.rb
-- lib/active_record/cached_at.rb
-- lib/active_record/cached_at/version.rb
+- 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/associations/association.rb
+- lib/cached_at/associations/belongs_to_association.rb
+- lib/cached_at/associations/collection_association.rb
+- lib/cached_at/associations/has_many_through_association.rb
+- lib/cached_at/associations/has_one_association.rb
+- lib/cached_at/base.rb
+- lib/cached_at/connection_adapters/abstract/schema_definitions.rb
+- lib/cached_at/connection_adapters/abstract/schema_statements.rb
+- lib/cached_at/helpers.rb
+- lib/cached_at/timestamp.rb
+- lib/cached_at/version.rb
 homepage: https://github.com/malomalo/activerecord-cached_at
 licenses:
 - MIT
@@ -143,7 +168,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Allows ActiveRecord and Rails to use a `cached_at` column for the `cache_key`

data/lib/active_record/cached_at.rb

@@ -1,3 +0,0 @@
-require 'active_record'
-
-require File.expand_path(File.join(__FILE__, '../../../ext/active_record/timestamp'))

data/lib/active_record/cached_at/version.rb

@@ -1,5 +0,0 @@
-module ActiveRecord
-  module CachedAt
-    VERSION = '1.0.0'
-  end
-end