identity_cache 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: abed676c785bc468fee7349b8e28af469499b78b
-  data.tar.gz: e64ed12cef1b57634416a2d4183313fae2a5f491
+  metadata.gz: 8b3399599b1784b0df560313cc902e20e7cd86fd
+  data.tar.gz: 4a45bfa103d6095837bf2226a1ccd505219001fb
 SHA512:
-  metadata.gz: cd1e569f94285089975e400da50e183731115c186b538ad822edf0bcb6bdf50c6b152a3b159d4196bb5749cd793f3745b19d744821e96479ba5106a1703d3785
-  data.tar.gz: 45358caea4c1d9ef27a682736cf180cbe982a9ce48946b842c6f788d0cb31c47658ed478f2c056e8e736b71e78dfa9af08abdbc5989e99ef12a96450a0197a3e
+  metadata.gz: 50b692df952ca33119c152a4aaaa9bf0e0360c2a56005bd0711a707ea516031a12ceb7f8e9e9599b52f0ba5ce1568c33585b7598bdc9a6a1da018b7b42eec0a3
+  data.tar.gz: e9519a582f37d3e029a43046157139ba37c3a897fda507febe592e1219a2d84968c3c10b68780a4c4397eeec9102cfd3ed4f69f41756818e7532b17ce4aa4d1e

data/.travis.yml

@@ -1,13 +1,10 @@
 language: ruby
 
 rvm:
-  - 1.9.3
-  - 2.0.0
   - 2.1
   - 2.2
 
 gemfile:
-  - Gemfile.rails32
   - Gemfile.rails40
   - Gemfile.rails41
   - Gemfile.rails42

data/identity_cache.gemspec

@@ -31,6 +31,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) >= Gem::Version.new("2.1.0")
+    gem.add_development_dependency('stackprof') if Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new("2.1.0")
   end
 end

data/lib/identity_cache/configuration_dsl.rb

@@ -278,23 +278,17 @@ module IdentityCache
 
       def add_parent_expiry_hook(options)
         child_class = options[:association_class]
-        child_association = child_class.reflect_on_association(options[:inverse_name])
-        raise InverseAssociationError unless child_association
-        foreign_key = child_association.association_foreign_key
+        raise InverseAssociationError unless child_class.reflect_on_association(options[:inverse_name])
 
         child_class.send(:include, ArTransactionChanges) unless child_class.include?(ArTransactionChanges)
         child_class.send(:include, ParentModelExpiration) unless child_class.include?(ParentModelExpiration)
 
-        after_action_name = "expire_parent_cache_#{self.name.underscore}"
+        child_class.parent_expiration_entries[options[:inverse_name]] << [self, options[:only_on_foreign_key_change]]
 
         child_class.class_eval(<<-CODE, __FILE__, __LINE__ + 1)
-        
-          after_commit :#{after_action_name}
-          after_touch  :#{after_action_name}
-          add_parent_expiration_entry :#{after_action_name}
-
-          def #{after_action_name}
-            expire_parent_cache_on_changes(:#{options[:inverse_name]}, '#{foreign_key}', #{self.name}, #{options[:only_on_foreign_key_change]})
+          after_commit :expire_parent_caches
+          if Gem::Version.new(ActiveRecord::VERSION::STRING) < Gem::Version.new("4.0.4")
+            after_touch :expire_parent_caches
           end
         CODE
       end

data/lib/identity_cache/parent_model_expiration.rb

@@ -4,44 +4,61 @@ module IdentityCache
 
     included do |base|
       base.class_attribute :parent_expiration_entries
-      base.parent_expiration_entries = Set.new
+      base.parent_expiration_entries = Hash.new{ |hash, key| hash[key] = [] }
     end
-  
-    module ClassMethods
-      private
 
-      def add_parent_expiration_entry(after_action_name)
-        parent_expiration_entries << after_action_name
-      end
-    end
-    
     def expire_parent_caches
-      self.class.parent_expiration_entries.each do |parent_expiration_entry|
-        send(parent_expiration_entry)
+      parents_to_expire = {}
+      add_parents_to_cache_expiry_set(parents_to_expire)
+      parents_to_expire.each_value do |parent|
+        parent.send(:expire_primary_index)
       end
     end
 
-    def expire_parent_cache_on_changes(parent_name, foreign_key, parent_class, only_on_foreign_key_change)
-      new_parent = send(parent_name)
+    def add_parents_to_cache_expiry_set(parents_to_expire)
+      self.class.parent_expiration_entries.each do |association_name, cached_associations|
+        parents_to_expire_on_changes(parents_to_expire, association_name, cached_associations)
+      end
+    end
 
-      if new_parent && new_parent.respond_to?(:expire_primary_index, true)
-        if should_expire_identity_cache_parent?(foreign_key, only_on_foreign_key_change)
-          new_parent.send(:expire_primary_index)
-          new_parent.send(:expire_parent_caches) if new_parent.respond_to?(:expire_parent_caches, true)
-        end
+    def add_record_to_cache_expiry_set(parents_to_expire, record)
+      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)
       end
