identity_cache 0.4.1 → 1.1.0

data/lib/identity_cache/cached/recursive/has_many.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    module Recursive
+      class HasMany < Association # :nodoc:
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/recursive/has_one.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    module Recursive
+      class HasOne < Association # :nodoc:
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/reference/association.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    module Reference
+      class Association < Cached::Association # :nodoc:
+        def embedded_by_reference?
+          true
+        end
+
+        def embedded_recursively?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/reference/has_many.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    module Reference
+      class HasMany < Association # :nodoc:
+        def initialize(name, reflection:)
+          super
+          @cached_ids_name = "fetch_#{ids_name}"
+          @ids_variable_name = :"@#{ids_cached_reader_name}"
+        end
+
+        attr_reader :cached_ids_name, :ids_variable_name
+
+        def build
+          reflection.active_record.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            attr_reader :#{ids_cached_reader_name}
+
+            def #{cached_ids_name}
+              #{ids_variable_name} ||= #{ids_name}
+            end
+
+            def #{cached_accessor_name}
+              assoc = association(:#{name})
+              if assoc.klass.should_use_cache? && !assoc.loaded? && assoc.target.blank?
+                #{records_variable_name} ||= #{reflection.class_name}.fetch_multi(#{cached_ids_name})
+              else
+                #{name}.to_a
+              end
+            end
+          RUBY
+
+          ParentModelExpiration.add_parent_expiry_hook(self)
+        end
+
+        def read(record)
+          record.public_send(cached_ids_name)
+        end
+
+        def write(record, ids)
+          record.instance_variable_set(ids_variable_name, ids)
+        end
+
+        def clear(record)
+          [ids_variable_name, records_variable_name].each do |ivar|
+            if record.instance_variable_defined?(ivar)
+              record.remove_instance_variable(ivar)
+            end
+          end
+        end
+
+        def fetch(records)
+          fetch_async(LoadStrategy::Eager, records) { |child_records| child_records }
+        end
+
+        def fetch_async(load_strategy, records)
+          fetch_embedded_async(load_strategy, records) do
+            ids_to_parent_record = records.each_with_object({}) do |record, hash|
+              child_ids = record.send(cached_ids_name)
+              child_ids.each do |child_id|
+                hash[child_id] = record
+              end
+            end
+
+            load_strategy.load_multi(
+              reflection.klass.cached_primary_index,
+              ids_to_parent_record.keys
+            ) do |child_records_by_id|
+              parent_record_to_child_records = Hash.new { |h, k| h[k] = [] }
+
+              child_records_by_id.each do |id, child_record|
+                parent_record = ids_to_parent_record.fetch(id)
+                parent_record_to_child_records[parent_record] << child_record
+              end
+
+              parent_record_to_child_records.each do |parent, children|
+                parent.instance_variable_set(records_variable_name, children)
+              end
+
+              yield child_records_by_id.values.compact
+            end
+          end
+        end
+
+        private
+
+        def embedded_fetched?(records)
+          record = records.first
+          super || record.instance_variable_defined?(ids_variable_name)
+        end
+
+        def singular_name
+          name.to_s.singularize
+        end
+
+        def ids_name
+          "#{singular_name}_ids"
+        end
+
+        def ids_cached_reader_name
+          "cached_#{ids_name}"
+        end
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/reference/has_one.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    module Reference
+      class HasOne < Association # :nodoc:
+        def initialize(name, reflection:)
+          super
+          @cached_id_name = "fetch_#{id_name}"
+          @id_variable_name = :"@#{id_cached_reader_name}"
+        end
+
+        attr_reader :cached_id_name, :id_variable_name
+
+        def build
+          reflection.active_record.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            attr_reader :#{id_cached_reader_name}
+
+            def #{cached_id_name}
+              return #{id_variable_name} if defined?(#{id_variable_name})
+              #{id_variable_name} = association(:#{name}).scope.ids.first
+            end
+
+            def #{cached_accessor_name}
+              assoc = association(:#{name})
+              if assoc.klass.should_use_cache? && !assoc.loaded?
+                #{records_variable_name} ||= #{reflection.class_name}.fetch(#{cached_id_name}) if #{cached_id_name}
+              else
+                #{name}
+              end
+            end
+          RUBY
+
+          ParentModelExpiration.add_parent_expiry_hook(self)
+        end
+
+        def read(record)
+          record.public_send(cached_id_name)
+        end
+
+        def write(record, id)
+          record.instance_variable_set(id_variable_name, id)
+        end
+
+        def clear(record)
+          [id_variable_name, records_variable_name].each do |ivar|
+            if record.instance_variable_defined?(ivar)
+              record.remove_instance_variable(ivar)
+            end
+          end
+        end
+
+        def fetch(records)
+          fetch_async(LoadStrategy::Eager, records) { |child_records| child_records }
+        end
+
+        def fetch_async(load_strategy, records)
+          fetch_embedded_async(load_strategy, records) do
+            ids_to_parent_record = records.each_with_object({}) do |record, hash|
+              child_id = record.send(cached_id_name)
+              hash[child_id] = record if child_id
+            end
+
+            load_strategy.load_multi(
+              reflection.klass.cached_primary_index,
+              ids_to_parent_record.keys
+            ) do |child_records_by_id|
+              parent_record_to_child_record = {}
+
+              child_records_by_id.each do |id, child_record|
+                parent_record = ids_to_parent_record.fetch(id)
+                parent_record_to_child_record[parent_record] ||= child_record
+              end
+
+              parent_record_to_child_record.each do |parent, child|
+                parent.instance_variable_set(records_variable_name, child)
+              end
+
+              yield child_records_by_id.values.compact
+            end
+          end
+        end
+
+        private
+
+        def embedded_fetched?(records)
+          record = records.first
+          super || record.instance_variable_defined?(id_variable_name)
+        end
+
+        def id_name
+          "#{name}_id"
+        end
+
+        def id_cached_reader_name
+          "cached_#{id_name}"
+        end
+      end
+    end
+  end
+end

data/lib/identity_cache/configuration_dsl.rb

@@ -1,76 +1,19 @@
+# frozen_string_literal: true
 module IdentityCache
   module ConfigurationDSL
     extend ActiveSupport::Concern
 
     included do |base|
-      base.class_attribute :cache_indexes
-      base.class_attribute :cached_has_manys
-      base.class_attribute :cached_has_ones
-      base.class_attribute :primary_cache_index_enabled
+      base.class_attribute(:cache_indexes)
+      base.class_attribute(:cached_has_manys)
+      base.class_attribute(:cached_has_ones)
 
       base.cached_has_manys = {}
       base.cached_has_ones = {}
       base.cache_indexes = []
-      base.primary_cache_index_enabled = true
-
-      base.after_commit :expire_parent_caches
     end
 
     module ClassMethods
-      # Declares a new index in the cache for the class where IdentityCache was
-      # included.
-      #
-      # IdentityCache will add a fetch_by_field1_and_field2_and_...field for every
-      # index.
-      #
-      # == Example:
-      #
-      #  class Product
-      #    include IdentityCache
-      #    cache_index :name, :vendor
-      #  end
-      #
-      # Will add Product.fetch_by_name_and_vendor
-      #
-      # == Parameters
-      #
-      # +fields+ Array of symbols or strings representing the fields in the index
-      #
-      # == Options
-      # * unique: if the index would only have unique values
-      #
-      def cache_index(*fields)
-        raise NotImplementedError, "Cache indexes need an enabled primary index" unless primary_cache_index_enabled
-        options = fields.extract_options!
-        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 unique
-          self.instance_eval(ruby = <<-CODE, __FILE__, __LINE__ + 1)
-            def fetch_by_#{field_list}(#{arg_list}, options={})
-              id = fetch_id_by_#{field_list}(#{arg_list})
-              id && fetch_by_id(id, options)
-            end
-
-            # exception throwing variant
-            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}, options={})
-              ids = fetch_id_by_#{field_list}(#{arg_list})
-              ids.empty? ? ids : fetch_multi(ids, options)
-            end
-          CODE
-        end
-      end
-
-
       # Will cache an association to the class including IdentityCache.
       # The embed option, if set, will make IdentityCache keep the association
       # values in the same cache entry as the parent.
