identity_cache 0.4.1 → 1.1.0

data/lib/identity_cache/railtie.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module IdentityCache
+  class Railtie < Rails::Railtie
+    initializer "identity_cache.setup" do |app|
+      app.config.eager_load_namespaces << IdentityCache
+    end
+  end
+end

data/lib/identity_cache/record_not_found.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module IdentityCache
+  class RecordNotFound < ActiveRecord::RecordNotFound
+  end
+end

data/lib/identity_cache/should_use_cache.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module IdentityCache
   module ShouldUseCache
     extend ActiveSupport::Concern

data/lib/identity_cache/version.rb

@@ -1,4 +1,5 @@
+# frozen_string_literal: true
 module IdentityCache
-  VERSION = "0.4.1"
-  CACHE_VERSION = 6
+  VERSION = "1.1.0"
+  CACHE_VERSION = 8
 end

data/lib/identity_cache/with_primary_index.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+module IdentityCache
+  module WithPrimaryIndex
+    extend ActiveSupport::Concern
+
+    include WithoutPrimaryIndex
+
+    def expire_cache
+      expire_primary_index
+      super
+    end
+
+    # @api private
+    def expire_primary_index # :nodoc:
+      self.class.expire_primary_key_cache_index(id)
+    end
+
+    # @api private
+    def primary_cache_index_key # :nodoc:
+      self.class.cached_primary_index.cache_key(id)
+    end
+
+    module ClassMethods
+      # @api private
+      def cached_primary_index
+        @cached_primary_index ||= Cached::PrimaryIndex.new(self)
+      end
+
+      def primary_cache_index_enabled
+        true
+      end
+
+      # 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. Default is false
+      #
+      def cache_index(*fields, unique: false)
+        attribute_proc = -> { primary_key }
+        cache_attribute_by_alias(attribute_proc, alias_name: :id, by: fields, unique: unique)
+
+        field_list = fields.join("_and_")
+        arg_list = (0...fields.size).collect { |i| "arg#{i}" }.join(',')
+
+        if unique
+          instance_eval(<<-CODE, __FILE__, __LINE__ + 1)
+            def fetch_by_#{field_list}(#{arg_list}, includes: nil)
+              id = fetch_id_by_#{field_list}(#{arg_list})
+              id && fetch_by_id(id, includes: includes)
+            end
+
+            # exception throwing variant
+            def fetch_by_#{field_list}!(#{arg_list}, includes: nil)
+              fetch_by_#{field_list}(#{arg_list}, includes: includes) or raise IdentityCache::RecordNotFound
+            end
+          CODE
+        else
+          instance_eval(<<-CODE, __FILE__, __LINE__ + 1)
+            def fetch_by_#{field_list}(#{arg_list}, includes: nil)
+              ids = fetch_id_by_#{field_list}(#{arg_list})
+              ids.empty? ? ids : fetch_multi(ids, includes: includes)
+            end
+          CODE
+        end
+
+        if fields.length == 1
+          instance_eval(<<-CODE, __FILE__, __LINE__ + 1)
+            def fetch_multi_by_#{field_list}(index_values, includes: nil)
+              ids = fetch_multi_id_by_#{field_list}(index_values).values.flatten(1)
+              return ids if ids.empty?
+              fetch_multi(ids, includes: includes)
+            end
+          CODE
+        end
+      end
+
+      # Similar to ActiveRecord::Base#exists? will return true if the id can be
+      # found in the cache or in the DB.
+      def exists_with_identity_cache?(id)
+        !!fetch_by_id(id)
+      end
+
+      # Default fetcher added to the model on inclusion, it behaves like
+      # ActiveRecord::Base.where(id: id).first
+      def fetch_by_id(id, includes: nil)
+        ensure_base_model
+        raise_if_scoped
+        record = cached_primary_index.fetch(id)
+        prefetch_associations(includes, [record]) if record && includes
+        record
+      end
+
+      # Default fetcher added to the model on inclusion, it behaves like
+      # ActiveRecord::Base.find, but will raise IdentityCache::RecordNotFound
+      # if the id is not in the cache.
+      def fetch(id, includes: nil)
+        fetch_by_id(id, includes: includes) || raise(
+          IdentityCache::RecordNotFound, "Couldn't find #{name} with ID=#{id}"
+        )
+      end
+
+      # Default fetcher added to the model on inclusion, if behaves like
+      # ActiveRecord::Base.find_all_by_id
+      def fetch_multi(*ids, includes: nil)
+        ensure_base_model
+        raise_if_scoped
+        ids.flatten!(1)
+        records = cached_primary_index.fetch_multi(ids)
+        prefetch_associations(includes, records) if includes
+        records
+      end
+
+      # Invalidates the primary cache index for the associated record. Will not invalidate cached attributes.
+      def expire_primary_key_cache_index(id)
+        cached_primary_index.expire(id)
+      end
+    end
+  end
+end

data/lib/identity_cache/without_primary_index.rb

@@ -1,10 +1,31 @@
+# frozen_string_literal: true
 module IdentityCache
   module WithoutPrimaryIndex
     extend ActiveSupport::Concern
 
