identity_cache 0.4.1 → 1.1.0

data/Rakefile

@@ -1,13 +1,14 @@
 #!/usr/bin/env rake
+# frozen_string_literal: true
 require 'bundler/gem_tasks'
 
 require 'rake/testtask'
 require 'rdoc/task'
 
-desc 'Default: run unit tests.'
-task :default => :test
+desc('Default: run tests and style checks.')
+task(default: [:test, :rubocop])
 
-desc 'Test the identity_cache plugin.'
+desc('Test the identity_cache plugin.')
 Rake::TestTask.new(:test) do |t|
   t.libs << 'lib'
   t.libs << 'test'
@@ -15,9 +16,17 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = true
 end
 
-desc 'Update serialization format test fixture.'
+task :rubocop do
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+end
+
+desc('Update serialization format test fixture.')
 task :update_serialization_format do
-  ruby './test/helpers/update_serialization_format.rb'
+  %w(mysql2 postgresql).each do |db|
+    ENV["DB"] = db
+    ruby './test/helpers/update_serialization_format.rb'
+  end
 end
 
 namespace :benchmark do

data/dev.yml

@@ -3,7 +3,10 @@ name: identity-cache
 up:
   - homebrew:
     - postgresql
-  - ruby: 2.3.3
+    - mysql-client@5.7:
+        or:        [mysql@5.7]
+        conflicts: [mysql-connector-c, mysql, mysql-client]
+  - ruby: 2.6.5
   - railgun
   - bundler
 
@@ -27,6 +30,14 @@ commands:
         bundle exec ruby -I test "$@"
       fi
 
+  style:
+    desc: 'Run rubocop checks'
+    run: bundle exec rubocop "$@"
+
+  check:
+    desc: 'Run tests and style checks'
+    run: bundle exec rake test && bundle exec rubocop
+
   benchmark-cpu:
     desc: 'Run the identity cache CPU benchmark'
     run: bundle exec rake benchmark:cpu
@@ -38,18 +49,3 @@ commands:
   update-serialization-format:
     desc: 'Update serialization format test fixture'
     run: bundle exec rake update_serialization_format
-
-railgun:
-  image: dev:railgun-common-services-0.2.x
-  ip_address: 192.168.64.98
-  memory: 1G
-  cores: 1
-  disk: 1G
-  services:
-    mysql: 3306
-    postgresql: 5432
-    memcached: 11211
-
-packages:
-  - git@github.com:Shopify/dev-shopify.git
-

data/gemfiles/Gemfile.latest-release

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+gemspec path: '..'
+
+gem 'activerecord'
+gem 'activesupport'
+gem "mysql2", ">= 0.4.4"
+gem "pg", ">= 0.18", "< 2.0"
+gem 'rubocop', '~> 1.5'

data/gemfiles/Gemfile.min-supported

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+gemspec path: '..'
+
+gem 'ar_transaction_changes', '~> 1.1.0'
+gem 'activerecord', '~> 5.2.0'
+gem 'mysql2', '~> 0.4.4'
+gem 'pg', '~> 0.18.0'

data/gemfiles/Gemfile.rails-edge

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+gemspec path: '..'
+
+gem 'activerecord', github: 'rails/rails'
+gem 'activesupport', github: 'rails/rails'
+gem "mysql2", ">= 0.4.4"
+gem "pg", "~> 1.1"

data/identity_cache.gemspec

@@ -1,27 +1,46 @@
 # -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 require File.expand_path('../lib/identity_cache/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Camilo Lopez", "Tom Burns", "Harry Brundage", "Dylan Thacker-Smith", "Tobias Lutke", "Arthur Neves", "Francis Bogsanyi"]
+  gem.authors = [
+    "Camilo Lopez",
+    "Tom Burns",
+    "Harry Brundage",
+    "Dylan Thacker-Smith",
+    "Tobias Lutke",
+    "Arthur Neves",
+    "Francis Bogsanyi",
+  ]
   gem.email         = ["gems@shopify.com"]
