identity_cache 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e1ebdc0142ea9597f6053f9d07ef1c43bfbd5434
-  data.tar.gz: 4aacba1f352ff488dc13cf4eadb136369c5cb767
+  metadata.gz: 1fa182ed254be40433e84f2bdef8faf341581e5f
+  data.tar.gz: b795a7e03b4cf94a9d5ff3fd77e04186cde84d5c
 SHA512:
-  metadata.gz: a46686540738897cc446dda713c3d99dcb8c7fd513351894d7ac3ae3ee43c46baac0648eb0876cb1db1e5b2bfacf1ee2e8586b3aeb055d6126479794fd797dfa
-  data.tar.gz: 40af995454fc23abaddcab686808a62972758d586f6a4514314a0b30730fac71accbfd83cd671a9e90553dc5daa45a30ab162c21680e76b9691697e9bb8f7707
+  metadata.gz: 51c4645eb6a548c720444d6964412576bf9c84a399ad1a100251953d24f7e114654170eb4ae3111c906fedd1d9f0555c1c3c2734904675383f84f9ee62fe3362
+  data.tar.gz: fabf846eb3ac2d9ccd9eda7f11dc3e42ed64ac5b678863fd1755e066bc04fc77cc46c4cf9eade1149da4a7fa244c28a45a62fdd4c798501a0b3764ded56d697f

data/.travis.yml

@@ -1,8 +1,8 @@
 language: ruby
 
 rvm:
-  - 2.1
-  - 2.2.3
+  - '2.2.6'
+  - '2.3.3'
 
 gemfile:
   - Gemfile.rails42
@@ -10,8 +10,6 @@ gemfile:
 
 matrix:
   exclude:
-    - rvm: 2.1
-      gemfile: Gemfile.rails50
     - gemfile: Gemfile.rails50
       env: DB=postgresql
 

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # IdentityCache changelog
 