+    end
 
+    def parents_to_expire_on_changes(parents_to_expire, association_name, cached_associations)
+      parent_association = self.class.reflect_on_association(association_name)
+      foreign_key = parent_association.association_foreign_key
+
+      new_parent = send(association_name)
+
+      old_parent = nil
       if transaction_changed_attributes[foreign_key].present?
         begin
-          old_parent = parent_class.find(transaction_changed_attributes[foreign_key])
-          old_parent.send(:expire_primary_index) if old_parent.respond_to?(:expire_primary_index, true)
-          old_parent.send(:expire_parent_caches)  if old_parent.respond_to?(:expire_parent_caches, true)
+          if parent_association.options[:polymorhpic]
+            klass = transaction_changed_attributes[parent_association.association_foreign_key].try(:constantize)
+            klass ||= new_parent.class
+          else
+            klass = parent_association.klass
+          end
+          old_parent = klass.find(transaction_changed_attributes[foreign_key])
         rescue ActiveRecord::RecordNotFound => e
           # suppress errors finding the old parent if its been destroyed since it will have expired itself in that case
         end
       end
 
-      true
+      cached_associations.each do |parent_class, only_on_foreign_key_change|
+        if new_parent && new_parent.is_a?(parent_class) && should_expire_identity_cache_parent?(foreign_key, only_on_foreign_key_change)
+          add_record_to_cache_expiry_set(parents_to_expire, new_parent)
+        end
+
+        if old_parent && old_parent.is_a?(parent_class)
+          add_record_to_cache_expiry_set(parents_to_expire, old_parent)
+        end
+      end
     end
 
     def should_expire_identity_cache_parent?(foreign_key, only_on_foreign_key_change)

data/lib/identity_cache/query_api.rb

@@ -80,7 +80,13 @@ module IdentityCache
       def record_from_coder(coder) #:nodoc:
         if coder.present? && coder.has_key?(:class)
           record = coder[:class].allocate
-          unless coder[:class].serialized_attributes.empty?
+          empty_serialized_attrs =
+            if defined?(ActiveRecord::Type::Serialized)
+              coder[:class].columns.find { |t| t.cast_type.is_a?(ActiveRecord::Type::Serialized) }.nil?
+            else
+              coder[:class].serialized_attributes.empty?
+            end
+          unless empty_serialized_attrs
             coder = coder.dup
             coder['attributes'] = coder['attributes'].dup
           end

data/lib/identity_cache/version.rb

@@ -1,4 +1,4 @@
 module IdentityCache
-  VERSION = "0.2.4"
+  VERSION = "0.2.5"
   CACHE_VERSION = 5
 end

data/test/cache_invalidation_test.rb

@@ -120,4 +120,19 @@ class CacheInvalidationTest < IdentityCache::TestCase
       refute IdentityCache.cache.fetch(expected_key) { nil }
     end
   end
+
+  def test_dedup_cache_invalidation_of_records_embedded_twice_through_different_associations
+    Item.cache_has_many :associated_records, embed: true
+    AssociatedRecord.cache_has_many :deeply_associated_records, embed: true
+    Item.cache_has_many :deeply_associated_records, embed: true
+
+    deeply_associated_record = DeeplyAssociatedRecord.new(name: 'deep', item_id: @record.id)
+    @record.associated_records[0].deeply_associated_records << deeply_associated_record
+    deeply_associated_record.reload
+
+    Item.any_instance.expects(:expire_primary_index).once
+
+    deeply_associated_record.name = "deep2"
+    deeply_associated_record.save!
+  end
 end

data/test/deeply_nested_associated_record_test.rb

@@ -0,0 +1,17 @@
+require "test_helper"
+
+class DeeplyNestedAssociatedRecordHasOneTest < IdentityCache::TestCase
+  def test_deeply_nested_models_can_cache_has_one_associations
+    assert_nothing_raised do
+      Deeply::Nested::AssociatedRecord.has_one :polymorphic_record, as: 'owner'
+      Deeply::Nested::AssociatedRecord.cache_has_one :polymorphic_record, inverse_name: :owner
+    end
+  end
+
+  def test_deeply_nested_models_can_cache_has_many_associations
+    assert_nothing_raised do
+      Deeply::Nested::AssociatedRecord.has_many :polymorphic_records, as: 'owner'
+      Deeply::Nested::AssociatedRecord.cache_has_many :polymorphic_records, inverse_name: :owner
+    end
+  end
+end

data/test/helpers/active_record_objects.rb

