identity_cache 0.2.5 → 0.3.0

data/lib/identity_cache/parent_model_expiration.rb

@@ -38,9 +38,10 @@ module IdentityCache
       old_parent = nil
       if transaction_changed_attributes[foreign_key].present?
         begin
-          if parent_association.options[:polymorhpic]
-            klass = transaction_changed_attributes[parent_association.association_foreign_key].try(:constantize)
-            klass ||= new_parent.class
+          if parent_association.polymorphic?
+            parent_class_name = transaction_changed_attributes[parent_association.foreign_type]
+            parent_class_name ||= read_attribute(parent_association.foreign_type)
+            klass = parent_class_name.try!(:safe_constantize)
           else
             klass = parent_association.klass
           end

data/lib/identity_cache/query_api.rb

@@ -4,9 +4,6 @@ module IdentityCache
 
     included do |base|
       base.after_commit :expire_cache
-      if Gem::Version.new(ActiveRecord::VERSION::STRING) < Gem::Version.new("4.0.4")
-        base.after_touch :expire_cache
-      end
     end
 
     module ClassMethods
@@ -19,11 +16,12 @@ module IdentityCache
 
       # Default fetcher added to the model on inclusion, it behaves like
       # ActiveRecord::Base.where(id: id).first
-      def fetch_by_id(id)
-        return unless id
+      def fetch_by_id(id, options={})
+        ensure_base_model
+        raise_if_scoped
         raise NotImplementedError, "fetching needs the primary index enabled" unless primary_cache_index_enabled
-        if IdentityCache.should_use_cache?
-
+        return unless id
+        record = if IdentityCache.should_use_cache?
           require_if_necessary do
             object = nil
             coder = IdentityCache.fetch(rails_cache_key(id)){ coder_from_record(object = resolve_cache_miss(id)) }
@@ -31,22 +29,25 @@ module IdentityCache
             IdentityCache.logger.error "[IDC id mismatch] fetch_by_id_requested=#{id} fetch_by_id_got=#{object.id} for #{object.inspect[(0..100)]} " if object && object.id != id.to_i
             object
           end
-
         else
-          self.reorder(nil).where(primary_key => id).first
+          resolve_cache_miss(id)
         end
+        prefetch_associations(options[:includes], [record]) if record && options[:includes]
+        record
       end
 
       # Default fetcher added to the model on inclusion, it behaves like
       # ActiveRecord::Base.find, will raise ActiveRecord::RecordNotFound exception
       # if id is not in the cache or the db.