+#### 0.4.1
+
+- Deprecated embedded associations on models that don't use IDC (#305)
+- Remove a respond_to? check that hides mistakes in includes hash (#307)
+- Drop ruby 2.1 support (#301)
+- Avoid querying when no ids are passed to fetch_multi (#297)
+- Fix fetching already loaded belongs_to association (#294)
+- Move `should_use_cache?` calls to the model-level (#291)
+- Clone instead of dup record when readonlyifying fetched records (#292)
+- Consistently store the array for cached has many associations (#288)
+
 #### 0.4.0
 
 - Return an array from fetched association to prevent chaining. Up to now, a relation was returned by default. (#287)

data/README.md

@@ -19,7 +19,7 @@ And then execute:
     $ bundle
 
 
-Add the following to your environment/production.rb:
+Add the following to all your environment/*.rb files (production/development/test):
 
 ```ruby
 config.identity_cache_store = :mem_cache_store, Memcached::Rails.new(:servers => ["mem1.server.com"])
@@ -36,6 +36,10 @@ IdentityCache.cache_backend = ActiveSupport::Cache.lookup_store(*Rails.configura
 ### Basic Usage
 
 ``` ruby
+class Image < ActiveRecord::Base
+  include IdentityCache::WithoutPrimaryIndex
+end
+
 class Product < ActiveRecord::Base
   include IdentityCache
 
@@ -44,10 +48,10 @@ class Product < ActiveRecord::Base
   cache_has_many :images, :embed => true
 end
 
-# Fetch the product by its id, the primary index.
+# Fetch the product by its id using the primary primary index as well as the embedded images association.
 @product = Product.fetch(id)
 
-# Fetch the images for the Product. Images are embedded so the product fetch would have already loaded them.
+# Access the loaded images for the Product.
 @images = @product.fetch_images
 ```
 

data/dev.yml

@@ -3,9 +3,7 @@ name: identity-cache
 up:
   - homebrew:
     - postgresql
-  - ruby:
-      version: 2.2.3p172-shopify
-      package: shopify/shopify/shopify-ruby
+  - ruby: 2.3.3
   - railgun
   - bundler
 

data/identity_cache.gemspec

@@ -15,11 +15,13 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = IdentityCache::VERSION
 
+  gem.required_ruby_version = '>= 2.2.0'
+
   gem.add_dependency('ar_transaction_changes', '~> 1.0')
   gem.add_dependency('activerecord', '>= 4.2.0')
 
   gem.add_development_dependency('memcached', '~> 1.8.0')
-  gem.add_development_dependency('memcached_store', '~> 0.12.6')
+  gem.add_development_dependency('memcached_store', '~> 1.0.0')
   gem.add_development_dependency('rake')
   gem.add_development_dependency('mocha', '0.14.0')
   gem.add_development_dependency('spy')

data/lib/identity_cache.rb

@@ -7,14 +7,27 @@ require 'identity_cache/memoized_cache_proxy'
 require 'identity_cache/belongs_to_caching'
 require 'identity_cache/cache_key_generation'
 require 'identity_cache/configuration_dsl'
+require 'identity_cache/should_use_cache'
 require 'identity_cache/parent_model_expiration'
 require 'identity_cache/query_api'
 require "identity_cache/cache_hash"
 require "identity_cache/cache_invalidation"
 require "identity_cache/cache_fetcher"
 require "identity_cache/fallback_fetcher"
+require 'identity_cache/without_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
+
   CACHED_NIL = :idc_cached_nil
   BATCH_SIZE = 1000
   DELETED = :idc_cached_deleted
@@ -55,14 +68,10 @@ module IdentityCache
     self.fetch_read_only_records = version >= Gem::Version.new("0.5")
 
     def included(base) #:nodoc:
-      raise AlreadyIncludedError if base.include?(IdentityCache::ConfigurationDSL)
-
-      base.send(:include, ArTransactionChanges) unless base.include?(ArTransactionChanges)
-      base.send(:include, IdentityCache::BelongsToCaching)
-      base.send(:include, IdentityCache::CacheKeyGeneration)
-      base.send(:include, IdentityCache::ConfigurationDSL)
-      base.send(:include, IdentityCache::QueryAPI)
-      base.send(:include, IdentityCache::CacheInvalidation)
+      raise AlreadyIncludedError if base.respond_to?(:cached_model)
+      base.class_attribute :cached_model
+      base.cached_model = base
+      super
     end
 
     # Sets the cache adaptor IdentityCache will be using

data/lib/identity_cache/belongs_to_caching.rb

@@ -34,15 +34,16 @@ module IdentityCache
         foreign_key = options[:association_reflection].foreign_key
         self.class_eval(<<-CODE, __FILE__, __LINE__ + 1)
           def #{options[:cached_accessor_name]}
-            if IdentityCache.should_use_cache? && #{foreign_key}.present? && !association(:#{association}).loaded?
+            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(:#{association}).klass.fetch_by_id(#{foreign_key})
+                @#{options[:records_variable_name]} = association_klass.fetch_by_id(#{foreign_key})
               end
             else
-              if IdentityCache.fetch_read_only_records && IdentityCache.should_use_cache?
-                load_and_readonlyify(:#{association})
+              if IdentityCache.fetch_read_only_records && association_klass.should_use_cache?
+                readonly_copy(association(:#{association}).load_target)
               else
                 #{association}
               end

data/lib/identity_cache/configuration_dsl.rb

@@ -3,17 +3,17 @@ module IdentityCache
     extend ActiveSupport::Concern
 
     included do |base|
-      base.class_attribute :cached_model
       base.class_attribute :cache_indexes
       base.class_attribute :cached_has_manys
       base.class_attribute :cached_has_ones
       base.class_attribute :primary_cache_index_enabled
 
-      base.cached_model = base
       base.cached_has_manys = {}
       base.cached_has_ones = {}
       base.cache_indexes = []
       base.primary_cache_index_enabled = true
+
+      base.after_commit :expire_parent_caches
     end
 
     module ClassMethods
@@ -175,6 +175,7 @@ module IdentityCache
       end
 
       def disable_primary_cache_index
+        ActiveSupport::Deprecation.warn("disable_primary_cache_index is deprecated, use `include IdentityCache::WithoutPrimaryIndex` instead")
         ensure_base_model
         self.primary_cache_index_enabled = false
       end
@@ -233,7 +234,8 @@ module IdentityCache
           end
 
           def #{options[:cached_accessor_name]}
-            if IdentityCache.should_use_cache? && !#{association}.loaded?
+            association_klass = association(:#{association}).klass
+            if association_klass.should_use_cache? && !#{association}.loaded?
               @#{options[:records_variable_name]} ||= #{options[:association_reflection].klass}.fetch_multi(#{options[:cached_ids_name]})
             else
               #{association}.to_a
@@ -251,24 +253,33 @@ module IdentityCache
 
       def attribute_dynamic_fetcher(attribute, fields, values, unique_index) #:nodoc:
         raise_if_scoped
-        cache_key = rails_cache_key_for_attribute_and_fields_and_values(attribute, fields, values, unique_index)
-        IdentityCache.fetch(cache_key) do
-          query = reorder(nil).where(Hash[fields.zip(values)])
-          query = query.limit(1) if unique_index
-          results = query.pluck(attribute)
-          unique_index ? results.first : results
+
+        if should_use_cache?
+          cache_key = rails_cache_key_for_attribute_and_fields_and_values(attribute, fields, values, unique_index)
+          IdentityCache.fetch(cache_key) do
+            dynamic_attribute_cache_miss(attribute, fields, values, unique_index)
+          end
+        else
+          dynamic_attribute_cache_miss(attribute, fields, values, unique_index)
         end
       end
 
+      def dynamic_attribute_cache_miss(attribute, fields, values, unique_index)
+        query = reorder(nil).where(Hash[fields.zip(values)])
+        query = query.limit(1) if unique_index
+        results = query.pluck(attribute)
+        unique_index ? results.first : results
+      end
+
       def add_parent_expiry_hook(options)
         child_class = options[:association_reflection].klass
-
-        child_class.send(:include, ArTransactionChanges) unless child_class.include?(ArTransactionChanges)
-        child_class.send(:include, ParentModelExpiration) unless child_class.include?(ParentModelExpiration)
-
+        unless child_class < IdentityCache
+          message = "associated class #{child_class} will need to include IdentityCache or " \
+            "IdentityCache::WithoutPrimaryIndex for embedded associations"
+          ActiveSupport::Deprecation.warn(message, caller(3))
+          child_class.send(:include, IdentityCache::WithoutPrimaryIndex)
+        end
         child_class.parent_expiration_entries[options[:inverse_name]] << [self, options[:only_on_foreign_key_change]]
-
-        child_class.after_commit :expire_parent_caches
       end
 
       def deprecate_embed_option(options, old_value, new_value)

data/lib/identity_cache/parent_model_expiration.rb

@@ -25,7 +25,7 @@ module IdentityCache
       key = record.primary_cache_index_key
       unless parents_to_expire[key]
         parents_to_expire[key] = record
-        record.add_parents_to_cache_expiry_set(parents_to_expire) if record.respond_to?(:add_parents_to_cache_expiry_set, true)
+        record.add_parents_to_cache_expiry_set(parents_to_expire)
       end
     end
 

data/lib/identity_cache/query_api.rb

@@ -21,7 +21,7 @@ module IdentityCache
         raise_if_scoped
         raise NotImplementedError, "fetching needs the primary index enabled" unless primary_cache_index_enabled
         return unless id
-        record = if IdentityCache.should_use_cache?
+        record = if should_use_cache?
           require_if_necessary do
             object = nil
             coder = IdentityCache.fetch(rails_cache_key(id)){ coder_from_record(object = resolve_cache_miss(id)) }
@@ -53,7 +53,7 @@ module IdentityCache
         raise NotImplementedError, "fetching needs the primary index enabled" unless primary_cache_index_enabled
         options = ids.extract_options!
         ids.flatten!(1)
-        records = if IdentityCache.should_use_cache?
+        records = if should_use_cache?
           require_if_necessary do
             cache_keys = ids.map {|id| rails_cache_key(id) }
             key_to_id_map = Hash[ cache_keys.zip(ids) ]
@@ -79,10 +79,6 @@ module IdentityCache
       def prefetch_associations(associations, records)
         records = records.to_a
         return if records.empty?
-        unless IdentityCache.should_use_cache?
-          ActiveRecord::Associations::Preloader.new.preload(records, associations)
-          return
-        end
 
         case associations
         when nil
@@ -97,8 +93,8 @@ module IdentityCache
           associations.each do |association, sub_associations|
             next_level_records = prefetch_one_association(association, records)
 
-            associated_class = reflect_on_association(association).klass
-            if associated_class.respond_to?(:prefetch_associations)
+            if sub_associations.present?
+              associated_class = reflect_on_association(association).klass
               associated_class.prefetch_associations(sub_associations, next_level_records)
             end
           end
@@ -152,16 +148,17 @@ module IdentityCache
         value = if IdentityCache.unmap_cached_nil_for(coder_or_array).nil?
           nil
         elsif (reflection = record.class.reflect_on_association(association_name)).collection?
-          association = reflection.association_class.new(record, reflection)
-          association.target = coder_or_array.map {|e| record_from_coder(e) }
+          associated_records = coder_or_array.map {|e| record_from_coder(e) }
 
-          set_inverse_of_cached_has_many(record, reflection, association.target)
+          set_inverse_of_cached_has_many(record, reflection, associated_records)
 
           unless IdentityCache.never_set_inverse_association
+            association = reflection.association_class.new(record, reflection)
+            association.target = associated_records
             association.target.each {|e| association.set_inverse_instance(e) }
           end
 
-          association
+          associated_records
         else
           record_from_coder(coder_or_array)
         end
@@ -227,7 +224,7 @@ module IdentityCache
         record = self.includes(cache_fetch_includes).reorder(nil).where(primary_key => id).first
         if record
           preload_id_embedded_associations([record])
-          record.readonly! if IdentityCache.fetch_read_only_records && IdentityCache.should_use_cache?
+          record.readonly! if IdentityCache.fetch_read_only_records && should_use_cache?
         end
         record
       end
@@ -286,10 +283,7 @@ module IdentityCache
         associations_for_identity_cache = recursively_embedded_associations.map do |child_association, options|
           child_class = reflect_on_association(child_association).try(:klass)
 
-          child_includes = nil
-          if child_class.respond_to?(:cache_fetch_includes, true)
-            child_includes = child_class.send(:cache_fetch_includes)
-          end
+          child_includes = child_class.send(:cache_fetch_includes)
 
           if child_includes.blank?
             child_association
@@ -302,10 +296,12 @@ module IdentityCache
       end
 
       def find_batch(ids)
+        return [] if ids.empty?
+
         @id_column ||= columns.detect {|c| c.name == primary_key}
         ids = ids.map{ |id| connection.type_cast(id, @id_column) }
         records = where(primary_key => ids).includes(cache_fetch_includes).to_a
-        records.each(&:readonly!) if IdentityCache.fetch_read_only_records && IdentityCache.should_use_cache?
+        records.each(&:readonly!) if IdentityCache.fetch_read_only_records && should_use_cache?
         preload_id_embedded_associations(records)
         records_by_id = records.index_by(&:id)
         ids.map{ |id| records_by_id[id] }
@@ -345,6 +341,11 @@ module IdentityCache
       end
 
       def prefetch_one_association(association, records)
+        unless records.first.class.should_use_cache?
+          ActiveRecord::Associations::Preloader.new.preload(records, association)
+          return
+        end
+
         case
         when details = cached_has_manys[association]
           prefetch_embedded_association(records, association, details)
@@ -417,26 +418,22 @@ module IdentityCache
     private
 
     def fetch_recursively_cached_association(ivar_name, association_name) # :nodoc:
-      assoc = if IdentityCache.should_use_cache?
-        ivar_full_name = :"@#{ivar_name}"
+      ivar_full_name = :"@#{ivar_name}"
+      assoc = association(association_name)
 
-        assoc = if instance_variable_defined?(ivar_full_name)
+      if assoc.klass.should_use_cache?
+        if instance_variable_defined?(ivar_full_name)
           instance_variable_get(ivar_full_name)
         else
-          cached_assoc = if IdentityCache.fetch_read_only_records
-            load_and_readonlyify(association_name)
-          else
-            send(association_name)
+          cached_assoc = assoc.load_target
+          if IdentityCache.fetch_read_only_records
+            cached_assoc = readonly_copy(cached_assoc)
           end
           instance_variable_set(ivar_full_name, cached_assoc)
         end
-
-        assoc.is_a?(ActiveRecord::Associations::CollectionAssociation) ? assoc.reader : assoc
       else
-        send(association_name.to_sym)
+        assoc.load_target
       end
-      assoc = assoc.to_ary if assoc.respond_to?(:to_ary)
-      assoc
     end
 
     def expire_primary_index # :nodoc:
@@ -483,13 +480,17 @@ module IdentityCache
       !destroyed? && transaction_changed_attributes.has_key?(pk) && transaction_changed_attributes[pk].nil?
     end
 
-    def load_and_readonlyify(association_name)
-      record_or_records = send(association_name)
+    def readonly_record_copy(record)
+      record = record.clone
+      record.readonly!
+      record
+    end
 
-      if self.class.reflect_on_association(association_name).collection?
-        record_or_records.map { |p| p.dup.tap(&:readonly!) }
-      else
-        record_or_records.dup.tap(&:readonly!) if record_or_records
+    def readonly_copy(record_or_records)
+      if record_or_records.is_a?(Array)
+        record_or_records.map { |record| readonly_record_copy(record) }
+      elsif record_or_records
+        readonly_record_copy(record_or_records)
       end
     end
   end

data/lib/identity_cache/should_use_cache.rb

@@ -0,0 +1,11 @@
+module IdentityCache
+  module ShouldUseCache
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def should_use_cache?
+        IdentityCache.should_use_cache?
+      end
+    end
+  end
+end

data/lib/identity_cache/version.rb

@@ -1,4 +1,4 @@
 module IdentityCache
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
   CACHE_VERSION = 6
 end

data/lib/identity_cache/without_primary_index.rb

@@ -0,0 +1,10 @@
+module IdentityCache
+  module WithoutPrimaryIndex
+    extend ActiveSupport::Concern
+
+    included do |base|
+      base.send(:include, IdentityCache)
+      base.primary_cache_index_enabled = false
+    end
+  end
+end

data/performance/cache_runner.rb

@@ -14,7 +14,10 @@ require File.dirname(__FILE__) + '/../test/helpers/database_connection'
 
 IdentityCache.logger = Logger.new(nil)
 IdentityCache.cache_backend = ActiveSupport::Cache::MemcachedStore.new("localhost:#{$memcached_port}", :support_cas => true)
-ActiveRecord::Base.raise_in_transactional_callbacks = 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
 
 def create_record(id)
   Item.new(id)

data/test/attribute_cache_test.rb

@@ -31,10 +31,10 @@ class AttributeCacheTest < IdentityCache::TestCase
   end
 
   def test_nil_is_stored_in_the_cache_on_cache_misses
-    assert_equal nil, AssociatedRecord.fetch_name_by_id(2)
+    assert_nil AssociatedRecord.fetch_name_by_id(2)
 
     assert_queries(0) do
-      assert_equal nil, AssociatedRecord.fetch_name_by_id(2)
+      assert_nil AssociatedRecord.fetch_name_by_id(2)
     end
   end
 
@@ -63,13 +63,13 @@ class AttributeCacheTest < IdentityCache::TestCase
 
     @record.destroy
 
-    assert_queries(1) { assert_equal nil, AssociatedRecord.fetch_name_by_id(1) }
+    assert_queries(1) { assert_nil AssociatedRecord.fetch_name_by_id(1) }
   end
 
   def test_cached_attribute_values_are_expired_from_the_cache_when_a_new_record_is_saved
     new_id = 2
-    assert_queries(1) { assert_equal nil, AssociatedRecord.fetch_name_by_id(new_id) }
-    assert_queries(0) { assert_equal nil, AssociatedRecord.fetch_name_by_id(new_id) }
+    assert_queries(1) { assert_nil AssociatedRecord.fetch_name_by_id(new_id) }
+    assert_queries(0) { assert_nil AssociatedRecord.fetch_name_by_id(new_id) }
 
     @parent.associated_records.create(:name => 'bar')
 
@@ -87,7 +87,7 @@ class AttributeCacheTest < IdentityCache::TestCase
   end
 
   def test_previously_stored_cached_nils_are_busted_by_new_record_saves
-    assert_equal nil, AssociatedRecord.fetch_name_by_id(2)
+    assert_nil AssociatedRecord.fetch_name_by_id(2)
     AssociatedRecord.create(:name => "Jim")
     assert_equal "Jim", AssociatedRecord.fetch_name_by_id(2)
   end
@@ -97,4 +97,14 @@ class AttributeCacheTest < IdentityCache::TestCase
       StiRecordTypeA.cache_attribute :name
     end
   end
+
+  def test_cache_attribute_respects_should_use_cache
+    AssociatedRecord.stubs(:should_use_cache?).returns(false)
+
+    assert_queries(1) do
+      assert_memcache_operations(0) do
+        AssociatedRecord.fetch_name_by_id(@record.id)
+      end
+    end
+  end
 end

data/test/cache_fetch_includes_test.rb

@@ -33,6 +33,7 @@ class CacheFetchIncludesTest < IdentityCache::TestCase
 
   def test_multiple_cached_associations_and_child_associations_are_included_in_includes
     Item.send(:cache_has_many, :associated_records, :embed => true)
+    PolymorphicRecord.send(:include, IdentityCache::WithoutPrimaryIndex)
     Item.send(:cache_has_many, :polymorphic_records, {:inverse_name => :owner, :embed => true})
     Item.send(:cache_has_one, :associated, :embed => true)
     AssociatedRecord.send(:cache_has_many, :deeply_associated_records, :embed => true)

data/test/deeply_nested_associated_record_test.rb

@@ -3,6 +3,7 @@ require "test_helper"
 class DeeplyNestedAssociatedRecordHasOneTest < IdentityCache::TestCase
   def test_deeply_nested_models_can_cache_has_one_associations
     assert_nothing_raised do
+      PolymorphicRecord.include(IdentityCache::WithoutPrimaryIndex)
       Deeply::Nested::AssociatedRecord.has_one :polymorphic_record, as: 'owner'
       Deeply::Nested::AssociatedRecord.cache_has_one :polymorphic_record, inverse_name: :owner
     end

data/test/denormalized_has_many_test.rb

@@ -3,6 +3,7 @@ require "test_helper"
 class DenormalizedHasManyTest < IdentityCache::TestCase
   def setup
     super
+    PolymorphicRecord.include(IdentityCache::WithoutPrimaryIndex)
     Item.cache_has_many :associated_records, :embed => true
 
     @record = Item.new(:title => 'foo')
@@ -21,7 +22,7 @@ class DenormalizedHasManyTest < IdentityCache::TestCase
     expected = @record.associated_records
     record_from_db = Item.find(@record.id)
 
-    Item.any_instance.expects(:associated_records).returns(expected)
+    Item.any_instance.expects(:association).with(:associated_records).returns(expected)
 
     assert_equal @record, record_from_db
     assert_equal expected, record_from_db.fetch_associated_records
@@ -42,7 +43,11 @@ class DenormalizedHasManyTest < IdentityCache::TestCase
     assert_equal @record, record_from_cache_hit
 
     expected = @record.associated_records
-    Item.any_instance.expects(:associated_records).never
+
+    assoc = mock()
+    assoc.expects(:klass).returns(Item)
+    Item.any_instance.expects(:association).with(:associated_records).returns(assoc).once
+
     assert_equal expected, record_from_cache_hit.fetch_associated_records
   end
 
@@ -167,6 +172,17 @@ class DenormalizedHasManyTest < IdentityCache::TestCase
     end
   end
 
+  def test_respect_should_use_cache_from_embedded_records
+    Item.fetch(@record.id)
+    AssociatedRecord.stubs(:should_use_cache?).returns(false)
+
+    assert_memcache_operations(1) do
+      assert_queries(1) do
+        Item.fetch(@record.id).fetch_associated_records
+      end
+    end
+  end
+
   class CheckAssociationTest < IdentityCache::TestCase
     def test_unsupported_through_assocation
       assert_raises IdentityCache::UnsupportedAssociationError, "caching through associations isn't supported" do

data/test/denormalized_has_one_test.rb

@@ -3,6 +3,7 @@ require "test_helper"
 class DenormalizedHasOneTest < IdentityCache::TestCase
   def setup
     super
+    PolymorphicRecord.include(IdentityCache::WithoutPrimaryIndex)
     Item.cache_has_one :associated
     Item.cache_index :title, :unique => true
     @record = Item.new(:title => 'foo')

data/test/fetch_multi_test.rb

@@ -265,6 +265,16 @@ class FetchMultiTest < IdentityCache::TestCase
     end
   end
 
+  def test_fetch_multi_with_no_keys_does_not_query_when_cache_is_disabled
+    Item.stubs(:should_use_cache?).returns(false)
+
+    assert_queries(0) do
+      assert_memcache_operations(0) do
+        Item.fetch_multi
+      end
+    end
+  end
+
   private
 
   def populate_only_fred

data/test/fetch_test.rb

@@ -17,7 +17,7 @@ class FetchTest < IdentityCache::TestCase
   end
 
   def test_fetch_with_garbage_input
-    assert_equal nil, Item.fetch_by_id('garbage')
+    assert_nil Item.fetch_by_id('garbage')
   end
 
   def test_fetch_cache_hit
@@ -110,7 +110,7 @@ class FetchTest < IdentityCache::TestCase
     nonexistent_record_id = 10
     fetcher.expects(:add).with(@blob_key + '0', IdentityCache::CACHED_NIL)
 
-    assert_equal nil, Item.fetch_by_id(nonexistent_record_id)
+    assert_nil Item.fetch_by_id(nonexistent_record_id)
   end
 
   def test_fetch_not_found_should_raise
@@ -123,7 +123,7 @@ class FetchTest < IdentityCache::TestCase
   def test_cached_nil_expiry_on_record_creation
     key = @record.primary_cache_index_key
 
-    assert_equal nil, Item.fetch_by_id(@record.id)
+    assert_nil Item.fetch_by_id(@record.id)
     assert_equal IdentityCache::CACHED_NIL, backend.read(key)
 
     @record.save!
@@ -162,10 +162,10 @@ class FetchTest < IdentityCache::TestCase
     Item.connection.expects(:exec_query).once.returns(ActiveRecord::Result.new([], []))
     add = Spy.on(fetcher, :add).and_call_through
     fetch = Spy.on(fetcher, :fetch).and_call_through
-    assert_equal nil, Item.fetch_by_title('bob') # exec_query => nil
+    assert_nil Item.fetch_by_title('bob') # exec_query => nil
 
-    assert_equal nil, Item.fetch_by_title('bob') # returns cached nil
-    assert_equal nil, Item.fetch_by_title('bob') # returns cached nil
+    assert_nil Item.fetch_by_title('bob') # returns cached nil
+    assert_nil Item.fetch_by_title('bob') # returns cached nil
 
     assert add.has_been_called_with?(@index_key, IdentityCache::CACHED_NIL)
     assert_equal 3, fetch.calls.length
@@ -244,4 +244,15 @@ class FetchTest < IdentityCache::TestCase
       end
     end
   end
+
+  def test_respects_should_use_cache_on_record
+    @record.save
+    Item.stubs(:should_use_cache?).returns(false)
+
+    assert_memcache_operations(0) do
+      assert_queries(1) do
+        Item.fetch_by_id(@record.id)
+      end
+    end
+  end
 end

data/test/helpers/database_connection.rb

@@ -18,7 +18,15 @@ module DatabaseConnection
 
   def self.drop_tables
     TABLES.keys.each do |table|
-      ActiveRecord::Base.connection.drop_table(table) if ActiveRecord::Base.connection.table_exists?(table)
+      ActiveRecord::Base.connection.drop_table(table) if table_exists?(table)
+    end
+  end
+
+  def self.table_exists?(table)
+    if ActiveRecord::Base.connection.respond_to?(:data_source_exists?)
+      ActiveRecord::Base.connection.data_source_exists?(table)
+    else
+      ActiveRecord::Base.connection.table_exists?(table)
     end
   end
 

data/test/identity_cache_test.rb

@@ -2,14 +2,17 @@ require "test_helper"
 
 class IdentityCacheTest < IdentityCache::TestCase
 
-  class BadModel < ActiveRecord::Base
+  class BadModelBase < ActiveRecord::Base
+    include IdentityCache
+  end
+
+  class BadModel < BadModelBase
   end
 
   def test_identity_cache_raises_if_loaded_twice
     assert_raises(IdentityCache::AlreadyIncludedError) do
       BadModel.class_eval do
         include IdentityCache
-        include IdentityCache
       end
     end
   end

data/test/index_cache_test.rb

@@ -25,12 +25,12 @@ class IndexCacheTest < IdentityCache::TestCase
       .with(regexp_matches(/ LIMIT 1\Z/i), any_parameters)
       .returns(ActiveRecord::Result.new([], []))
 
-    assert_equal nil, Item.fetch_by_title_and_id('title', '2')
+    assert_nil Item.fetch_by_title_and_id('title', '2')
   end
 
   def test_unique_index_caches_nil
     Item.cache_index :title, :unique => true
-    assert_equal nil, Item.fetch_by_title('bob')
+    assert_nil Item.fetch_by_title('bob')
     assert_equal IdentityCache::CACHED_NIL, backend.read(cache_key(unique: true))
   end
 

data/test/memoized_cache_proxy_test.rb

@@ -30,7 +30,7 @@ class MemoizedCacheProxyTest < IdentityCache::TestCase
 
     IdentityCache.cache.with_memoization do
       IdentityCache.cache.write('foo', nil)
-      assert_equal nil, IdentityCache.cache.fetch('foo')
+      assert_nil IdentityCache.cache.fetch('foo')
       IdentityCache.cache.write('bar', false)
       assert_equal false, IdentityCache.cache.fetch('bar')
     end

data/test/normalized_belongs_to_test.rb

@@ -43,8 +43,8 @@ class NormalizedBelongsToTest < IdentityCache::TestCase
 
   def test_fetching_the_association_should_cache_nil_and_not_raise_if_the_record_cant_be_found
     Item.expects(:fetch_by_id).with(@parent_record.id).returns(nil)
-    assert_equal nil, @record.fetch_item # miss
-    assert_equal nil, @record.fetch_item # hit
+    assert_nil @record.fetch_item # miss
+    assert_nil @record.fetch_item # hit
   end
 
   def test_cache_belongs_to_on_derived_model_raises
@@ -76,6 +76,15 @@ class NormalizedBelongsToTest < IdentityCache::TestCase
     end
   end
 
+  def test_db_returned_record_should_never_be_readonly
+    IdentityCache.with_fetch_read_only_records do
+      uncached_record = @record.item
+      refute uncached_record.readonly?
+      @record.fetch_item
+      refute uncached_record.readonly?
+    end
+  end
+
   def test_returned_record_with_open_transactions_should_not_be_readonly
     IdentityCache.with_fetch_read_only_records do
       Item.transaction do
@@ -84,4 +93,15 @@ class NormalizedBelongsToTest < IdentityCache::TestCase
       end
     end
   end
+
+  def test_respects_should_use_cache_on_parent
+    @record.reload
+    @parent_record.class.stubs(:should_use_cache?).returns(false)
+
+    assert_queries(1) do
+      assert_memcache_operations(0) do
+        @record.fetch_item
+      end
+    end
+  end
 end

data/test/normalized_has_many_test.rb

@@ -217,4 +217,15 @@ class NormalizedHasManyTest < IdentityCache::TestCase
       assert record_from_cache_miss.fetch_associated_records.all?(&:readonly?)
     end
   end
+
+  def test_respects_should_use_cache_on_association
+    @record.reload
+    AssociatedRecord.stubs(:should_use_cache?).returns(false)
+
+    assert_queries(1) do
+      assert_memcache_operations(0) do
+        @record.fetch_associated_records
+      end
+    end
+  end
 end

data/test/prefetch_associations_test.rb

@@ -96,7 +96,7 @@ class PrefetchAssociationsTest < IdentityCache::TestCase
   def test_prefetch_associations_with_nil_cached_belongs_to
     Item.send(:cache_belongs_to, :item)
     @bob.update_attributes!(item_id: 1234)
-    assert_equal nil, @bob.fetch_item
+    assert_nil @bob.fetch_item
 
     assert_no_queries do
       assert_memcache_operations(0) do
@@ -188,6 +188,7 @@ class PrefetchAssociationsTest < IdentityCache::TestCase
   end
 
   def test_fetch_multi_batch_fetches_first_level_associations_who_dont_include_identity_cache
+    NotCachedRecord.include(IdentityCache::WithoutPrimaryIndex)
     Item.send(:cache_has_many, :not_cached_records, :embed => true)
 
     @bob_child  = @bob.not_cached_records.create!(:name => "bob child")

data/test/readonly_test.rb

@@ -35,7 +35,7 @@ class ReadonlyTest < IdentityCache::TestCase
   def test_clear_should_update_cache
     backend.write(@key, @value)
     fetcher.clear
-    assert_equal nil, backend.read(@key)
+    assert_nil backend.read(@key)
   end
 
   def test_fetch_should_not_update_cache

data/test/schema_change_test.rb

@@ -75,6 +75,7 @@ class SchemaChangeTest < IdentityCache::TestCase
   def test_schema_changes_on_new_cached_child_association
     record = Item.fetch(@record.id)
 
+    PolymorphicRecord.include(IdentityCache::WithoutPrimaryIndex)
     Item.cache_has_many :polymorphic_records, :inverse_name => :owner, :embed => true
     read_new_schema
 
@@ -92,6 +93,7 @@ class SchemaChangeTest < IdentityCache::TestCase
     teardown_models
     setup_models
 
+    PolymorphicRecord.include(IdentityCache::WithoutPrimaryIndex)
     Item.cache_has_many :polymorphic_records, :inverse_name => :owner, :embed => true
     read_new_schema
 

data/test/test_helper.rb

@@ -14,15 +14,15 @@ DatabaseConnection.setup
 ActiveSupport::Cache::Store.instrument = true if ActiveSupport.version < Gem::Version.new("4.2.0")
 
 # This patches AR::MemcacheStore to notify AS::Notifications upon read_multis like the rest of rails does
-class ActiveSupport::Cache::MemcachedStore
-  def read_multi_with_instrumentation(*args, &block)
-    instrument("read_multi", "MULTI", {:keys => args}) do
-      read_multi_without_instrumentation(*args, &block)
+module MemcachedStoreInstrumentation
+  def read_multi(*args, &block)
+    instrument('read_multi', 'MULTI', keys: args) do
+      super(*args, &block)
     end
   end
-
-  alias_method_chain :read_multi, :instrumentation
 end
+ActiveSupport::Cache::MemcachedStore.prepend(MemcachedStoreInstrumentation)
+
 
 MiniTest::Test = MiniTest::Unit::TestCase unless defined?(MiniTest::Test)
 class IdentityCache::TestCase < Minitest::Test
@@ -30,7 +30,7 @@ class IdentityCache::TestCase < Minitest::Test
   attr_reader :backend
 
   def setup
-    if ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks=)
+    if ActiveRecord.gem_version < Gem::Version.new('5') && ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks=)
       ActiveRecord::Base.raise_in_transactional_callbacks = true
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: identity_cache
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Camilo Lopez
@@ -64,14 +64,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.12.6
+        version: 1.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.12.6
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -214,7 +214,9 @@ files:
 - lib/identity_cache/memoized_cache_proxy.rb
 - lib/identity_cache/parent_model_expiration.rb
 - lib/identity_cache/query_api.rb
+- lib/identity_cache/should_use_cache.rb
 - lib/identity_cache/version.rb
+- lib/identity_cache/without_primary_index.rb
 - performance/cache_runner.rb
 - performance/cpu.rb
 - performance/externals.rb
@@ -260,7 +262,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="