identity_cache 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b3399599b1784b0df560313cc902e20e7cd86fd
-  data.tar.gz: 4a45bfa103d6095837bf2226a1ccd505219001fb
+  metadata.gz: e9c2e392201ed1b9c143a6ebff82f7c7af602a89
+  data.tar.gz: 445f3ce67f61a386db9bd99939d169e03562052b
 SHA512:
-  metadata.gz: 50b692df952ca33119c152a4aaaa9bf0e0360c2a56005bd0711a707ea516031a12ceb7f8e9e9599b52f0ba5ce1568c33585b7598bdc9a6a1da018b7b42eec0a3
-  data.tar.gz: e9519a582f37d3e029a43046157139ba37c3a897fda507febe592e1219a2d84968c3c10b68780a4c4397eeec9102cfd3ed4f69f41756818e7532b17ce4aa4d1e
+  metadata.gz: d3012a594fb51bcd37c08e322545b4cf3d9e2fe8ce3d14253df79cb423fd673f143e7dea5b8c7b13499660c56db9e266d3bc0fe6e923a6f1c37a918ba5d63fa4
+  data.tar.gz: a790523fd6989dde3669602a4ddd045032c44808f7e1f6a06f3e01fbf93e9ac137377e77fd360266a11642fdf7c6d5ef21ec1cb157a1d4ea37e2bde88dc5612c

data/.travis.yml

@@ -2,7 +2,7 @@ language: ruby
 
 rvm:
   - 2.1
-  - 2.2
+  - 2.2.3
 
 gemfile:
   - Gemfile.rails40
@@ -23,6 +23,4 @@ before_script:
   - mysql -e 'create database identity_cache_test'
   - psql -c 'create database identity_cache_test;' -U postgres
 
-matrix:
-  allow_failures:
-    - gemfile: Gemfile.rails42
+cache: bundler

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # IdentityCache changelog
 
+#### 0.2.6 (unreleased)
+- Add support for includes option on cache_index and fetch_by_id
+- Use ActiveRecord instantiate
+- Add association pre-fetching support for fetch_by_id
+- Remove support for 3.2
+- Fix N+1 from fetching embedded ids on a cache miss
+- Raise when trying to cache a through association. Previously it wouldn't be invalidated properly.
+- Raise if a class method is called on a scope.  Previously the scope was ignored.
+- Raise if a class method is called on a subclass of one that included IdentityCache. This never worked properly.
+- Fix cache_belongs_to on polymorphic assocations.
+- Fetching a cache_belongs_to association no longer loads the belongs_to association
+
+#### 0.2.5
+
+- Fixed support for namespaced model classes
+- Added some deduplication for parent cache expiry
+- Fixed some deprecation warnings in rails 4.2
+
+#### 0.2.4
+
+- Refactoring, documentation and test changes
+
 #### 0.2.3
 
 - PostgreSQL support

data/Gemfile

@@ -1,2 +1,4 @@
 source 'https://rubygems.org'
 gemspec
+
+gem 'mysql2', '~> 0.3.13'

data/Gemfile.rails40

@@ -3,3 +3,4 @@ gemspec
 
 gem 'activerecord', '~> 4.0.4'
 gem 'activesupport', '~> 4.0.4'
+gem 'mysql2', '~> 0.3.13'

data/Gemfile.rails41

@@ -3,3 +3,4 @@ gemspec
 
 gem 'activerecord', '~> 4.1.0'
 gem 'activesupport', '~> 4.1.0'
+gem 'mysql2', '~> 0.3.13'

data/Gemfile.rails42

@@ -3,3 +3,4 @@ gemspec
 
 gem 'activerecord', '~> 4.2.0'
 gem 'activesupport', '~> 4.2.0'
+gem 'mysql2', '~> 0.3.13'

data/README.md