-      def fetch(id)
-        fetch_by_id(id) or raise(ActiveRecord::RecordNotFound, "Couldn't find #{self.name} with ID=#{id}")
+      def fetch(id, options={})
+        fetch_by_id(id, options) or raise(ActiveRecord::RecordNotFound, "Couldn't find #{self.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)
+        ensure_base_model
+        raise_if_scoped
         raise NotImplementedError, "fetching needs the primary index enabled" unless primary_cache_index_enabled
         options = ids.extract_options!
         ids.flatten!(1)
@@ -59,9 +60,7 @@ module IdentityCache
             coders_by_key = IdentityCache.fetch_multi(cache_keys) do |unresolved_keys|
               ids = unresolved_keys.map {|key| key_to_id_map[key] }
               records = find_batch(ids)
-              found_records = records.compact
-              found_records.each{ |record| record.send(:populate_association_caches) }
-              key_to_record_map = found_records.index_by{ |record| rails_cache_key(record.id) }
+              key_to_record_map = records.compact.index_by{ |record| rails_cache_key(record.id) }
               records.map {|record| coder_from_record(record) }
             end
 
@@ -77,23 +76,19 @@ module IdentityCache
 
       private
 
+      def raise_if_scoped
+        if current_scope
+          raise UnsupportedScopeError, "IdentityCache doesn't support rails scopes"
+        end
+      end
+
       def record_from_coder(coder) #:nodoc:
-        if coder.present? && coder.has_key?(:class)
-          record = coder[:class].allocate
-          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
-          record.init_with(coder)
+        if coder
+          klass = coder[:class]
+          record = klass.instantiate(coder[:attributes].dup)
 
           coder[:associations].each {|name, value| set_embedded_association(record, name, value) } if coder.has_key?(:associations)
-          coder[:normalized_has_many].each {|name, ids| record.instance_variable_set(:"@#{record.class.cached_has_manys[name][:ids_variable_name]}", ids) } if coder.has_key?(:normalized_has_many)
+          coder[:association_ids].each {|name, ids| record.instance_variable_set(:"@#{record.class.cached_has_manys[name][:ids_variable_name]}", ids) } if coder.has_key?(:association_ids)
           record
         end
       end
@@ -114,10 +109,8 @@ module IdentityCache
       end
 
       def get_embedded_association(record, association, options) #:nodoc:
-        embedded_variable = record.instance_variable_get(:"@#{options[:records_variable_name]}")
-        if IdentityCache.unmap_cached_nil_for(embedded_variable).nil?
-          nil
-        elsif record.class.reflect_on_association(association).collection?
+        embedded_variable = record.public_send(options.fetch(:cached_accessor_name))
+        if record.class.reflect_on_association(association).collection?
           embedded_variable.map {|e| coder_from_record(e) }
         else
           coder_from_record(embedded_variable)
@@ -126,8 +119,10 @@ module IdentityCache
 
       def coder_from_record(record) #:nodoc:
         unless record.nil?
-          coder = {:class => record.class }
-          record.encode_with(coder)
+          coder = {
+            attributes: record.attributes_before_type_cast,
+            class: record.class,
+          }
           add_cached_associations_to_coder(record, coder)
           coder
         end
@@ -142,7 +137,7 @@ module IdentityCache
             end
           end
           if (cached_has_manys = klass.cached_has_manys).present?
-            coder[:normalized_has_many] = cached_has_manys.each_with_object({}) do |(name, options), hash|
+            coder[:association_ids] = cached_has_manys.each_with_object({}) do |(name, options), hash|
               hash[name] = record.instance_variable_get(:"@#{options[:ids_variable_name]}") unless options[:embed] == true
             end
           end
@@ -168,9 +163,43 @@ module IdentityCache
       end
 
       def resolve_cache_miss(id)
-        object = self.includes(cache_fetch_includes).reorder(nil).where(primary_key => id).try(:first)
-        object.send(:populate_association_caches) if object
-        object
+        record = self.includes(cache_fetch_includes).reorder(nil).where(primary_key => id).first
+        preload_id_embedded_associations([record]) if record
+        record
+      end
+
+      def preload_id_embedded_associations(records)
+        return if records.empty?
+        each_id_embedded_association do |options|
+          reflection = options.fetch(:association_reflection)
+          child_model = reflection.klass
+          scope = child_model.all
+          scope = scope.instance_exec(nil, &reflection.scope) if reflection.scope
+
+          pairs = scope.where(reflection.foreign_key => records.map(&:id)).pluck(reflection.foreign_key, reflection.active_record_primary_key)
+          ids_by_parent = Hash.new{ |hash, key| hash[key] = [] }
+          pairs.each do |parent_id, child_id|
+            ids_by_parent[parent_id] << child_id
+          end
+
+          records.each do |parent|
+            child_ids = ids_by_parent[parent.id]
+            parent.instance_variable_set(:"@#{options.fetch(:ids_variable_name)}", child_ids)
+          end
+        end
+        recursively_embedded_associations.each_value do |options|
+          child_model = options.fetch(:association_reflection).klass
+          if child_model.include?(IdentityCache)
+            child_records = records.flat_map(&options.fetch(:cached_accessor_name).to_sym).compact
+            child_model.send(:preload_id_embedded_associations, child_records)
+          end
+        end
+      end
+
+      def each_id_embedded_association
+        cached_has_manys.each_value do |options|
+          yield options if options.fetch(:embed) == :ids
+        end
       end
 
       def recursively_embedded_associations
@@ -212,6 +241,7 @@ module IdentityCache
         @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
+        preload_id_embedded_associations(records)
         records_by_id = records.index_by(&:id)
         ids.map{ |id| records_by_id[id] }
       end
@@ -234,7 +264,7 @@ module IdentityCache
               end
 
               parent_record_to_child_records = Hash.new { |h, k| h[k] = [] }
-              child_records = details[:association_class].fetch_multi(*ids_to_parent_record.keys)
+              child_records = details[:association_reflection].klass.fetch_multi(*ids_to_parent_record.keys)
               child_records.each do |child_record|
                 parent_record = ids_to_parent_record[child_record.id]
                 parent_record_to_child_records[parent_record] << child_record
@@ -251,11 +281,16 @@ module IdentityCache
             if details[:embed] == true
               raise ArgumentError.new("Embedded belongs_to associations do not support prefetching yet.")
             else
+              reflection = details[:association_reflection]
+              if reflection.polymorphic?
+                raise ArgumentError.new("Polymorphic belongs_to associations do not support prefetching yet.")
+              end
+
               ids_to_child_record = records.each_with_object({}) do |child_record, hash|
-                parent_id = child_record.send(details[:foreign_key])
+                parent_id = child_record.send(reflection.foreign_key)
                 hash[parent_id] = child_record if parent_id.present?
               end
-              parent_records = details[:association_class].fetch_multi(ids_to_child_record.keys)
+              parent_records = reflection.klass.fetch_multi(ids_to_child_record.keys)
               parent_records.each do |parent_record|
                 child_record = ids_to_child_record[parent_record.id]
                 child_record.send(details[:prepopulate_method_name], parent_record)
@@ -277,8 +312,8 @@ module IdentityCache
             raise ArgumentError.new("Unknown cached association #{association} listed for prefetching")
           end
 
-          if details && details[:association_class].respond_to?(:prefetch_associations, true)
-            details[:association_class].send(:prefetch_associations, sub_associations, next_level_records)
+          if details && details[:association_reflection].klass.respond_to?(:prefetch_associations, true)
+            details[:association_reflection].klass.send(:prefetch_associations, sub_associations, next_level_records)
           end
         end
       end
@@ -306,39 +341,22 @@ module IdentityCache
 
     private
 
-    def populate_association_caches # :nodoc:
-      self.class.send(:embedded_associations).each do |cached_association, options|
-        send(options[:population_method_name])
-        reflection = options[:embed] == true && self.class.reflect_on_association(cached_association)
-        if reflection && reflection.klass.respond_to?(:cached_has_manys)
-          child_objects = Array.wrap(send(options[:cached_accessor_name]))
-          child_objects.each{ |child| child.send(:populate_association_caches) }
-        end
-      end
-    end
-
     def fetch_recursively_cached_association(ivar_name, association_name) # :nodoc:
-      ivar_full_name = :"@#{ivar_name}"
       if IdentityCache.should_use_cache?
-        populate_recursively_cached_association(ivar_name, association_name)
-        assoc = IdentityCache.unmap_cached_nil_for(instance_variable_get(ivar_full_name))
+        ivar_full_name = :"@#{ivar_name}"
+
+        unless ivar_value = instance_variable_get(ivar_full_name)
+          ivar_value = IdentityCache.map_cached_nil_for(send(association_name))
+          instance_variable_set(ivar_full_name, ivar_value)
+        end
+
+        assoc = IdentityCache.unmap_cached_nil_for(ivar_value)
         assoc.is_a?(ActiveRecord::Associations::CollectionAssociation) ? assoc.reader : assoc
       else
         send(association_name.to_sym)
       end
     end
 
-    def populate_recursively_cached_association(ivar_name, association_name) # :nodoc:
-      ivar_full_name = :"@#{ivar_name}"
-
-      value = instance_variable_get(ivar_full_name)
-      return value unless value.nil?
-
-      loaded_association = send(association_name)
-
-      instance_variable_set(ivar_full_name, IdentityCache.map_cached_nil_for(loaded_association))
-    end
-
     def expire_primary_index # :nodoc:
       return unless self.class.primary_cache_index_enabled
 
@@ -357,39 +375,23 @@ module IdentityCache
       IdentityCache.cache.delete(primary_cache_index_key)
     end
 
-    def expire_secondary_indexes # :nodoc:
-      return unless self.class.primary_cache_index_enabled
-      cache_indexes.try(:each) do |fields|
-        if self.destroyed?
-          IdentityCache.cache.delete(secondary_cache_index_key_for_previous_values(fields))
-        else
-          new_cache_index_key = secondary_cache_index_key_for_current_values(fields)
-          IdentityCache.cache.delete(new_cache_index_key)
-
-          if !was_new_record?
-            old_cache_index_key = secondary_cache_index_key_for_previous_values(fields)
-            IdentityCache.cache.delete(old_cache_index_key) unless old_cache_index_key == new_cache_index_key
-          end
-        end
-      end
-    end
-
     def expire_attribute_indexes # :nodoc:
-      cache_attributes.try(:each) do |(attribute, fields)|
+      cache_indexes.each do |(attribute, fields, unique)|
         unless was_new_record?
-          old_cache_attribute_key = attribute_cache_key_for_attribute_and_previous_values(attribute, fields)
+          old_cache_attribute_key = attribute_cache_key_for_attribute_and_previous_values(attribute, fields, unique)
           IdentityCache.cache.delete(old_cache_attribute_key)
         end
-        new_cache_attribute_key = attribute_cache_key_for_attribute_and_current_values(attribute, fields)
-        if new_cache_attribute_key != old_cache_attribute_key
-          IdentityCache.cache.delete(new_cache_attribute_key)
+        unless destroyed?
+          new_cache_attribute_key = attribute_cache_key_for_attribute_and_current_values(attribute, fields, unique)
+          if new_cache_attribute_key != old_cache_attribute_key
+            IdentityCache.cache.delete(new_cache_attribute_key)
+          end
         end
       end
     end
 
     def expire_cache # :nodoc:
       expire_primary_index
-      expire_secondary_indexes
       expire_attribute_indexes
       true
     end

data/lib/identity_cache/version.rb

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

data/test/attribute_cache_test.rb

@@ -9,89 +9,80 @@ class AttributeCacheTest < IdentityCache::TestCase
 
     @parent = Item.create!(:title => 'bob')
     @record = @parent.associated_records.create!(:name => 'foo')
-    @name_attribute_key = "#{NAMESPACE}attribute:AssociatedRecord:name:id:#{cache_hash(@record.id.to_s)}"
+    @name_attribute_key = "#{NAMESPACE}attr:AssociatedRecord:name:id:#{cache_hash(@record.id.to_s)}"
     IdentityCache.cache.clear
   end
 
-  def test_attribute_values_are_returned_on_cache_hits
-    IdentityCache.cache.expects(:fetch).with(@name_attribute_key).returns('foo')
-    assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
-  end
-
   def test_attribute_values_are_fetched_and_returned_on_cache_misses
     fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
-    expects_fetch_associated_record_name_by_id(1, returns: 'foo')
 
-    assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
+    assert_queries(1) do
+      assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
+    end
     assert fetch.has_been_called_with?(@name_attribute_key)
   end
 
-  def test_attribute_values_are_stored_in_the_cache_on_cache_misses
-    # Cache miss, so
-    fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
-
-    # Grab the value of the attribute from the DB
-    expects_fetch_associated_record_name_by_id(1, returns: 'foo')
-
-    # And write it back to the cache
-    add = Spy.on(fetcher, :add).and_call_through
-
+  def test_attribute_values_are_returned_on_cache_hits
     assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
-    assert fetch.has_been_called_with?(@name_attribute_key)
-    assert add.has_been_called_with?(@name_attribute_key, 'foo')
-    assert_equal 'foo', IdentityCache.cache.fetch(@name_attribute_key)
+
+    assert_queries(0) do
+      assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
+    end
   end
 
   def test_nil_is_stored_in_the_cache_on_cache_misses
-    # Cache miss, so
-    fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
-
-    # Grab the value of the attribute from the DB
-    expects_fetch_associated_record_name_by_id(1, returns: nil)
-
-    # And write it back to the cache
-    add = Spy.on(fetcher, :add).and_call_through
+    assert_equal nil, AssociatedRecord.fetch_name_by_id(2)
 
-    assert_equal nil, AssociatedRecord.fetch_name_by_id(1)
-    assert fetch.has_been_called_with?(@name_attribute_key)
-    assert add.has_been_called_with?(@name_attribute_key, IdentityCache::CACHED_NIL)
+    assert_queries(0) do
+      assert_equal nil, AssociatedRecord.fetch_name_by_id(2)
+    end
   end
 
   def test_cached_attribute_values_are_expired_from_the_cache_when_an_existing_record_is_saved
-    IdentityCache.cache.expects(:delete).with(@name_attribute_key)
-    IdentityCache.cache.expects(:delete).with(blob_key_for_associated_record(1))
+    assert_queries(1) { assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1) }
+    assert_queries(0) { assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1) }
+
     @record.save!