@@ -84,10 +27,8 @@ module IdentityCache
       #     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
@@ -95,27 +36,28 @@ module IdentityCache
       #
       # == Options
       #
-      # * embed: If set to true, will cause IdentityCache to keep the
-      #   values for this association in the same cache entry as the parent,
-      #   instead of its own.
-      # * 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 = {})
+      # * embed: If `true`, IdentityCache will embed the associated records
+      #   in the cache entries for this model, as well as all the embedded
+      #   associations for the associated record recursively.
+      #   If `:ids` (the default), it will only embed the ids for the associated
+      #   records.
+      def cache_has_many(association, embed: :ids)
         ensure_base_model
-        options = options.slice(:embed, :inverse_name)
-        options[:embed] = :ids unless options.has_key?(:embed)
-        deprecate_embed_option(options, false, :ids)
-        ensure_cacheable_association(association, options)
-        self.cached_has_manys[association] = options
-
-        case options[:embed]
-        when true
-          build_recursive_association_cache(association, options)
+        check_association_for_caching(association)
+        reflection = reflect_on_association(association)
+        association_class = case embed
         when :ids
-          build_id_embedded_has_many_cache(association, options)
+          Cached::Reference::HasMany
+        when true
+          Cached::Recursive::HasMany
         else
           raise NotImplementedError
         end