-  gem.description   = %q{Opt in read through ActiveRecord caching.}
-  gem.summary       = %q{IdentityCache lets you specify how you want to cache your model objects, at the model level, and adds a number of convenience methods for accessing those objects through the cache. Memcached is used as the backend cache store, and the database is only hit when a copy of the object cannot be found in Memcached.}
+  gem.description   = "Opt-in read through Active Record caching."
+  gem.summary       = "IdentityCache lets you specify how you want to cache your " \
+                      "model objects, at the model level, and adds a number of " \
+                      "convenience methods for accessing those objects through " \
+                      "the cache. Memcached is used as the backend cache store, " \
+                      "and the database is only hit when a copy of the object " \
+                      "cannot be found in Memcached."
   gem.homepage      = "https://github.com/Shopify/identity_cache"
 
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.files         = Dir.chdir(File.expand_path(__dir__)) do
+    %x(git ls-files -z).split("\x0").reject { |f| f.match(%r{^test/}) }
+  end
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^test/})
   gem.name          = "identity_cache"
   gem.require_paths = ["lib"]
   gem.version       = IdentityCache::VERSION
 
-  gem.required_ruby_version = '>= 2.2.0'
+  gem.required_ruby_version = '>= 2.5.0'
+
+  gem.metadata['allowed_push_host'] = 'https://rubygems.org'
 
-  gem.add_dependency('ar_transaction_changes', '~> 1.0')
-  gem.add_dependency('activerecord', '>= 4.2.0')
+  gem.add_dependency('ar_transaction_changes', '~> 1.1')
+  gem.add_dependency('activerecord', '>= 5.2')
 
   gem.add_development_dependency('memcached', '~> 1.8.0')
   gem.add_development_dependency('memcached_store', '~> 1.0.0')
+  gem.add_development_dependency('dalli')
   gem.add_development_dependency('rake')
   gem.add_development_dependency('mocha', '0.14.0')
   gem.add_development_dependency('spy')
@@ -33,6 +52,6 @@ Gem::Specification.new do |gem|
     gem.add_development_dependency('cityhash', '0.6.0')
     gem.add_development_dependency('mysql2')
     gem.add_development_dependency('pg')
-    gem.add_development_dependency('stackprof') if Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new("2.1.0")
+    gem.add_development_dependency('stackprof')
   end
 end

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,14 @@ 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
+  autoload :MemCacheStoreCAS, 'identity_cache/mem_cache_store_cas'
+
+  include WithPrimaryIndex
 
   CACHED_NIL = :idc_cached_nil
   BATCH_SIZE = 1000
@@ -34,43 +54,34 @@ module IdentityCache
   DELETED_TTL = 1000
 
   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
-
-    version = Gem::Version.new(IdentityCache::VERSION)
-
-    # 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 = version >= Gem::Version.new("0.5")
-
-    # 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 = version >= Gem::Version.new("0.5")
-
-    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
 
@@ -101,8 +112,27 @@ module IdentityCache
     end
 
     def should_use_cache? # :nodoc:
-      pool = ActiveRecord::Base.connection_pool
-      !pool.active_connection? || pool.connection.open_transactions == 0
+      ActiveRecord::Base.connection_handler.connection_pool_list.none? do |pool|
+        pool.active_connection? &&
+          # Rails wraps each of your tests in a transaction, so that any changes
+          # made to the database during the test can be rolled back afterwards.
+          # These transactions are flagged as "unjoinable", which tries to make
+          # your application behave as if they weren't there. In particular:
+          #
+          #  - Opening another transaction during the test creates a savepoint,
+          #    which can be rolled back independently of the main transaction.
+          #  - When those nested transactions complete, any `after_commit`
+          #    callbacks for records modified during the transaction will run,
+          #    even though the changes haven't actually been committed yet.
+          #
+          # By ignoring unjoinable transactions, IdentityCache's behaviour
+          # during your test suite will more closely match production.
+          #
+          # When there are no open transactions, `current_transaction` returns a
+          # special `NullTransaction` object that is unjoinable, meaning we will
+          # use the cache.
+          pool.connection.current_transaction.joinable?
+      end
     end
 
     # Cache retrieval and miss resolver primitive; given a key it will try to
@@ -114,7 +144,7 @@ module IdentityCache
     #
     def fetch(key)
       if should_use_cache?
-        unmap_cached_nil_for(cache.fetch(key) { map_cached_nil_for yield })
+        unmap_cached_nil_for(cache.fetch(key) { map_cached_nil_for(yield) })
       else
         yield
       end
@@ -135,12 +165,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
@@ -154,29 +184,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