identity_cache 0.5.1 → 1.0.0

data/lib/identity_cache.rb

@@ -1,8 +1,32 @@
+# frozen_string_literal: true
 require 'active_record'
 require 'active_support/core_ext/module/attribute_accessors'
 require 'ar_transaction_changes'
 
 require "identity_cache/version"
+require "identity_cache/record_not_found"
+require "identity_cache/encoder"
+require "identity_cache/cache_key_loader"
+require "identity_cache/load_strategy/load_request"
+require "identity_cache/load_strategy/multi_load_request"
+require "identity_cache/load_strategy/eager"
+require "identity_cache/load_strategy/lazy"
+require "identity_cache/cached"
+require "identity_cache/cached/prefetcher"
+require "identity_cache/cached/embedded_fetching"
+require "identity_cache/cached/association"
+require "identity_cache/cached/attribute"
+require "identity_cache/cached/attribute_by_one"
+require "identity_cache/cached/attribute_by_multi"
+require "identity_cache/cached/belongs_to"
+require "identity_cache/cached/primary_index"
+require "identity_cache/cached/recursive/association"
+require "identity_cache/cached/recursive/has_one"
+require "identity_cache/cached/recursive/has_many"
+require "identity_cache/cached/reference/association"
+require "identity_cache/cached/reference/has_one"
+require "identity_cache/cached/reference/has_many"
+require "identity_cache/expiry_hook"
 require 'identity_cache/memoized_cache_proxy'
 require 'identity_cache/belongs_to_caching'
 require 'identity_cache/cache_key_generation'
@@ -15,18 +39,12 @@ require "identity_cache/cache_invalidation"
 require "identity_cache/cache_fetcher"
 require "identity_cache/fallback_fetcher"
 require 'identity_cache/without_primary_index'
+require 'identity_cache/with_primary_index'
 
 module IdentityCache
   extend ActiveSupport::Concern
 
-  include ArTransactionChanges
-  include IdentityCache::BelongsToCaching
-  include IdentityCache::CacheKeyGeneration
-  include IdentityCache::ConfigurationDSL
-  include IdentityCache::QueryAPI
-  include IdentityCache::CacheInvalidation
-  include IdentityCache::ShouldUseCache
-  include IdentityCache::ParentModelExpiration
+  include WithPrimaryIndex
 
   CACHED_NIL = :idc_cached_nil
   BATCH_SIZE = 1000
@@ -35,40 +53,28 @@ module IdentityCache
 
   class AlreadyIncludedError < StandardError; end
   class AssociationError < StandardError; end
-  class InverseAssociationError < StandardError
-    def initialize
-      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 InverseAssociationError < StandardError; end
   class UnsupportedScopeError < StandardError; end
   class UnsupportedAssociationError < StandardError; end
   class DerivedModelError < StandardError; end
 
+  mattr_accessor :cache_namespace
+  self.cache_namespace = "IDC:#{CACHE_VERSION}:"
+
+  # Fetched records are not read-only and this could sometimes prevent IDC from
+  # reflecting what's truly in the database when fetch_read_only_records is false.
+  # When set to true, it will only return read-only records when cache is used.
+  mattr_accessor :fetch_read_only_records
+  self.fetch_read_only_records = true
+
   class << self
     include IdentityCache::CacheHash
 
     attr_accessor :readonly
     attr_writer :logger
 
-    mattr_accessor :cache_namespace
-    self.cache_namespace = "IDC:#{CACHE_VERSION}:".freeze
-
-    # Inverse active record associations are set when loading embedded
-    # cache_has_many associations from the cache when never_set_inverse_association
-    # is false. When set to true, it will only set the inverse cached association.
-    mattr_accessor :never_set_inverse_association
-    self.never_set_inverse_association = true
-
-    # Fetched records are not read-only and this could sometimes prevent IDC from
-    # reflecting what's truly in the database when fetch_read_only_records is false.
-    # When set to true, it will only return read-only records when cache is used.
-    mattr_accessor :fetch_read_only_records
-    self.fetch_read_only_records = true
-
-    def included(base) #:nodoc:
-      raise AlreadyIncludedError if base.respond_to?(:cached_model)
-      base.class_attribute :cached_model
-      base.cached_model = base
+    def append_features(base) #:nodoc:
+      raise AlreadyIncludedError if base.include?(IdentityCache)
       super
     end
 
