identity_cache 0.5.1 → 1.0.0

data/lib/identity_cache/cached.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+  end
+
+  private_constant :Cached
+end

data/lib/identity_cache/cached/association.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    class Association # :nodoc:
+      include EmbeddedFetching
+
+      def initialize(name, reflection:)
+        @name = name
+        @reflection = reflection
+        @cached_accessor_name = :"fetch_#{name}"
+        @records_variable_name = :"@cached_#{name}"
+      end
+
+      attr_reader :name, :reflection, :cached_accessor_name, :records_variable_name
+
+      def build
+        raise NotImplementedError
+      end
+
+      def read(_record)
+        raise NotImplementedError
+      end
+
+      def write(_record, _value)
+        raise NotImplementedError
+      end
+
+      def clear(_record)
+        raise NotImplementedError
+      end
+
+      def fetch(_records)
+        raise NotImplementedError
+      end
+
+      def fetch_async(_load_strategy, _records)
+        raise NotImplementedError
+      end
+
+      def embedded?
+        embedded_by_reference? || embedded_recursively?
+      end
+
+      def embedded_by_reference?
+        raise NotImplementedError
+      end
+
+      def embedded_recursively?
+        raise NotImplementedError
+      end
+
+      def inverse_name
+        @inverse_name ||= begin
+          reflection.inverse_of&.name ||
+          reflection.active_record.name.underscore
+        end
+      end
+
+      def validate
+        parent_class = reflection.active_record
+        child_class  = reflection.klass
+
+        unless child_class < IdentityCache::WithoutPrimaryIndex
+          if embedded_recursively?
+            raise UnsupportedAssociationError, <<~MSG.squish
+              cached association #{parent_class}\##{reflection.name} requires
+              associated class #{child_class} to include IdentityCache
+              or IdentityCache::WithoutPrimaryIndex
+            MSG
+          else
+            raise UnsupportedAssociationError, <<~MSG.squish
+              cached association #{parent_class}\##{reflection.name} requires
+              associated class #{child_class} to include IdentityCache
+            MSG
+          end
+        end
+
+        unless child_class.reflect_on_association(inverse_name)
+          raise InverseAssociationError, <<~MSG
+            Inverse name for association #{parent_class}\##{reflection.name} could not be determined.
+            Use the :inverse_of option on the Active Record association to specify the inverse association name.
+          MSG
+        end
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/attribute.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module IdentityCache
+  module Cached
+    # @abstract
+    class Attribute
+      attr_reader :model, :alias_name, :key_fields, :unique
+
+      def initialize(model, attribute_or_proc, alias_name, key_fields, unique)
+        @model = model
+        if attribute_or_proc.is_a?(Proc)
+          @attribute_proc = attribute_or_proc
+        else
+          @attribute = attribute_or_proc.to_sym
+        end
+        @alias_name = alias_name.to_sym
+        @key_fields = key_fields.map(&:to_sym)
+        @unique = !!unique
+      end
+
+      def attribute
+        @attribute ||= @attribute_proc.call.to_sym
+      end
+
+      def fetch(db_key)
+        db_key = cast_db_key(db_key)
+
+        if model.should_use_cache?
+          IdentityCache.fetch(cache_key(db_key)) do
+            load_one_from_db(db_key)
+          end
+        else
+          load_one_from_db(db_key)
+        end
+      end
+
+      def expire(record)
+        unless record.send(:was_new_record?)
+          old_key = old_cache_key(record)
+          IdentityCache.cache.delete(old_key)
+        end
+        unless record.destroyed?
+          new_key = new_cache_key(record)
+          if new_key != old_key
+            IdentityCache.cache.delete(new_key)
+          end
+        end
+      end
+
+      def cache_key(index_key)
+        values_hash = IdentityCache.memcache_hash(unhashed_values_cache_key_string(index_key))
+        "#{model.rails_cache_key_namespace}#{cache_key_prefix}#{values_hash}"
+      end
+
+      def load_one_from_db(key)
+        query = model.reorder(nil).where(load_from_db_where_conditions(key))
+        query = query.limit(1) if unique
+        results = query.pluck(attribute)
+        unique ? results.first : results
+      end
+
+      private
+
+      # @abstract
+      def cast_db_key(_index_key)
+        raise NotImplementedError
+      end
+
+      # @abstract
+      def unhashed_values_cache_key_string(_index_key)
+        raise NotImplementedError
+      end
+
+      # @abstract
+      def load_from_db_where_conditions(_index_key_or_keys)
+        raise NotImplementedError
+      end
+
+      # @abstract
+      def cache_key_from_key_values(_key_values)
+        raise NotImplementedError
+      end
+
+      def field_types
+        @field_types ||= key_fields.map { |field| model.type_for_attribute(field.to_s) }
+      end
+
+      def cache_key_prefix
+        @cache_key_prefix ||= begin
+          unique_indicator = unique ? '' : 's'
+          "attr#{unique_indicator}" \
+            ":#{model.base_class.name}" \
+            ":#{attribute}" \
+            ":#{key_fields.join('/')}:"
+        end
+      end
+
+      def new_cache_key(record)
+        new_key_values = key_fields.map { |field| record.send(field) }
+        cache_key_from_key_values(new_key_values)
+      end
+
+      def old_cache_key(record)
+        old_key_values = key_fields.map do |field|
+          field_string = field.to_s
+          changes = record.transaction_changed_attributes
+          if record.destroyed? && changes.key?(field_string)
+            changes[field_string]
+          elsif record.persisted? && changes.key?(field_string)
+            changes[field_string]
+          else
+            record.send(field)
+          end
+        end
+        cache_key_from_key_values(old_key_values)
+      end
+
+      def fetch_method_suffix
+        "#{alias_name}_by_#{key_fields.join('_and_')}"
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/attribute_by_multi.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module IdentityCache
+  module Cached
+    class AttributeByMulti < Attribute
+      def build
+        cached_attribute = self
+
+        model.define_singleton_method(:"fetch_#{fetch_method_suffix}") do |*key_values|
+          raise_if_scoped
+          cached_attribute.fetch(key_values)
+        end
+      end
+
+      private
+
+      # Attribute method overrides
+
+      def cast_db_key(key_values)
+        field_types.each_with_index do |type, i|
+          key_values[i] = type.cast(key_values[i])
+        end
+        key_values
+      end
+
+      def unhashed_values_cache_key_string(key_values)
+        key_values.map { |v| v.try!(:to_s).inspect }.join('/')
+      end
+
+      def load_from_db_where_conditions(key_values)
+        Hash[key_fields.zip(key_values)]
+      end
+
+      alias_method :cache_key_from_key_values, :cache_key
+    end
+  end
+end