+
+    assert_queries(1) { assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1) }
   end
 
   def test_cached_attribute_values_are_expired_from_the_cache_when_an_existing_record_with_changed_attributes_is_saved
-    IdentityCache.cache.expects(:delete).with(@name_attribute_key)
-    IdentityCache.cache.expects(:delete).with(blob_key_for_associated_record(1))
+    assert_queries(1) { assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1) }
+    assert_queries(0) { assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1) }
+
     @record.name = 'bar'
     @record.save!
+
+    assert_queries(1) { assert_equal 'bar', AssociatedRecord.fetch_name_by_id(1) }
   end
 
   def test_cached_attribute_values_are_expired_from_the_cache_when_an_existing_record_is_destroyed
-    IdentityCache.cache.expects(:delete).with(@name_attribute_key)
-    IdentityCache.cache.expects(:delete).with(blob_key_for_associated_record(1))
+    assert_queries(1) { assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1) }
+    assert_queries(0) { assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1) }
+
     @record.destroy
+
+    assert_queries(1) { assert_equal 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.to_s
-    # primary index delete
-    IdentityCache.cache.expects(:delete).with(blob_key_for_associated_record(new_id))
-    # attribute cache delete
-    IdentityCache.cache.expects(:delete).with("#{NAMESPACE}attribute:AssociatedRecord:name:id:#{cache_hash(new_id)}")
+    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) }
+
     @parent.associated_records.create(:name => 'bar')
