identity_cache 0.4.1 → 1.1.0

data/lib/identity_cache/cache_fetcher.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module IdentityCache
   class CacheFetcher
     attr_accessor :cache_backend
@@ -11,7 +12,7 @@ module IdentityCache
     end
 
     def delete(key)
-      @cache_backend.write(key, IdentityCache::DELETED, :expires_in => IdentityCache::DELETED_TTL.seconds)
+      @cache_backend.write(key, IdentityCache::DELETED, expires_in: IdentityCache::DELETED_TTL.seconds)
     end
 
     def clear
@@ -49,8 +50,8 @@ module IdentityCache
     def cas_multi(keys)
       result = nil
       @cache_backend.cas_multi(*keys) do |results|
-        deleted = results.select {|_, v| IdentityCache::DELETED == v }
-        results.reject! {|_, v| IdentityCache::DELETED == v }
+        deleted = results.select { |_, v| IdentityCache::DELETED == v }
+        results.reject! { |_, v| IdentityCache::DELETED == v }
 
         result = results
         updates = {}
@@ -77,11 +78,11 @@ module IdentityCache
     def add_multi(keys)
       values = yield keys
       result = Hash[keys.zip(values)]
-      result.each {|k, v| add(k, v) }
+      result.each { |k, v| add(k, v) }
     end
 
     def add(key, value)
-      @cache_backend.write(key, value, :unless_exist => true) if IdentityCache.should_fill_cache?
+      @cache_backend.write(key, value, unless_exist: true) if IdentityCache.should_fill_cache?
     end
   end
 end

data/lib/identity_cache/cache_hash.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
 # Use CityHash for fast hashing if it is available; use Digest::MD5 otherwise
 begin
   require 'cityhash'
 rescue LoadError
   unless RUBY_PLATFORM == 'java'
-    warn <<-NOTICE
+    warn(<<-NOTICE)
       ** Notice: CityHash was not loaded. **
 
       For optimal performance, use of the cityhash gem is recommended.
@@ -19,7 +20,6 @@ end
 
 module IdentityCache
   module CacheHash
-
     if defined?(CityHash)
 
       def memcache_hash(key) #:nodoc:

data/lib/identity_cache/cache_invalidation.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 module IdentityCache
   module CacheInvalidation
-
-    CACHE_KEY_NAMES = [:ids_variable_name, :records_variable_name]
+    CACHE_KEY_NAMES = [:ids_variable_name, :id_variable_name, :records_variable_name]
 
     def reload(*)
       clear_cached_associations
@@ -11,15 +11,8 @@ module IdentityCache
     private
 
     def clear_cached_associations
-      self.class.send(:all_cached_associations).each do |_, data|
-        CACHE_KEY_NAMES.each do |key|
-          if data[key]
-            instance_variable_name = "@#{data[key]}"
-            if instance_variable_defined?(instance_variable_name)
-              remove_instance_variable(instance_variable_name)
-            end
-          end
-        end
+      self.class.all_cached_associations.each_value do |association|
+        association.clear(self)
       end
     end
   end

data/lib/identity_cache/cache_key_generation.rb

@@ -1,88 +1,40 @@
+# frozen_string_literal: true
 module IdentityCache
   module CacheKeyGeneration
     extend ActiveSupport::Concern
-    DEFAULT_NAMESPACE = "IDC:#{CACHE_VERSION}:".freeze
+    DEFAULT_NAMESPACE = "IDC:#{CACHE_VERSION}:"
 
     def self.schema_to_string(columns)
-      columns.sort_by(&:name).map{|c| "#{c.name}:#{c.type}"}.join(',')
+      columns.sort_by(&:name).map { |c| "#{c.name}:#{c.type}" }.join(',')
     end
 
-    def self.denormalized_schema_hash(klass)
-      schema_string = schema_to_string(klass.columns)
-      if klass.include?(IdentityCache)
-        klass.send(:all_cached_associations).sort.each do |name, options|
+    def self.denormalized_schema_string(klass)
+      schema_to_string(klass.columns).tap do |schema_string|
+        klass.all_cached_associations.sort.each do |name, association|
           klass.send(:check_association_scope, name)
-          case options[:embed]
-          when true
-            schema_string << ",#{name}:(#{denormalized_schema_hash(options[:association_reflection].klass)})"
-          when :ids
+          association.validate if association.embedded?
+          case association
+          when Cached::Recursive::Association
+            schema_string << ",#{name}:(#{denormalized_schema_hash(association.reflection.klass)})"
+          when Cached::Reference::HasMany
             schema_string << ",#{name}:ids"
+          when Cached::Reference::HasOne
+            schema_string << ",#{name}:id"
           end
         end
       end
+    end
+
+    def self.denormalized_schema_hash(klass)
+      schema_string = denormalized_schema_string(klass)
       IdentityCache.memcache_hash(schema_string)
     end
 
     module ClassMethods
-      def rails_cache_key(id)
-        "#{prefixed_rails_cache_key}#{id}"
-      end
-
-      def rails_cache_key_prefix
-        @rails_cache_key_prefix ||= IdentityCache::CacheKeyGeneration.denormalized_schema_hash(self)
-      end
-
-      def prefixed_rails_cache_key
-        "#{rails_cache_key_namespace}blob:#{base_class.name}:#{rails_cache_key_prefix}:"
-      end
-
-      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
         ns = IdentityCache.cache_namespace
         ns.is_a?(Proc) ? ns.call(self) : ns
       end