data/lib/identity_cache/cached/attribute_by_one.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module IdentityCache
+  module Cached
+    class AttributeByOne < Attribute
+      attr_reader :key_field
+
+      def initialize(*)
+        super
+        @key_field = key_fields.first
+      end
+
+      def build
+        cached_attribute = self
+
+        model.define_singleton_method(:"fetch_#{fetch_method_suffix}") do |key|
+          raise_if_scoped
+          cached_attribute.fetch(key)
+        end
+
+        model.define_singleton_method(:"fetch_multi_#{fetch_method_suffix}") do |keys|
+          raise_if_scoped
+          cached_attribute.fetch_multi(keys)
+        end
+      end
+
+      def fetch_multi(keys)
+        keys = keys.map { |key| cast_db_key(key) }
+
+        unless model.should_use_cache?
+          return load_multi_from_db(keys)
+        end
+
+        unordered_hash = CacheKeyLoader.load_multi(self, keys)
+
+        # Calling `values` on the result is expected to return the values in the same order as their
+        # corresponding keys. The fetch_multi_by_#{field_list} generated methods depend on this.
+        ordered_hash = {}
+        keys.each { |key| ordered_hash[key] = unordered_hash.fetch(key) }
+        ordered_hash
+      end
+
+      def load_multi_from_db(keys)
+        rows = model.reorder(nil).where(load_from_db_where_conditions(keys)).pluck(key_field, attribute)
+        result = {}
+        default = unique ? nil : []
+        keys.each do |index_value|
+          result[index_value] = default.try!(:dup)
+        end
+        if unique
+          rows.each do |index_value, attribute_value|
+            result[index_value] = attribute_value
+          end
+        else
+          rows.each do |index_value, attribute_value|
+            result[index_value] << attribute_value
+          end
+        end
+        result
+      end
+
+      def cache_encode(db_value)
+        db_value
+      end
+      alias_method :cache_decode, :cache_encode
+
+      private
+
+      # Attribute method overrides
+
+      def cast_db_key(key)
+        field_types.first.cast(key)
+      end
+
+      def unhashed_values_cache_key_string(key)
+        key.try!(:to_s).inspect
+      end
+
+      def load_from_db_where_conditions(key_values)
+        { key_field => key_values }
+      end
+
+      def cache_key_from_key_values(key_values)
+        cache_key(key_values.first)
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/belongs_to.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    class BelongsTo < Association # :nodoc:
+      attr_reader :records_variable_name
+
+      def build
+        reflection.active_record.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def #{cached_accessor_name}
+            association_klass = association(:#{name}).klass
+            if association_klass.should_use_cache? && #{reflection.foreign_key}.present? && !association(:#{name}).loaded?
+              if defined?(#{records_variable_name})
+                #{records_variable_name}
+              else
+                #{records_variable_name} = association_klass.fetch_by_id(#{reflection.foreign_key})
+              end
+            else
+              #{name}
+            end
+          end
+        RUBY
+      end
+
+      def clear(record)
+        if record.instance_variable_defined?(records_variable_name)
+          record.remove_instance_variable(records_variable_name)
+        end
+      end
+
+      def fetch(records)
+        fetch_async(LoadStrategy::Eager, records) { |associated_records| associated_records }
+      end
+
+      def fetch_async(load_strategy, records)
+        if reflection.polymorphic?
+          cache_keys_to_associated_ids = {}
+
+          records.each do |owner_record|
+            associated_id = owner_record.send(reflection.foreign_key)
+            next unless associated_id && !owner_record.instance_variable_defined?(records_variable_name)
+            associated_cache_key = Object.const_get(
+              owner_record.send(reflection.foreign_type)
+            ).cached_model.cached_primary_index
+            unless cache_keys_to_associated_ids[associated_cache_key]
+              cache_keys_to_associated_ids[associated_cache_key] = {}
+            end
+            cache_keys_to_associated_ids[associated_cache_key][associated_id] = owner_record
+          end
+
+          load_strategy.load_batch(cache_keys_to_associated_ids) do |associated_records_by_cache_key|
+            batch_records = []
+            associated_records_by_cache_key.each do |cache_key, associated_records|
+              associated_records.keys.each do |id, associated_record|
+                owner_record = cache_keys_to_associated_ids.fetch(cache_key).fetch(id)
+                batch_records << owner_record
+                owner_record.instance_variable_set(records_variable_name, associated_record)
+              end
+            end
+
+            yield batch_records
+          end
+        else
+          ids_to_owner_record = records.each_with_object({}) do |owner_record, hash|
+            associated_id = owner_record.send(reflection.foreign_key)
+            if associated_id && !owner_record.instance_variable_defined?(records_variable_name)
+              hash[associated_id] = owner_record
+            end
+          end
+
+          load_strategy.load_multi(
+            reflection.klass.cached_primary_index,
+            ids_to_owner_record.keys
+          ) do |associated_records_by_id|
+            associated_records_by_id.each do |id, associated_record|
+              owner_record = ids_to_owner_record.fetch(id)
+              owner_record.instance_variable_set(records_variable_name, associated_record)
+            end
+
+            yield associated_records_by_id.values.compact
+          end
+        end
+      end
+
+      def embedded_recursively?
+        false
+      end
+
+      def embedded_by_reference?
+        false
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/embedded_fetching.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    module EmbeddedFetching
+      private
+
+      def fetch_embedded(records)
+        fetch_embedded_async(LoadStrategy::Eager, records) {}
+      end
+
+      def fetch_embedded_async(load_strategy, records)
+        return yield if embedded_fetched?(records)
+
+        klass = reflection.active_record
+        cached_associations = klass.send(:embedded_associations)
+
+        return yield if cached_associations.empty?
+
+        return yield unless klass.primary_cache_index_enabled
+
+        load_strategy.load_multi(klass.cached_primary_index, records.map(&:id)) do |cached_records_by_id|
+          cached_associations.each_value do |cached_association|
+            records.each do |record|
+              next unless (cached_record = cached_records_by_id[record.id])
+              cached_value = cached_association.read(cached_record)
+              cached_association.write(record, cached_value)
+            end
+          end
+
+          yield
+        end
+      end
+
+      def embedded_fetched?(records)
+        # NOTE: Assume all records are the same, so just check the first one.
+        record = records.first
+        record.association(name).loaded? || record.instance_variable_defined?(records_variable_name)
+      end
+    end
+  end
+end