-    included do |base|
-      base.send(:include, IdentityCache)
-      base.primary_cache_index_enabled = false
+    include ArTransactionChanges
+    include IdentityCache::BelongsToCaching
+    include IdentityCache::CacheKeyGeneration
+    include IdentityCache::ConfigurationDSL
+    include IdentityCache::QueryAPI
+    include IdentityCache::CacheInvalidation
+    include IdentityCache::ShouldUseCache
+    include ParentModelExpiration
+
+    def self.append_features(base) #:nodoc:
+      raise AlreadyIncludedError if base.include?(WithoutPrimaryIndex)
+      super
+    end
+
+    included do
+      class_attribute(:cached_model)
+      self.cached_model = self
+    end
+
+    module ClassMethods
+      def primary_cache_index_enabled
+        false
+      end
     end
   end
 end

data/performance/cache_runner.rb

@@ -1,4 +1,5 @@
-$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+# frozen_string_literal: true
+$LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
 require 'active_record'
 require 'active_support/core_ext'
 require 'active_support/cache'
@@ -6,25 +7,19 @@ require 'identity_cache'
 require 'memcached_store'
 require 'active_support/cache/memcached_store'
 
-$memcached_port = 11211
-$mysql_port = 3306
-
 require File.dirname(__FILE__) + '/../test/helpers/active_record_objects'
 require File.dirname(__FILE__) + '/../test/helpers/database_connection'
+require File.dirname(__FILE__) + '/../test/helpers/cache_connection'
 
 IdentityCache.logger = Logger.new(nil)
-IdentityCache.cache_backend = ActiveSupport::Cache::MemcachedStore.new("localhost:#{$memcached_port}", :support_cas => true)
-
-if ActiveRecord.gem_version < Gem::Version.new('5') && ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks=)
-  ActiveRecord::Base.raise_in_transactional_callbacks = true
-end
+CacheConnection.setup
 
 def create_record(id)
   Item.new(id)
 end
 
 def database_ready(count)
-  Item.where(:id => (1..count)).count == count
+  Item.where(id: (1..count)).count == count
 rescue
   false
 end
@@ -42,26 +37,25 @@ def create_database(count)
   DatabaseConnection.create_tables
   existing = Item.all
   (1..count).to_a.each do |i|
-    unless existing.any? { |e| e.id == i }
-      a = Item.new
-      a.id = i
-      a.associated = AssociatedRecord.new(name: "Associated for #{i}")
-      a.associated_records
-      (1..5).each do |j|
-        a.associated_records << AssociatedRecord.new(name: "Has Many #{j} for #{i}")
-        a.normalized_associated_records << NormalizedAssociatedRecord.new(name: "Normalized Has Many #{j} for #{i}")
-      end
-      a.save
+    next if existing.any? { |e| e.id == i }
+    a = Item.new
+    a.id = i
+    a.associated = AssociatedRecord.new(name: "Associated for #{i}")
+    a.associated_records
+    (1..5).each do |j|
+      a.associated_records << AssociatedRecord.new(name: "Has Many #{j} for #{i}")
+      a.normalized_associated_records << NormalizedAssociatedRecord.new(name: "Normalized Has Many #{j} for #{i}")
     end
+    a.save
   end
 ensure
   helper.teardown_models
 end
 
 def setup_embedded_associations
-  Item.cache_has_one :associated
-  Item.cache_has_many :associated_records, :embed => true
-  AssociatedRecord.cache_has_many :deeply_associated_records, :embed => true
+  Item.cache_has_one(:associated, embed: true)
+  Item.cache_has_many(:associated_records, embed: true)
+  AssociatedRecord.cache_has_many(:deeply_associated_records, embed: true)
 end
 
 class CacheRunner
@@ -86,7 +80,7 @@ CACHE_RUNNERS = []
 class FindRunner < CacheRunner
   def run
     (1..@count).each do |i|
-      ::Item.includes(:associated, {:associated_records => :deeply_associated_records}).find(i)
+      ::Item.includes(:associated, associated_records: :deeply_associated_records).find(i)
     end
   end
 end
@@ -109,38 +103,16 @@ end
 module DeletedRunner
   def prepare
     super
-    (1..@count).each {|i| ::Item.find(i).send(:expire_cache) }
-  end
-end
-
-module ConflictRunner
-  def prepare
-    super
-    records = (1..@count).map {|id| ::Item.find(id) }
-    orig_resolve_cache_miss = ::Item.method(:resolve_cache_miss)
-
-    ::Item.define_singleton_method(:resolve_cache_miss) do |id|
-      records[id-1].send(:expire_cache)
-      orig_resolve_cache_miss.call(id)
-    end
-    IdentityCache.cache.clear
-  end
-end
-
-module DeletedConflictRunner
-  include ConflictRunner
-  def prepare
-    super
-    (1..@count).each {|i| ::Item.find(i).send(:expire_cache) }
+    (1..@count).each { |i| ::Item.find(i).expire_cache }
   end
 end
 
 class EmbedRunner < CacheRunner
   def setup_models
     super