@@ -20,6 +20,7 @@ module ActiveRecordObjects
   def setup_models(base = ActiveRecord::Base)
     Object.send :const_set, 'DeeplyAssociatedRecord', Class.new(base) {
       include IdentityCache
+      belongs_to :item
       belongs_to :associated_record
       default_scope { order('name DESC') }
     }
@@ -47,10 +48,17 @@ module ActiveRecordObjects
       belongs_to :owner, :polymorphic => true
     }
 
+    Object.send :const_set, 'Deeply', Module.new
+    Deeply.send :const_set, 'Nested', Module.new
+    Deeply::Nested.send :const_set, 'AssociatedRecord', Class.new(base) {
+      include IdentityCache
+    }
+
     Object.send :const_set, 'Item', Class.new(base) {
       include IdentityCache
       belongs_to :item
       has_many :associated_records, inverse_of: :item
+      has_many :deeply_associated_records, inverse_of: :item
       has_many :normalized_associated_records
       has_many :not_cached_records
       has_many :polymorphic_records, :as => 'owner'
@@ -81,5 +89,8 @@ module ActiveRecordObjects
     Object.send :remove_const, 'Item'
     Object.send :remove_const, 'ItemTwo'
     Object.send :remove_const, 'KeyedRecord'
+    Deeply::Nested.send :remove_const, 'AssociatedRecord'
+    Deeply.send :remove_const, 'Nested'
+    Object.send :remove_const, 'Deeply'
   end
 end

data/test/helpers/database_connection.rb

@@ -31,13 +31,13 @@ module DatabaseConnection
   end
 
   TABLES = {
-    :polymorphic_records           => [[:string, :owner_type], [:integer, :owner_id], [:timestamps]],
-    :deeply_associated_records     => [[:string, :name], [:integer, :associated_record_id], [:timestamps]],
+    :polymorphic_records           => [[:string, :owner_type], [:integer, :owner_id], [:timestamps, null: true]],
+    :deeply_associated_records     => [[:string, :name], [:integer, :associated_record_id], [:integer, :item_id], [:timestamps, null: true]],
     :associated_records            => [[:string, :name], [:integer, :item_id], [:integer, :item_two_id]],
-    :normalized_associated_records => [[:string, :name], [:integer, :item_id], [:timestamps]],
-    :not_cached_records            => [[:string, :name], [:integer, :item_id], [:timestamps]],
-    :items                         => [[:integer, :item_id], [:string, :title], [:timestamps]],
-    :items2                        => [[:integer, :item_id], [:string, :title], [:timestamps]],
+    :normalized_associated_records => [[:string, :name], [:integer, :item_id], [:timestamps, null: true]],
+    :not_cached_records            => [[:string, :name], [:integer, :item_id], [:timestamps, null: true]],
+    :items                         => [[:integer, :item_id], [:string, :title], [:timestamps, null: true]],
+    :items2                        => [[:integer, :item_id], [:string, :title], [:timestamps, null: true]],
     :keyed_records                 => [[:string, :value], :primary_key => "hashed_key"],
   }
 

data/test/test_helper.rb

@@ -24,11 +24,16 @@ class ActiveSupport::Cache::MemcachedStore
   alias_method_chain :read_multi, :instrumentation
 end
 
-class IdentityCache::TestCase < MiniTest::Unit::TestCase
+MiniTest::Test = MiniTest::Unit::TestCase unless defined?(MiniTest::Test)
+class IdentityCache::TestCase < Minitest::Test
   include ActiveRecordObjects
   attr_reader :backend
 
   def setup
+    if ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks=)
+      ActiveRecord::Base.raise_in_transactional_callbacks = true
+    end
+
     DatabaseConnection.drop_tables
     DatabaseConnection.create_tables
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: identity_cache
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Camilo Lopez
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-13 00:00:00.000000000 Z
+date: 2015-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ar_transaction_changes
@@ -226,6 +226,7 @@ files:
 - test/cache_fetch_includes_test.rb
 - test/cache_hash_test.rb
 - test/cache_invalidation_test.rb
+- test/deeply_nested_associated_record_test.rb
 - test/denormalized_has_many_test.rb
 - test/denormalized_has_one_test.rb
 - test/fetch_multi_test.rb
@@ -267,7 +268,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.3
 signing_key: 
 specification_version: 4
 summary: IdentityCache lets you specify how you want to cache your model objects,
@@ -279,6 +280,7 @@ test_files:
 - test/cache_fetch_includes_test.rb
 - test/cache_hash_test.rb
 - test/cache_invalidation_test.rb
+- test/deeply_nested_associated_record_test.rb
 - test/denormalized_has_many_test.rb
 - test/denormalized_has_one_test.rb
 - test/fetch_multi_test.rb