@@ -133,12 +139,12 @@ module IdentityCache
     # +keys+ A collection or array of key strings
     def fetch_multi(*keys)
       keys.flatten!(1)
-      return {} if keys.size == 0
+      return {} if keys.empty?
 
       result = if should_use_cache?
         fetch_in_batches(keys.uniq) do |missed_keys|
           results = yield missed_keys
-          results.map {|e| map_cached_nil_for e }
+          results.map { |e| map_cached_nil_for e }
         end
       else
         results = yield keys
@@ -152,29 +158,26 @@ module IdentityCache
       result
     end
 
-    def with_never_set_inverse_association(value = true)
-      old_value = self.never_set_inverse_association
-      self.never_set_inverse_association = value
-      yield
-    ensure
-      self.never_set_inverse_association = old_value
-    end
-
-
     def with_fetch_read_only_records(value = true)
-      old_value = self.fetch_read_only_records
+      old_value = fetch_read_only_records
       self.fetch_read_only_records = value
       yield
     ensure
       self.fetch_read_only_records = old_value
     end
 
+    def eager_load!
+      ParentModelExpiration.install_all_pending_parent_expiry_hooks
+    end
+
     private
 
     def fetch_in_batches(keys)
-      keys.each_slice(BATCH_SIZE).each_with_object Hash.new do |slice, result|
-        result.merge! cache.fetch_multi(*slice) {|missed_keys| yield missed_keys }
+      keys.each_slice(BATCH_SIZE).each_with_object({}) do |slice, result|
+        result.merge!(cache.fetch_multi(*slice) { |missed_keys| yield missed_keys })
       end
     end
   end
 end
+
+require 'identity_cache/railtie' if defined?(Rails)

data/lib/identity_cache/belongs_to_caching.rb

@@ -1,59 +1,31 @@
+# frozen_string_literal: true
 module IdentityCache
   module BelongsToCaching
     extend ActiveSupport::Concern
 
     included do |base|
-      base.class_attribute :cached_belongs_tos
+      base.class_attribute(:cached_belongs_tos)
       base.cached_belongs_tos = {}
     end
 
     module ClassMethods
-      def cache_belongs_to(association, options = {})
+      def cache_belongs_to(association)
         ensure_base_model
-        raise NotImplementedError if options[:embed]
 
-        unless association_reflection = reflect_on_association(association)
+        unless (reflection = reflect_on_association(association))
           raise AssociationError, "Association named '#{association}' was not found on #{self.class}"
         end
 
-        options = {}
-        self.cached_belongs_tos[association] = options
-
-        options[:embed]                   = false
-        options[:cached_accessor_name]    = "fetch_#{association}"
-        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
+        if reflection.scope
+          raise(
+            UnsupportedAssociationError,
+            "caching association #{self}.#{association} is scoped which isn't supported"
+          )
+        end
 
-      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]}
-            association_klass = association(:#{association}).klass
-            if association_klass.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_klass.fetch_by_id(#{foreign_key})
-              end
-            else
-              if IdentityCache.fetch_read_only_records && association_klass.should_use_cache?
-                readonly_copy(association(:#{association}).load_target)
-              else
-                #{association}
-              end
-            end
-          end
+        cached_belongs_to = Cached::BelongsTo.new(association, reflection: reflection)
 
-          def #{options[:prepopulate_method_name]}(record)
-            @#{options[:records_variable_name]} = record
-          end
-        CODE
+        cached_belongs_tos[association] = cached_belongs_to.tap(&:build)
       end
     end
   end

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.send(: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.send(: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