@@ -125,7 +125,9 @@ IdentityCache tries to figure out both sides of an association whenever it can s
 
 ``` ruby
 class Metafield < ActiveRecord::Base
+  include IdentityCache
   belongs_to :owner, :polymorphic => true
+  cache_belongs_to :owner
 end
 
 class Product < ActiveRecord::Base
@@ -183,6 +185,11 @@ _[:inverse_name]_ Specifies the name of parent object used by the association. T
 Example:
 `cache_has_one :configuration, :embed => true`
 
+#### cache_belongs_to
+
+Example:
+`cache_belongs_to :shop`
+
 #### cache_attribute
 
 Options:

data/identity_cache.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |gem|
   gem.version       = IdentityCache::VERSION
 
   gem.add_dependency('ar_transaction_changes', '~> 1.0')
-  gem.add_dependency('activerecord', '>= 3.2')
+  gem.add_dependency('activerecord', '>= 4.0.4')
   gem.add_development_dependency('memcached', '~> 1.8.0')
 
   gem.add_development_dependency('memcached_store', '~> 0.12.6')

data/lib/identity_cache.rb

@@ -27,6 +27,9 @@ module IdentityCache
       super "Inverse name for association could not be determined. Please use the :inverse_name option to specify the inverse association name for this cache."
     end
   end
+  class UnsupportedScopeError < StandardError; end
+  class UnsupportedAssociationError < StandardError; end
+  class DerivedModelError < StandardError; end
 
   class << self
     include IdentityCache::CacheHash
@@ -38,7 +41,7 @@ module IdentityCache
     self.cache_namespace = "IDC:#{CACHE_VERSION}:".freeze
 
     def included(base) #:nodoc:
-      raise AlreadyIncludedError if base.respond_to? :cache_indexes
+      raise AlreadyIncludedError if base.include?(IdentityCache::ConfigurationDSL)
 
       base.send(:include, ArTransactionChanges) unless base.include?(ArTransactionChanges)
       base.send(:include, IdentityCache::BelongsToCaching)
@@ -112,7 +115,7 @@ module IdentityCache
       return {} if keys.size == 0
 
       result = if should_use_cache?
-        fetch_in_batches(keys) do |missed_keys|
+        fetch_in_batches(keys.uniq) do |missed_keys|
           results = yield missed_keys
           results.map {|e| map_cached_nil_for e }
         end

data/lib/identity_cache/belongs_to_caching.rb

@@ -9,6 +9,7 @@ module IdentityCache
 
     module ClassMethods
       def cache_belongs_to(association, options = {})
+        ensure_base_model
         raise NotImplementedError if options[:embed]
 
         unless association_reflection = reflect_on_association(association)
@@ -20,25 +21,32 @@ module IdentityCache
 
         options[:embed]                   = false
         options[:cached_accessor_name]    = "fetch_#{association}"
-        options[:foreign_key]             = association_reflection.foreign_key
-        options[:association_class]       = association_reflection.klass
+        options[:records_variable_name]   = "cached_#{association}"
+        options[:association_reflection]  = association_reflection
         options[:prepopulate_method_name] = "prepopulate_fetched_#{association}"
 
         build_normalized_belongs_to_cache(association, options)
       end
 
+      private
+
       def build_normalized_belongs_to_cache(association, options)
+        foreign_key = options[:association_reflection].foreign_key
         self.class_eval(<<-CODE, __FILE__, __LINE__ + 1)
           def #{options[:cached_accessor_name]}
-            if IdentityCache.should_use_cache? && #{options[:foreign_key]}.present? && !association(:#{association}).loaded?
-              self.#{association} = #{options[:association_class]}.fetch_by_id(#{options[:foreign_key]})
+            if IdentityCache.should_use_cache? && #{foreign_key}.present? && !association(:#{association}).loaded?
+              if instance_variable_defined?(:@#{options[:records_variable_name]})
+                @#{options[:records_variable_name]}
+              else
+                @#{options[:records_variable_name]} = association(:#{association}).klass.fetch_by_id(#{foreign_key})
+              end
             else
               #{association}
             end
           end
 
           def #{options[:prepopulate_method_name]}(record)
-            self.#{association} = record
+            @#{options[:records_variable_name]} = record
           end
         CODE
       end

data/lib/identity_cache/cache_key_generation.rb

@@ -13,7 +13,7 @@ module IdentityCache
         klass.send(:all_cached_associations).sort.each do |name, options|
           case options[:embed]
           when true
-            schema_string << ",#{name}:(#{denormalized_schema_hash(options[:association_class])})"
+            schema_string << ",#{name}:(#{denormalized_schema_hash(options[:association_reflection].klass)})"
           when :ids
             schema_string << ",#{name}:ids"
           end
@@ -35,12 +35,13 @@ module IdentityCache
         "#{rails_cache_key_namespace}blob:#{base_class.name}:#{rails_cache_key_prefix}:"
       end
 
-      def rails_cache_index_key_for_fields_and_values(fields, values)
-        "#{rails_cache_key_namespace}index:#{base_class.name}:#{rails_cache_string_for_fields_and_values(fields, values)}"
-      end
-
-      def rails_cache_key_for_attribute_and_fields_and_values(attribute, fields, values)
-        "#{rails_cache_key_namespace}attribute:#{base_class.name}:#{attribute}:#{rails_cache_string_for_fields_and_values(fields, values)}"
+      def rails_cache_key_for_attribute_and_fields_and_values(attribute, fields, values, unique)
+        unique_indicator = unique ? '' : 's' 
+        "#{rails_cache_key_namespace}" \
+          "attr#{unique_indicator}" \
+          ":#{base_class.name}" \
+          ":#{attribute}" \
+          ":#{rails_cache_string_for_fields_and_values(fields, values)}"
       end
 
       def rails_cache_key_namespace
@@ -58,20 +59,12 @@ module IdentityCache
       self.class.rails_cache_key(id)
     end
 
-    def secondary_cache_index_key_for_current_values(fields) # :nodoc:
-      self.class.rails_cache_index_key_for_fields_and_values(fields, current_values_for_fields(fields))
-    end
-
-    def secondary_cache_index_key_for_previous_values(fields) # :nodoc:
-      self.class.rails_cache_index_key_for_fields_and_values(fields, old_values_for_fields(fields))
-    end
-
-    def attribute_cache_key_for_attribute_and_current_values(attribute, fields) # :nodoc:
-      self.class.rails_cache_key_for_attribute_and_fields_and_values(attribute, fields, current_values_for_fields(fields))
+    def attribute_cache_key_for_attribute_and_current_values(attribute, fields, unique) # :nodoc:
+      self.class.rails_cache_key_for_attribute_and_fields_and_values(attribute, fields, current_values_for_fields(fields), unique)
     end
 
-    def attribute_cache_key_for_attribute_and_previous_values(attribute, fields) # :nodoc:
-      self.class.rails_cache_key_for_attribute_and_fields_and_values(attribute, fields, old_values_for_fields(fields))
+    def attribute_cache_key_for_attribute_and_previous_values(attribute, fields, unique) # :nodoc:
+      self.class.rails_cache_key_for_attribute_and_fields_and_values(attribute, fields, old_values_for_fields(fields), unique)
     end
 
     def current_values_for_fields(fields) # :nodoc:

data/lib/identity_cache/configuration_dsl.rb

@@ -3,15 +3,15 @@ module IdentityCache
     extend ActiveSupport::Concern
 
     included do |base|
+      base.class_attribute :cached_model
       base.class_attribute :cache_indexes
-      base.class_attribute :cache_attributes
       base.class_attribute :cached_has_manys
       base.class_attribute :cached_has_ones
       base.class_attribute :primary_cache_index_enabled
 
+      base.cached_model = base
       base.cached_has_manys = {}
       base.cached_has_ones = {}
-      base.cache_attributes = []
       base.cache_indexes = []
       base.primary_cache_index_enabled = true
     end
@@ -42,26 +42,29 @@ module IdentityCache
       def cache_index(*fields)
         raise NotImplementedError, "Cache indexes need an enabled primary index" unless primary_cache_index_enabled
         options = fields.extract_options!
-        self.cache_indexes.push fields
+        unique = options[:unique] || false
+        cache_attribute_by_alias('primary_key', 'id', by: fields, unique: unique)
 
         field_list = fields.join("_and_")
         arg_list = (0...fields.size).collect { |i| "arg#{i}" }.join(',')
 
-        if options[:unique]
+        if unique
           self.instance_eval(ruby = <<-CODE, __FILE__, __LINE__ + 1)
-            def fetch_by_#{field_list}(#{arg_list})
-              identity_cache_single_value_dynamic_fetcher(#{fields.inspect}, [#{arg_list}])
+            def fetch_by_#{field_list}(#{arg_list}, options={})
+              id = fetch_#{primary_key}_by_#{field_list}(#{arg_list})
+              id && fetch_by_id(id, options)
             end
 
             # exception throwing variant
-            def fetch_by_#{field_list}!(#{arg_list})
-              fetch_by_#{field_list}(#{arg_list}) or raise ActiveRecord::RecordNotFound
+            def fetch_by_#{field_list}!(#{arg_list}, options={})
+              fetch_by_#{field_list}(#{arg_list}, options) or raise ActiveRecord::RecordNotFound
             end
           CODE
         else
           self.instance_eval(ruby = <<-CODE, __FILE__, __LINE__ + 1)
-            def fetch_by_#{field_list}(#{arg_list})
-              identity_cache_multiple_value_dynamic_fetcher(#{fields.inspect}, [#{arg_list}])
+            def fetch_by_#{field_list}(#{arg_list}, options={})
+              ids = fetch_#{primary_key}_by_#{field_list}(#{arg_list})
+              ids.empty? ? ids : fetch_multi(ids, options)
             end
           CODE
         end
@@ -78,9 +81,13 @@ module IdentityCache
       #
       # == Example:
       #   class Product
-      #    cached_has_many :options, :embed => false
-      #    cached_has_many :orders
-      #    cached_has_many :buyers, :inverse_name => 'line_item'
+      #     include IdentityCache
+      #     has_many :options
+      #     has_many :orders
+      #     has_many :buyers
+      #     cache_has_many :options, embed: :ids
+      #     cache_has_many :orders
+      #     cache_has_many :buyers, inverse_name: 'line_item'
       #   end
       #
       # == Parameters
@@ -94,13 +101,11 @@ module IdentityCache
       # * inverse_name: The name of the parent in the association if the name is
       #   not the lowercase pluralization of the parent object's class
       def cache_has_many(association, options = {})
+        ensure_base_model
         options = options.slice(:embed, :inverse_name)
         options[:embed] = :ids unless options.has_key?(:embed)
         deprecate_embed_option(options, false, :ids)
-        options[:inverse_name] ||= self.name.underscore.to_sym
-        unless self.reflect_on_association(association)
-          raise AssociationError, "Association named '#{association}' was not found on #{self.class}"
-        end
+        ensure_cacheable_association(association, options)
         self.cached_has_manys[association] = options
 
         case options[:embed]
@@ -119,8 +124,8 @@ module IdentityCache
       #
       # == Example:
       #   class Product
-      #    cached_has_one :store, :embed => true
-      #    cached_has_one :vendor
+      #     cache_has_one :store, embed: true
+      #     cache_has_one :vendor
       #   end
       #
       # == Parameters
@@ -135,12 +140,10 @@ module IdentityCache
       #   necessary if the name is not the lowercase pluralization of the
       #   parent object's class)
       def cache_has_one(association, options = {})
+        ensure_base_model
         options = options.slice(:embed, :inverse_name)
         options[:embed] = true unless options.has_key?(:embed)
-        options[:inverse_name] ||= self.name.underscore.to_sym
-        unless self.reflect_on_association(association)
-          raise AssociationError, "Association named '#{association}' was not found on #{self.class}"
-        end
+        ensure_cacheable_association(association, options)
         self.cached_has_ones[association] = options
 
         if options[:embed] == true
@@ -155,8 +158,9 @@ module IdentityCache
       #
       # == Example:
       #   class Product
-      #    cache_attribute :quantity, :by => :name
-      #    cache_attribute :quantity  :by => [:name, :vendor]
+      #     include IdentityCache
+      #     cache_attribute :quantity, by: :name
+      #     cache_attribute :quantity, by: [:name, :vendor]
       #   end
       #
       # == Parameters
@@ -165,52 +169,41 @@ module IdentityCache
       # == Options
       #
       # * by: Other attribute or attributes in the model to keep values indexed. Default is :id
+      # * unique: if the index would only have unique values. Default is true
       def cache_attribute(attribute, options = {})
-        options[:by] ||= :id
-        fields = Array(options[:by])
-
-        self.cache_attributes.push [attribute, fields]
-
-        field_list = fields.join("_and_")
-        arg_list = (0...fields.size).collect { |i| "arg#{i}" }.join(',')
-
-        self.instance_eval(<<-CODE, __FILE__, __LINE__ + 1)
-          def fetch_#{attribute}_by_#{field_list}(#{arg_list})
-            attribute_dynamic_fetcher(#{attribute.inspect}, #{fields.inspect}, [#{arg_list}])
-          end
-        CODE
+        cache_attribute_by_alias(attribute.inspect, attribute, options)
       end
 
       def disable_primary_cache_index
-        raise NotImplementedError, "Secondary indexes rely on the primary index to function. You must either remove the secondary indexes or don't disable the primary" if self.cache_indexes.size > 0
+        ensure_base_model
         self.primary_cache_index_enabled = false
       end
 
       private
 
-      def identity_cache_single_value_dynamic_fetcher(fields, values) # :nodoc:
-        cache_key = rails_cache_index_key_for_fields_and_values(fields, values)
-        id = IdentityCache.fetch(cache_key) { identity_cache_conditions(fields, values).limit(1).pluck(primary_key).first }
-        unless id.nil?
-          record = fetch_by_id(id)
-          IdentityCache.cache.delete(cache_key) unless record
-        end
+      def cache_attribute_by_alias(attribute, alias_name, options)
+        ensure_base_model
+        options[:by] ||= :id
+        alias_name = alias_name.to_sym
+        unique = options[:unique].nil? ? true : !!options[:unique]
+        fields = Array(options[:by])
 
-        record
-      end
+        self.cache_indexes.push [alias_name, fields, unique]
 
-      def identity_cache_multiple_value_dynamic_fetcher(fields, values) # :nodoc
-        cache_key = rails_cache_index_key_for_fields_and_values(fields, values)
-        ids = IdentityCache.fetch(cache_key) { identity_cache_conditions(fields, values).pluck(primary_key) }
+        field_list = fields.join("_and_")
+        arg_list = (0...fields.size).collect { |i| "arg#{i}" }.join(',')
 
-        ids.empty? ? [] : fetch_multi(ids)
+        self.instance_eval(<<-CODE, __FILE__, __LINE__ + 1)
+          def fetch_#{alias_name}_by_#{field_list}(#{arg_list})
+            attribute_dynamic_fetcher(#{attribute}, #{fields.inspect}, [#{arg_list}], #{unique})
+          end
+        CODE
       end
 
       def build_recursive_association_cache(association, options) #:nodoc:
-        options[:association_class]      = reflect_on_association(association).klass
+        options[:association_reflection] = reflect_on_association(association)
         options[:cached_accessor_name]   = "fetch_#{association}"
         options[:records_variable_name]  = "cached_#{association}"
-        options[:population_method_name] = "populate_#{association}_cache"
 
 
         unless instance_methods.include?(options[:cached_accessor_name].to_sym)
@@ -218,10 +211,6 @@ module IdentityCache
             def #{options[:cached_accessor_name]}
               fetch_recursively_cached_association('#{options[:records_variable_name]}', :#{association})
             end
-
-            def #{options[:population_method_name]}
-              populate_recursively_cached_association('#{options[:records_variable_name]}', :#{association})
-            end
           CODE
 
           options[:only_on_foreign_key_change] = false
@@ -231,32 +220,24 @@ module IdentityCache
 
       def build_id_embedded_has_many_cache(association, options) #:nodoc:
         singular_association = association.to_s.singularize
-        options[:association_class]       = reflect_on_association(association).klass
+        options[:association_reflection]  = reflect_on_association(association)
         options[:cached_accessor_name]    = "fetch_#{association}"
         options[:ids_name]                = "#{singular_association}_ids"
         options[:cached_ids_name]         = "fetch_#{options[:ids_name]}"
         options[:ids_variable_name]       = "cached_#{options[:ids_name]}"
         options[:records_variable_name]   = "cached_#{association}"
-        options[:population_method_name]  = "populate_#{association}_cache"
         options[:prepopulate_method_name] = "prepopulate_fetched_#{association}"
 
         self.class_eval(<<-CODE, __FILE__, __LINE__ + 1)
           attr_reader :#{options[:ids_variable_name]}
 
           def #{options[:cached_ids_name]}
-            #{options[:population_method_name]} unless @#{options[:ids_variable_name]}
-            @#{options[:ids_variable_name]}
-          end
-
-          def #{options[:population_method_name]}
-            @#{options[:ids_variable_name]} = #{options[:ids_name]}
-            association_cache.delete(:#{association})
+            @#{options[:ids_variable_name]} ||= #{options[:ids_name]}
           end
 
           def #{options[:cached_accessor_name]}
             if IdentityCache.should_use_cache? || #{association}.loaded?
-              #{options[:population_method_name]} unless @#{options[:ids_variable_name]} || @#{options[:records_variable_name]}
-              @#{options[:records_variable_name]} ||= #{options[:association_class]}.fetch_multi(@#{options[:ids_variable_name]})
+              @#{options[:records_variable_name]} ||= #{options[:association_reflection].klass}.fetch_multi(#{options[:cached_ids_name]})
             else
               #{association}
             end
@@ -271,30 +252,26 @@ module IdentityCache
         add_parent_expiry_hook(options)
       end
 
-      def attribute_dynamic_fetcher(attribute, fields, values) #:nodoc:
-        cache_key = rails_cache_key_for_attribute_and_fields_and_values(attribute, fields, values)
-        IdentityCache.fetch(cache_key) { identity_cache_conditions(fields, values).limit(1).pluck(attribute).first }
+      def attribute_dynamic_fetcher(attribute, fields, values, unique_index) #:nodoc:
+        raise_if_scoped
+        cache_key = rails_cache_key_for_attribute_and_fields_and_values(attribute, fields, values, unique_index)
+        IdentityCache.fetch(cache_key) do
+          query = reorder(nil).where(Hash[fields.zip(values)])
+          query = query.limit(1) if unique_index
+          results = query.pluck(attribute)
+          unique_index ? results.first : results
+        end
       end
 
       def add_parent_expiry_hook(options)
-        child_class = options[:association_class]
-        raise InverseAssociationError unless child_class.reflect_on_association(options[:inverse_name])
+        child_class = options[:association_reflection].klass
 
         child_class.send(:include, ArTransactionChanges) unless child_class.include?(ArTransactionChanges)
         child_class.send(:include, ParentModelExpiration) unless child_class.include?(ParentModelExpiration)
 
         child_class.parent_expiration_entries[options[:inverse_name]] << [self, options[:only_on_foreign_key_change]]
 
-        child_class.class_eval(<<-CODE, __FILE__, __LINE__ + 1)
-          after_commit :expire_parent_caches
-          if Gem::Version.new(ActiveRecord::VERSION::STRING) < Gem::Version.new("4.0.4")
-            after_touch :expire_parent_caches
-          end
-        CODE
-      end
-
-      def identity_cache_conditions(fields, values)
-        reorder(nil).where(Hash[fields.zip(values)])
+        child_class.after_commit :expire_parent_caches
       end
 
       def deprecate_embed_option(options, old_value, new_value)
@@ -303,6 +280,28 @@ module IdentityCache
           ActiveSupport::Deprecation.warn("`embed: #{old_value.inspect}` was renamed to `embed: #{new_value.inspect}` for clarity", caller(2))
         end
       end
+
+      def ensure_base_model
+        if self != cached_model
+          raise DerivedModelError, "IdentityCache class methods must be called on the same model that includes IdentityCache"
+        end
+      end
+
+      def ensure_cacheable_association(association, options)
+        unless association_reflection = self.reflect_on_association(association)
+          raise AssociationError, "Association named '#{association}' was not found on #{self.class}"
+        end
+        if association_reflection.options[:through]
+          raise UnsupportedAssociationError, "caching through associations isn't supported"
+        end
+        options[:inverse_name] ||= association_reflection.inverse_of.name if association_reflection.inverse_of
+        options[:inverse_name] ||= self.name.underscore.to_sym
+        child_class = association_reflection.klass
+        raise InverseAssociationError unless child_class.reflect_on_association(options[:inverse_name])
+        unless options[:embed] == true || child_class.include?(IdentityCache)
+          raise UnsupportedAssociationError, "associated class #{child_class} must include IdentityCache to be cached without full embedding"
+        end
+      end
     end
   end
 end