-    Item.cache_has_one :associated
-    Item.cache_has_many :associated_records, :embed => true
-    AssociatedRecord.cache_has_many :deeply_associated_records, :embed => true
+    Item.cache_has_one(:associated, embed: true)
+    Item.cache_has_many(:associated_records, embed: true)
+    AssociatedRecord.cache_has_many(:deeply_associated_records, embed: true)
   end
 
   def run
@@ -167,22 +139,12 @@ class FetchEmbedDeletedRunner < EmbedRunner
 end
 CACHE_RUNNERS << FetchEmbedDeletedRunner
 
-class FetchEmbedConflictRunner < EmbedRunner
-  include ConflictRunner
-end
-CACHE_RUNNERS << FetchEmbedConflictRunner
-
-class FetchEmbedDeletedConflictRunner < EmbedRunner
-  include DeletedConflictRunner
-end
-CACHE_RUNNERS << FetchEmbedDeletedConflictRunner
-
 class NormalizedRunner < CacheRunner
   def setup_models
     super
-    Item.cache_has_one :associated # :embed => false isn't supported
-    Item.cache_has_many :associated_records, :embed => :ids
-    AssociatedRecord.cache_has_many :deeply_associated_records, :embed => :ids
+    Item.cache_has_one(:associated, embed: :id)
+    Item.cache_has_many(:associated_records, embed: :ids)
+    AssociatedRecord.cache_has_many(:deeply_associated_records, embed: :ids)
   end
 
   def run
@@ -210,13 +172,3 @@ class FetchNormalizedDeletedRunner < NormalizedRunner
   include DeletedRunner
 end
 CACHE_RUNNERS << FetchNormalizedDeletedRunner
-
-class FetchNormalizedConflictRunner < EmbedRunner
-  include ConflictRunner
-end
-CACHE_RUNNERS << FetchNormalizedConflictRunner
-
-class FetchNormalizedDeletedConflictRunner < EmbedRunner
-  include DeletedConflictRunner
-end
-CACHE_RUNNERS << FetchNormalizedDeletedConflictRunner

data/performance/cpu.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rubygems'
 require 'benchmark'
 
@@ -19,16 +20,16 @@ ensure
   obj.cleanup
 end
 
-def benchmark(runners, label_width=0)
+def benchmark(runners, label_width = 0)
   IdentityCache.cache.clear
   runners.each do |runner|
-    print "#{runner.name}: ".ljust(label_width)
+    print("#{runner.name}: ".ljust(label_width))
     puts run(runner.new(RUNS))
   end
 end
 
 def bmbm(runners)
-  label_width = runners.map{ |r| r.name.size }.max + 2
+  label_width = runners.map { |r| r.name.size }.max + 2
   width = label_width + Benchmark::CAPTION.size
 
   puts 'Rehearsal: '.ljust(width, '-')

data/performance/externals.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rubygems'
 require 'benchmark'
 require 'ruby-prof'
@@ -7,8 +8,8 @@ require_relative 'cache_runner'
 RUNS = 1000
 RubyProf.measure_mode = RubyProf::CPU_TIME
 
-EXTERNALS = {"Memcache" => ["MemCache#set", "MemCache#get"],
-             "Database" => ["Mysql2::Client#query"]}
+EXTERNALS = { "Memcache" => ["MemCache#set", "MemCache#get"],
+              "Database" => ["Mysql2::Client#query"] }
 
 def run(obj)
   obj.prepare
@@ -26,7 +27,7 @@ def count_externals(results)
   count = {}
   results.split(/\n/).each do |line|
     fields = line.split
-    if ext = EXTERNALS.detect { |e| e[1].any? { |method| method == fields[-1] } }
+    if (ext = EXTERNALS.detect { |e| e[1].any? { |method| method == fields[-1] } })
       count[ext[0]] ||= 0
       count[ext[0]] += fields[-2].to_i
     end

data/performance/profile.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rubygems'
 require 'benchmark'
 require 'stackprof'
@@ -21,15 +22,15 @@ end
 
 create_database(RUNS)
 
-if runner_name = ENV['RUNNER']
-  if runner = CACHE_RUNNERS.find{ |r| r.name == runner_name }
+if (runner_name = ENV['RUNNER'])
+  if (runner = CACHE_RUNNERS.find { |r| r.name == runner_name })
     run(runner.new(RUNS), filename: ENV['FILENAME'])
   else
     puts "Couldn't find cache runner #{runner_name.inspect}"
-    exit 1
+    exit(1)
   end
 else
-  CACHE_RUNNERS.each do |runner|
-    run(runner.new(RUNS))
+  CACHE_RUNNERS.each do |cache_runner|
+    run(cache_runner.new(RUNS))
   end
 end

data/railgun.yml

@@ -0,0 +1,16 @@
+# https://dev-accel.shopify.io/dev/railgun/Railgun-Config
+name: identity-cache
+
+vm:
+  image:      /opt/dev/misc/railgun-images/default
+  ip_address: 192.168.64.98
+  memory:     1G
+  cores:      2
+
+volumes:
+  root: 1G
+
+services:
+  - mysql
+  - postgresql
+  - memcached