+
+        cached_has_manys[association] = association_class.new(
+          association,
+          reflection: reflection,
+        ).tap(&:build)
       end
 
       # Will cache an association to the class including IdentityCache.
@@ -125,7 +67,7 @@ module IdentityCache
       # == Example:
       #   class Product
       #     cache_has_one :store, embed: true
-      #     cache_has_one :vendor
+      #     cache_has_one :vendor, embed: :id
       #   end
       #
       # == Parameters
@@ -133,24 +75,27 @@ module IdentityCache
       #
       # == Options
       #
-      # * embed: Only true is supported, which is also the default, so
-      #   IdentityCache will keep the values for this association in the same
-      #   cache entry as the parent, instead of its own.
-      # * inverse_name: The name of the parent in the association ( only
-      #   necessary if the name is not the lowercase pluralization of the
-      #   parent object's class)
-      def cache_has_one(association, options = {})
+      # * embed: If `true`, IdentityCache will embed the associated record
+      #   in the cache entries for this model, as well as all the embedded
+      #   associations for the associated record recursively.
+      #   If `:id`, it will only embed the id for the associated record.
+      def cache_has_one(association, embed:)
         ensure_base_model
-        options = options.slice(:embed, :inverse_name)
-        options[:embed] = true unless options.has_key?(:embed)
-        ensure_cacheable_association(association, options)
-        self.cached_has_ones[association] = options
-
-        if options[:embed] == true
-          build_recursive_association_cache(association, options)
+        check_association_for_caching(association)
+        reflection = reflect_on_association(association)
+        association_class = case embed
+        when :id
+          Cached::Reference::HasOne
+        when true
+          Cached::Recursive::HasOne
         else
           raise NotImplementedError
         end
+
+        cached_has_ones[association] = association_class.new(
+          association,
+          reflection: reflection,
+        ).tap(&:build)
       end
 
       # Will cache a single attribute on its own blob, it will add a
@@ -170,145 +115,38 @@ module IdentityCache
       #
       # * 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 = {})
-        cache_attribute_by_alias(attribute.inspect, attribute, options)
-      end
-
-      def disable_primary_cache_index
-        ActiveSupport::Deprecation.warn("disable_primary_cache_index is deprecated, use `include IdentityCache::WithoutPrimaryIndex` instead")
-        ensure_base_model
-        self.primary_cache_index_enabled = false
+      def cache_attribute(attribute, by: :id, unique: true)
+        cache_attribute_by_alias(attribute, alias_name: attribute, by: by, unique: unique)
       end
 
       private
 
-      def cache_attribute_by_alias(attribute, alias_name, options)
+      def cache_attribute_by_alias(attribute_or_proc, alias_name:, by:, unique:)
         ensure_base_model
