identity_cache 0.5.1 → 1.0.0

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

data/lib/identity_cache/encoder.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Encoder
+    DEHYDRATE_EVENT = "dehydration.identity_cache"
+    HYDRATE_EVENT   = "hydration.identity_cache"
+
+    class << self
+      def encode(record)
+        return unless record
+
+        ActiveSupport::Notifications.instrument(DEHYDRATE_EVENT, class: record.class.name) do
+          coder_from_record(record, record.class)
+        end
+      end
+
+      def decode(coder, klass)
+        return unless coder
+
+        ActiveSupport::Notifications.instrument(HYDRATE_EVENT, class: klass.name) do
+          record_from_coder(coder, klass)
+        end
+      end
+
+      private
+
+      def coder_from_record(record, klass)
+        return unless record
+
+        coder = {}
+        coder[:attributes] = record.attributes_before_type_cast.dup
+
+        recursively_embedded_associations = klass.send(:recursively_embedded_associations)
+        id_embedded_has_manys = klass.cached_has_manys.select { |_, association| association.embedded_by_reference? }
+        id_embedded_has_ones = klass.cached_has_ones.select { |_, association| association.embedded_by_reference? }
+
+        if recursively_embedded_associations.present?
+          coder[:associations] = recursively_embedded_associations.each_with_object({}) do |(name, association), hash|
+            hash[name] = IdentityCache.map_cached_nil_for(embedded_coder(record, name, association))
+          end
+        end
+
+        if id_embedded_has_manys.present?
+          coder[:association_ids] = id_embedded_has_manys.each_with_object({}) do |(name, association), hash|
+            hash[name] = record.instance_variable_get(association.ids_variable_name)
+          end
+        end
+
+        if id_embedded_has_ones.present?
+          coder[:association_id] = id_embedded_has_ones.each_with_object({}) do |(name, association), hash|
+            hash[name] = record.instance_variable_get(association.id_variable_name)
+          end
+        end
+
+        coder
+      end
+
+      def embedded_coder(record, _association, cached_association)
+        embedded_record_or_records = record.public_send(cached_association.cached_accessor_name)
+
+        if embedded_record_or_records.respond_to?(:to_ary)
+          embedded_record_or_records.map do |embedded_record|
+            coder_from_record(embedded_record, embedded_record.class)
+          end
+        else
+          coder_from_record(embedded_record_or_records, embedded_record_or_records.class)
+        end
+      end
+
+      def record_from_coder(coder, klass) #:nodoc:
+        record = klass.instantiate(coder[:attributes].dup)
+
+        if coder.key?(:associations)
+          coder[:associations].each do |name, value|
+            record.instance_variable_set(klass.cached_association(name).dehydrated_variable_name, value)
+          end
+        end
+        if coder.key?(:association_ids)
+          coder[:association_ids].each do |name, ids|
+            record.instance_variable_set(klass.cached_has_manys.fetch(name).ids_variable_name, ids)
+          end
+        end
+        if coder.key?(:association_id)
+          coder[:association_id].each do |name, id|
+            record.instance_variable_set(klass.cached_has_ones.fetch(name).id_variable_name, id)
+          end
+        end
+
+        record.readonly! if IdentityCache.fetch_read_only_records
+        record
+      end
+    end
+  end
+
+  private_constant :Encoder
+end

data/lib/identity_cache/expiry_hook.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module IdentityCache
+  class ExpiryHook
+    def initialize(cached_association)
+      @cached_association = cached_association
+    end
+
+    def install
+      cached_association.validate
+      entry = [parent_class, only_on_foreign_key_change?]
+      child_class.parent_expiration_entries[inverse_name] << entry
+    end
+
+    private
+
+    attr_reader :cached_association
+
+    def only_on_foreign_key_change?
+      cached_association.embedded_by_reference?
+    end
+
+    def inverse_name
+      cached_association.inverse_name
+    end
+
+    def parent_class
+      cached_association.reflection.active_record
+    end
+
+    def child_class
+      cached_association.reflection.klass
+    end
+  end
+
+  private_constant :ExpiryHook
+end