+
+    assert_queries(1) { assert_equal 'bar', AssociatedRecord.fetch_name_by_id(new_id) }
   end
 
   def test_fetching_by_attribute_delegates_to_block_if_transactions_are_open
-    IdentityCache.cache.expects(:read).with(@name_attribute_key).never
-
-    expects_fetch_associated_record_name_by_id(1, returns: 'foo')
+    IdentityCache.cache.expects(:read).never
 
     @record.transaction do
-      assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
+      assert_queries(1) do
+        assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
+      end
     end
   end
 
@@ -101,21 +92,9 @@ class AttributeCacheTest < IdentityCache::TestCase
     assert_equal "Jim", AssociatedRecord.fetch_name_by_id(2)
   end
 
-  private
-
-  def blob_key_for_associated_record(id)
-    cache_hash = cache_hash('id:integer,item_id:integer,item_two_id:integer,name:string')
-    "#{NAMESPACE}blob:AssociatedRecord:#{cache_hash}:#{id}"
-  end
-
-  def quoted_table_column(model, column_name)
-    "#{model.quoted_table_name}.#{model.connection.quote_column_name(column_name)}"
-  end
-
-  def expects_fetch_associated_record_name_by_id(id, options={})
-    result = options[:returns] ? [options[:returns]] : []
-    Item.connection.expects(:exec_query)
-      .with(AssociatedRecord.unscoped.select(quoted_table_column(AssociatedRecord, :name)).where(id: id).limit(1).to_sql, any_parameters)
-      .returns(ActiveRecord::Result.new(['name'], [result]))
+  def test_cache_attribute_on_derived_model_raises
+    assert_raises(IdentityCache::DerivedModelError) do
+      StiRecordTypeA.cache_attribute :name
+    end
   end
 end