-
-      private
-      def rails_cache_string_for_fields_and_values(fields, values)
-        "#{fields.join('/')}:#{IdentityCache.memcache_hash(values.join('/'))}"
-      end
-    end
-
-    def primary_cache_index_key # :nodoc:
-      self.class.rails_cache_key(id)
-    end
-
-    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, 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:
-      fields.collect {|field| self.send(field)}
-    end
-
-    def old_values_for_fields(fields) # :nodoc:
-      fields.map do |field|
-        field_string = field.to_s
-        if destroyed? && transaction_changed_attributes.has_key?(field_string)
-          transaction_changed_attributes[field_string]
-        elsif persisted? && transaction_changed_attributes.has_key?(field_string)
-          transaction_changed_attributes[field_string]
-        else
-          self.send(field)
-        end
-      end
     end
   end
 end

data/lib/identity_cache/cache_key_loader.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module IdentityCache
+  # A generic cache key loader that supports different types of
+  # cache fetchers, each of which can use their own cache key
+  # format and have their own cache miss resolvers.
+  #
+  # Here is the interface of a cache fetcher in the
+  # [ruby-signature](https://github.com/ruby/ruby-signature)'s
+  # format.
+  #
+  # ```
+  # interface _CacheFetcher[DbKey, DbValue, CacheableValue]
+  #   def cache_key: (DbKey) -> String
+  #   def cache_encode: (DbValue) -> CacheableValue
+  #   def cache_decode: (CacheableValue) -> DbValue
+  #   def load_one_from_db: (DbKey) -> DbValue
+  #   def load_multi_from_db: (Array[DbKey]) -> Hash[DbKey, DbValue]
+  # end
+  # ```
+  module CacheKeyLoader
+    class << self
+      # Load a single key for a cache fetcher.
+      #
+      # @param cache_fetcher [_CacheFetcher]
+      # @param db_key Reference to what to load from the database.
+      # @return The database value corresponding to the database key.
+      def load(cache_fetcher, db_key)
+        cache_key = cache_fetcher.cache_key(db_key)
+
+        db_value = nil
+
+        cache_value = IdentityCache.fetch(cache_key) do
+          db_value = cache_fetcher.load_one_from_db(db_key)
+          cache_fetcher.cache_encode(db_value)
+        end
+
+        db_value || cache_fetcher.cache_decode(cache_value)
+      end
+
+      # Load multiple keys for a cache fetcher.
+      #
+      # @param cache_fetcher [_CacheFetcher]
+      # @param db_key [Array] Reference to what to load from the database.
+      # @return [Hash] A hash mapping each database key to its corresponding value
+      def load_multi(cache_fetcher, db_keys)
+        load_batch(cache_fetcher => db_keys).fetch(cache_fetcher)
+      end
+
+      # Load multiple keys for multiple cache fetchers
+      def load_batch(cache_fetcher_to_db_keys_hash)
+        cache_key_to_db_key_hash = {}
+        cache_key_to_cache_fetcher_hash = {}
+
+        batch_load_result = {}
+
+        cache_fetcher_to_db_keys_hash.each do |cache_fetcher, db_keys|
+          if db_keys.empty?
+            batch_load_result[cache_fetcher] = {}
+            next
+          end
+          db_keys.each do |db_key|
+            cache_key = cache_fetcher.cache_key(db_key)
+            cache_key_to_db_key_hash[cache_key] = db_key
+            cache_key_to_cache_fetcher_hash[cache_key] = cache_fetcher
+          end
+        end
+
+        cache_keys = cache_key_to_db_key_hash.keys
+        cache_result = cache_fetch_multi(cache_keys) do |unresolved_cache_keys|
+          cache_fetcher_to_unresolved_keys_hash = unresolved_cache_keys.group_by do |cache_key|
+            cache_key_to_cache_fetcher_hash.fetch(cache_key)
+          end
+
+          resolve_miss_result = {}
+
+          db_keys_buffer = []
+          cache_fetcher_to_unresolved_keys_hash.each do |cache_fetcher, unresolved_cache_fetcher_keys|
+            batch_load_result[cache_fetcher] = resolve_multi_on_miss(cache_fetcher, unresolved_cache_fetcher_keys,
+              cache_key_to_db_key_hash, resolve_miss_result, db_keys_buffer: db_keys_buffer)
+          end
+
+          resolve_miss_result
+        end
+
+        cache_result.each do |cache_key, cache_value|
+          cache_fetcher = cache_key_to_cache_fetcher_hash.fetch(cache_key)
+          load_result = (batch_load_result[cache_fetcher] ||= {})
+
+          db_key = cache_key_to_db_key_hash.fetch(cache_key)
+          load_result[db_key] ||= cache_fetcher.cache_decode(cache_value)
+        end
+
+        batch_load_result
+      end
+
+      private
+
+      def cache_fetch_multi(cache_keys)
+        IdentityCache.fetch_multi(cache_keys) do |unresolved_cache_keys|
+          cache_key_to_cache_value_hash = yield unresolved_cache_keys
+          cache_key_to_cache_value_hash.fetch_values(*unresolved_cache_keys)
+        end
+      end
+
+      def resolve_multi_on_miss(
+        cache_fetcher, unresolved_cache_keys, cache_key_to_db_key_hash, resolve_miss_result,
+        db_keys_buffer: []
+      )
+        db_keys_buffer.clear
+        unresolved_cache_keys.each do |cache_key|
+          db_keys_buffer << cache_key_to_db_key_hash.fetch(cache_key)
+        end
+
+        load_result = cache_fetcher.load_multi_from_db(db_keys_buffer)
+
+        unresolved_cache_keys.each do |cache_key|
+          db_key = cache_key_to_db_key_hash.fetch(cache_key)
+          db_value = load_result[db_key]
+          resolve_miss_result[cache_key] = cache_fetcher.cache_encode(db_value)
+        end
+
+        load_result
+      end
+    end
+  end
+  private_constant :CacheKeyLoader
+end

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