-        options[:by] ||= :id
-        alias_name = alias_name.to_sym
-        unique = options[:unique].nil? ? true : !!options[:unique]
-        fields = Array(options[:by])
-
-        self.cache_indexes.push [alias_name, fields, unique]
-
-        field_list = fields.join("_and_")
-        arg_list = (0...fields.size).collect { |i| "arg#{i}" }.join(',')
-
-        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_reflection] = reflect_on_association(association)
-        options[:cached_accessor_name]   = "fetch_#{association}"
-        options[:records_variable_name]  = "cached_#{association}"
-
-        self.class_eval(<<-CODE, __FILE__, __LINE__ + 1)
-          def #{options[:cached_accessor_name]}
-            fetch_recursively_cached_association('#{options[:records_variable_name]}', :#{association})
-          end
-        CODE
-
-        options[:only_on_foreign_key_change] = false
-        add_parent_expiry_hook(options)
-      end
-
-      def build_id_embedded_has_many_cache(association, options) #:nodoc:
-        singular_association = association.to_s.singularize
-        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[: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[:ids_variable_name]} ||= #{options[:ids_name]}
-          end
-
-          def #{options[:cached_accessor_name]}
-            association_klass = association(:#{association}).klass
-            if association_klass.should_use_cache? && !#{association}.loaded?
-              @#{options[:records_variable_name]} ||= #{options[:association_reflection].klass}.fetch_multi(#{options[:cached_ids_name]})
-            else
-              #{association}.to_a
-            end
-          end
-
-          def #{options[:prepopulate_method_name]}(records)
-            @#{options[:records_variable_name]} = records
-          end
-        CODE
+        fields = Array(by)
 
-        options[:only_on_foreign_key_change] = true
-        add_parent_expiry_hook(options)
-      end
-
-      def attribute_dynamic_fetcher(attribute, fields, values, unique_index) #:nodoc:
-        raise_if_scoped
-
-        if should_use_cache?
-          cache_key = rails_cache_key_for_attribute_and_fields_and_values(attribute, fields, values, unique_index)
-          IdentityCache.fetch(cache_key) do
-            dynamic_attribute_cache_miss(attribute, fields, values, unique_index)
-          end
-        else
-          dynamic_attribute_cache_miss(attribute, fields, values, unique_index)
-        end
-      end
-
-      def dynamic_attribute_cache_miss(attribute, fields, values, unique_index)
-        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
-
-      def add_parent_expiry_hook(options)
-        child_class = options[:association_reflection].klass
-        unless child_class < IdentityCache
-          message = "associated class #{child_class} will need to include IdentityCache or " \
-            "IdentityCache::WithoutPrimaryIndex for embedded associations"
-          ActiveSupport::Deprecation.warn(message, caller(3))
-          child_class.send(:include, IdentityCache::WithoutPrimaryIndex)
-        end
-        child_class.parent_expiration_entries[options[:inverse_name]] << [self, options[:only_on_foreign_key_change]]
-      end
-
-      def deprecate_embed_option(options, old_value, new_value)
-        if options[:embed] == old_value
-          options[:embed] = new_value
-          ActiveSupport::Deprecation.warn("`embed: #{old_value.inspect}` was renamed to `embed: #{new_value.inspect}` for clarity", caller(2))
-        end
+        klass = fields.one? ? Cached::AttributeByOne : Cached::AttributeByMulti
+        cached_attribute = klass.new(self, attribute_or_proc, alias_name, fields, unique)
+        cached_attribute.build
+        cache_indexes.push(cached_attribute)
       end
 
       def ensure_base_model
         if self != cached_model
-          raise DerivedModelError, "IdentityCache class methods must be called on the same model that includes IdentityCache"
+          raise DerivedModelError, <<~MSG.squish
+            IdentityCache class methods must be called on the same
+            model that includes IdentityCache
+          MSG
         end
       end
 
-      def ensure_cacheable_association(association, options)
-        unless association_reflection = self.reflect_on_association(association)
+      def check_association_for_caching(association)
+        unless (association_reflection = 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