identity_cache 0.0.7 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4486319de757bbba037be1e7687cb18a2fd72dc8
-  data.tar.gz: 8869e35fceeca476227e9b8181a573cfe38f1d96
+  metadata.gz: 477c35f8ea40ea8d71d6937d63ab1842a7321871
+  data.tar.gz: 2729aa2c8c4c06dcf42b8be9f167b88aa79cc81b
 SHA512:
-  metadata.gz: 1a7927f13588a480924f558473f536a94790a165820c4ff606e69456a5374394ae66c1b6eb6e40d39bd76490b0537a1b3bc164855f0174b122cbd1109376580e
-  data.tar.gz: 90f5bec88b0edd0e6c915804533eebb2d5f020dcf99ecc03b262eeaec9313d64f6c30aa9420384d8652014642198083d0bf17a8bd507872705c7838e2df827e8
+  metadata.gz: efaef756ca74582dfb7b8669933720f482d95da1493a2f2173e88c8f6cdc79861225858ebced572386e499140f9eb41ecf20a519d4db7c8363e7693141816d81
+  data.tar.gz: e11dff95ae3b78d4d57fd305eb961c4bd21e40e34a7fd08df8cf529369be841a0a75ededa64a47943e7328d10c045cb698744b070d4da2d5301ea0cdb652f61d

data/.ruby-version

@@ -1 +1 @@
-2.1.0
+2.1.1

data/.travis.yml

@@ -2,11 +2,12 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1.0
+  - 2.1.1
   - jruby
 gemfile:
+  - Gemfile32
   - Gemfile
-  - Gemfile.rails4
+  - Gemfile.rails41
 services:
   - memcache
   - mysql

data/CHANGELOG

@@ -1,3 +1,15 @@
+Unreleased
+* Consistently use ActiveRecord / Arel APIs to build SQL queries
+	[related #148]
+
+* Stop expiring cache on after_touch callback. [backwards incompatible]
+* fetch_multi accepts an array of keys as argument
+* Fix: SystemStackError when fetching more records than the max stack size
+* Fix: Bug in fetch_multi in a transaction where results weren't compacted.
+* Fix: Avoid unused preload on fetch_multi with :includes option for cache miss
+* Change :embed option value from false to :ids for cache_has_many for clarity
+* Fix: reload will invalidate the local instance cache
+
 0.0.7
 * Fix: Not implemented error for cache_has_one with embed: false
 * Fix: cache key to change when adding a cache_has_many association with :embed => false
@@ -7,7 +19,7 @@
 0.0.6
 * Fix: bug where previously nil-cached attribute caches weren't expired on record creation
 * Fix: cache key to not change when adding a non-embedded association.
-* Perf: Rails 4 Only create CollectionProxy when using it 
+* Perf: Rails 4 Only create CollectionProxy when using it
 
 0.0.5
 

data/Gemfile

@@ -3,5 +3,5 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in identity_cache.gemspec
 gemspec
 
-gem 'activerecord', '~> 3.2.16'
-gem 'activesupport', '~> 3.2.16'
+gem 'activerecord', '~> 4.0.4'
+gem 'activesupport', '~> 4.0.4'

data/{Gemfile.rails4 → Gemfile.rails41}

@@ -3,5 +3,5 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in identity_cache.gemspec
 gemspec
 
-gem 'activerecord', '~> 4.0.1'
-gem 'activesupport', '~> 4.0.1'
+gem 'activerecord', '~> 4.1.0'
+gem 'activesupport', '~> 4.1.0'

data/Gemfile32

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in identity_cache.gemspec
+gemspec
+
+gem 'activerecord', '~> 3.2.16'
+gem 'activesupport', '~> 3.2.16'

data/README.md

@@ -1,5 +1,5 @@
 # IdentityCache
-[![Build Status](https://api.travis-ci.org/Shopify/identity_cache.png?branch=master)](http://travis-ci.org/Shopify/identity_cache)
+[![Build Status](https://travis-ci.org/Shopify/identity_cache.svg?branch=master)](https://travis-ci.org/Shopify/identity_cache)
 
 Opt in read through ActiveRecord caching used in production and extracted from Shopify. 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.
 
@@ -17,7 +17,6 @@ gem 'cityhash'        # optional, for faster hashing (C-Ruby only)
 And then execute:
 
     $ bundle
-    
 
 
 Add the following to your environment/production.rb:
@@ -167,7 +166,7 @@ Example:
 #### cache_has_many
 
 Options:  
-_[:embed]_ Specifies that the association should be included with the parent when caching. This means the associated objects will be loaded already when the parent is loaded from the cache and will not need to be fetched on their own.
+_[:embed]_ When true, specifies that the association should be included with the parent when caching. This means the associated objects will be loaded already when the parent is loaded from the cache and will not need to be fetched on their own. When :ids, only the id of the associated records will be included with the parent when caching.
 
 _[:inverse_name]_ Specifies the name of parent object used by the association. This is useful for polymorphic associations when the association is often named something different between the parent and child objects.
 
@@ -177,7 +176,7 @@ Example:
 #### cache_has_one
 
 Options:  
-_[:embed]_ Specifies that the association should be included with the parent when caching. This means the associated objects will be loaded already when the parent is loaded from the cache and will not need to be fetched on their own.
+_[:embed]_ When true, specifies that the association should be included with the parent when caching. This means the associated objects will be loaded already when the parent is loaded from the cache and will not need to be fetched on their own. No other values are currently implemented.
 
 _[:inverse_name]_ Specifies the name of parent object used by the association. This is useful for polymorphic associations when the association is often named something different between the parent and child objects.
 

data/identity_cache.gemspec

@@ -15,12 +15,13 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = IdentityCache::VERSION
 
-  gem.add_dependency('ar_transaction_changes', '= 0.0.3')
-  gem.add_dependency('activerecord', '>= 3.2', '< 4.1')
+  gem.add_dependency('ar_transaction_changes', '~> 1.0')
+  gem.add_dependency('activerecord', '>= 3.2')
 
   gem.add_development_dependency('memcached_store', '~> 0.11.2')
   gem.add_development_dependency('rake')
   gem.add_development_dependency('mocha', '0.14.0')
+  gem.add_development_dependency('spy')
 
   if RUBY_PLATFORM == 'java'
     gem.add_development_dependency 'jruby-openssl'

data/lib/identity_cache/belongs_to_caching.rb

@@ -24,7 +24,7 @@ module IdentityCache
       end
 
       def build_normalized_belongs_to_cache(association, options)
-        self.class_eval(ruby = <<-CODE, __FILE__, __LINE__ + 1)
+        self.class_eval(<<-CODE, __FILE__, __LINE__ + 1)
           def #{options[:cached_accessor_name]}
             if IdentityCache.should_cache? && #{options[:foreign_key]}.present? && !association(:#{association}).loaded?
               self.#{association} = #{options[:association_class]}.fetch_by_id(#{options[:foreign_key]})

data/lib/identity_cache/cache_hash.rb

@@ -21,12 +21,12 @@ module IdentityCache
   module CacheHash
 
     if defined?(CityHash)
-      
+
       def memcache_hash(key) #:nodoc:
         CityHash.hash64(key)
       end
     else
-      
+
       def memcache_hash(key) #:nodoc:
         a = Digest::MD5.digest(key).unpack('LL')
         (a[0] << 32) | a[1]

data/lib/identity_cache/cache_invalidation.rb

@@ -0,0 +1,26 @@
+module IdentityCache
+  module CacheInvalidation
+
+    CACHE_KEY_NAMES = [:ids_variable_name, :records_variable_name]
+
+    def reload(*)
+      clear_cached_associations
+      super
+    end
+
+    private
+
+    def clear_cached_associations
+      self.class.send(:all_cached_associations).each do |_, data|
+        CACHE_KEY_NAMES.each do |key|
+          if data[key]
+            instance_variable_name = "@#{data[key]}"
+            if instance_variable_defined?(instance_variable_name)
+              remove_instance_variable(instance_variable_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/identity_cache/cache_key_generation.rb

@@ -11,9 +11,10 @@ module IdentityCache
       schema_string = schema_to_string(klass.columns)
       if klass.include?(IdentityCache)
         klass.send(:all_cached_associations).sort.each do |name, options|
-          if options[:embed]
+          case options[:embed]
+          when true
             schema_string << ",#{name}:(#{denormalized_schema_hash(options[:association_class])})"
-          elsif options[:cached_ids_name]
+          when :ids
             schema_string << ",#{name}:ids"
           end
         end

data/lib/identity_cache/configuration_dsl.rb

@@ -88,34 +88,35 @@ module IdentityCache
       #
       # == Options
       #
-      # * embed: If set will cause IdentityCache to keep the values for this
-      #   association in the same cache entry as the parent, instead of its own.
+      # * embed: If set to true, will cause IdentityCache to keep the
+      #   values for this association in the same cache entry as the parent,
+      #   instead of its own.
       # * inverse_name: The name of the parent in the association if the name is
       #   not the lowercase pluralization of the parent object's class
       def cache_has_many(association, options = {})
-        options[:embed] ||= false
+        options[:embed] = :ids unless options.has_key?(:embed)
+        deprecate_embed_option(options, false, :ids)
         options[:inverse_name] ||= self.name.underscore.to_sym
         raise InverseAssociationError unless self.reflect_on_association(association)
         self.cached_has_manys[association] = options
 
-        if options[:embed]
-          build_denormalized_association_cache(association, options)
+        case options[:embed]
+        when true
+          build_recursive_association_cache(association, options)
+        when :ids
+          build_id_embedded_has_many_cache(association, options)
         else
-          build_normalized_has_many_cache(association, options)
+          raise NotImplementedError
         end
       end
 
       # Will cache an association to the class including IdentityCache.
-      # The embed option if set will make IdentityCache keep the association
-      # values in the same cache entry as the parent.
-      #
-      # Embedded associations are more effective in offloading database work,
-      # however they will increase the size of the cache entries and make the
-      # whole entry expire with the change of any of the embedded members
+      # IdentityCache will keep the association values in the same cache entry
+      # as the parent.
       #
       # == Example:
       #   class Product
-      #    cached_has_one :store, :embed => false
+      #    cached_has_one :store, :embed => true
       #    cached_has_one :vendor
       #   end
       #
@@ -124,8 +125,9 @@ module IdentityCache
       #
       # == Options
       #
-      # * embed: If set will cause IdentityCache to keep the values for this
-      #   association in the same cache entry as the parent, instead of its own.
+      # * embed: Only true is supported, which is also the default, so
+      #   IdentityCache will keep the values for this association in the same
+      #   cache entry as the parent, instead of its own.
       # * inverse_name: The name of the parent in the association ( only
       #   necessary if the name is not the lowercase pluralization of the
       #   parent object's class)
@@ -135,8 +137,8 @@ module IdentityCache
         raise InverseAssociationError unless self.reflect_on_association(association)
         self.cached_has_ones[association] = options
 
-        if options[:embed]
-          build_denormalized_association_cache(association, options)
+        if options[:embed] == true
+          build_recursive_association_cache(association, options)
         else
           raise NotImplementedError
         end
@@ -181,9 +183,8 @@ module IdentityCache
       private
 
       def identity_cache_single_value_dynamic_fetcher(fields, values) # :nodoc:
-        sql_on_miss = "SELECT #{quoted_primary_key} FROM #{quoted_table_name} WHERE #{identity_cache_sql_conditions(fields, values)} LIMIT 1"
         cache_key = rails_cache_index_key_for_fields_and_values(fields, values)
-        id = IdentityCache.fetch(cache_key) { connection.select_value(sql_on_miss) }
+        id = IdentityCache.fetch(cache_key) { identity_cache_conditions(fields, values).limit(1).pluck(primary_key).first }
         unless id.nil?
           record = fetch_by_id(id)
           IdentityCache.cache.delete(cache_key) unless record
@@ -193,28 +194,27 @@ module IdentityCache
       end
 
       def identity_cache_multiple_value_dynamic_fetcher(fields, values) # :nodoc
-        sql_on_miss = "SELECT #{quoted_primary_key} FROM #{quoted_table_name} WHERE #{identity_cache_sql_conditions(fields, values)}"
         cache_key = rails_cache_index_key_for_fields_and_values(fields, values)
-        ids = IdentityCache.fetch(cache_key) { connection.select_values(sql_on_miss) }
+        ids = IdentityCache.fetch(cache_key) { identity_cache_conditions(fields, values).pluck(primary_key) }
 
-        ids.empty? ? [] : fetch_multi(*ids)
+        ids.empty? ? [] : fetch_multi(ids)
       end
 
-      def build_denormalized_association_cache(association, options) #:nodoc:
+      def build_recursive_association_cache(association, options) #:nodoc:
         options[:association_class]      ||= reflect_on_association(association).klass
         options[:cached_accessor_name]   ||= "fetch_#{association}"
-        options[:records_variable_name]     ||= "cached_#{association}"
+        options[:records_variable_name]  ||= "cached_#{association}"
         options[:population_method_name] ||= "populate_#{association}_cache"
 
 
         unless instance_methods.include?(options[:cached_accessor_name].to_sym)
           self.class_eval(<<-CODE, __FILE__, __LINE__ + 1)
             def #{options[:cached_accessor_name]}
-              fetch_denormalized_cached_association('#{options[:records_variable_name]}', :#{association})
+              fetch_recursively_cached_association('#{options[:records_variable_name]}', :#{association})
             end
 
             def #{options[:population_method_name]}
-              populate_denormalized_cached_association('#{options[:records_variable_name]}', :#{association})
+              populate_recursively_cached_association('#{options[:records_variable_name]}', :#{association})
             end
           CODE
 
@@ -222,7 +222,7 @@ module IdentityCache
         end
       end
 
-      def build_normalized_has_many_cache(association, options) #:nodoc:
+      def build_id_embedded_has_many_cache(association, options) #:nodoc:
         singular_association = association.to_s.singularize
         options[:association_class]       ||= reflect_on_association(association).klass
         options[:cached_accessor_name]    ||= "fetch_#{association}"
@@ -249,7 +249,7 @@ module IdentityCache
           def #{options[:cached_accessor_name]}
             if IdentityCache.should_cache? || #{association}.loaded?
               #{options[:population_method_name]} unless @#{options[:ids_variable_name]} || @#{options[:records_variable_name]}
-              @#{options[:records_variable_name]} ||= #{options[:association_class]}.fetch_multi(*@#{options[:ids_variable_name]})
+              @#{options[:records_variable_name]} ||= #{options[:association_class]}.fetch_multi(@#{options[:ids_variable_name]})
             else
               #{association}
             end
@@ -265,8 +265,7 @@ module IdentityCache
 
       def attribute_dynamic_fetcher(attribute, fields, values) #:nodoc:
         cache_key = rails_cache_key_for_attribute_and_fields_and_values(attribute, fields, values)
-        sql_on_miss = "SELECT #{connection.quote_column_name(attribute)} FROM #{quoted_table_name} WHERE #{identity_cache_sql_conditions(fields, values)} LIMIT 1"
-        IdentityCache.fetch(cache_key) { connection.select_value(sql_on_miss) }
+        IdentityCache.fetch(cache_key) { identity_cache_conditions(fields, values).limit(1).pluck(attribute).first }
       end
 
       def add_parent_expiry_hook(options)
@@ -289,8 +288,15 @@ module IdentityCache
         CODE
       end
 
-      def identity_cache_sql_conditions(fields, values)
-        fields.each_with_index.collect { |f, i| "#{connection.quote_column_name(f)} = #{quote_value(values[i],nil)}" }.join(" AND ")
+      def identity_cache_conditions(fields, values)
+        reorder(nil).where(Hash[fields.zip(values)])
+      end
+
+      def deprecate_embed_option(options, old_value, new_value)
+        if options[:embed] == old_value
+          options[:embed] = new_value
+          ActiveSupport::Deprecation.warn("`embed: #{old_value.inspect}` was renamed to `embed: #{new_value.inspect}` for clarity", caller(2))
+        end
       end
     end
   end

data/lib/identity_cache/query_api.rb

@@ -4,7 +4,9 @@ module IdentityCache
 
     included do |base|
       base.after_commit :expire_cache
-      base.after_touch  :expire_cache
+      if Gem::Version.new(ActiveRecord::VERSION::STRING) < Gem::Version.new("4.0.4")
+        base.after_touch :expire_cache
+      end
     end
 
     module ClassMethods
@@ -31,7 +33,7 @@ module IdentityCache
           end
 
         else
-          self.where(id: id).first
+          self.reorder(nil).where(primary_key => id).first
         end
       end
 
@@ -47,28 +49,30 @@ module IdentityCache
       def fetch_multi(*ids)
         raise NotImplementedError, "fetching needs the primary index enabled" unless primary_cache_index_enabled
         options = ids.extract_options!
-        if IdentityCache.should_cache?
-
+        ids.flatten!(1)
+        records = if IdentityCache.should_cache?
           require_if_necessary do
             cache_keys = ids.map {|id| rails_cache_key(id) }
             key_to_id_map = Hash[ cache_keys.zip(ids) ]
+            key_to_record_map = {}
 
-            coders_by_key = IdentityCache.fetch_multi(*cache_keys) do |unresolved_keys|
+            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, options)
-              records.compact.each{ |record| record.send(:populate_association_caches) }
+              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) }
               records.map {|record| coder_from_record(record) }
             end
 
-            records = cache_keys.map {|key| record_from_coder(coders_by_key[key]) }.compact
-            prefetch_associations(options[:includes], records) if options[:includes]
-
-            records
+            cache_keys.map{ |key| key_to_record_map[key] || record_from_coder(coders_by_key[key]) }
           end
-
         else
-          find_batch(ids, options)
+          find_batch(ids)
         end
+        records.compact!
+        prefetch_associations(options[:includes], records) if options[:includes]
+        records
       end
 
       private
@@ -114,7 +118,7 @@ module IdentityCache
         else
           record_from_coder(coder_or_array)
         end
-        variable_name = record.class.send(:all_embedded_associations)[association_name][:records_variable_name]
+        variable_name = record.class.send(:recursively_embedded_associations)[association_name][:records_variable_name]
         record.instance_variable_set(:"@#{variable_name}", IdentityCache.map_cached_nil_for(value))
       end
 
@@ -139,14 +143,17 @@ module IdentityCache
       end
 
       def add_cached_associations_to_coder(record, coder)
-        if record.class.respond_to?(:all_embedded_associations, true) && record.class.send(:all_embedded_associations).present?
-          coder[:associations] = record.class.send(:all_embedded_associations).each_with_object({}) do |(name, options), hash|
-            hash[name] = IdentityCache.map_cached_nil_for(get_embedded_association(record, name, options))
+        klass = record.class
+        if klass.include?(IdentityCache)
+          if (recursively_embedded_associations = klass.send(:recursively_embedded_associations)).present?
+            coder[:associations] = recursively_embedded_associations.each_with_object({}) do |(name, options), hash|
+              hash[name] = IdentityCache.map_cached_nil_for(get_embedded_association(record, name, options))
+            end
           end
-        end
-        if record.class.respond_to?(:cached_has_manys) && record.class.cached_has_manys.present?
-          coder[:normalized_has_many] = record.class.cached_has_manys.each_with_object({}) do |(name, options), hash|
-            hash[name] = record.instance_variable_get(:"@#{options[:ids_variable_name]}") unless options[:embed]
+          if (cached_has_manys = klass.cached_has_manys).present?
+            coder[:normalized_has_many] = 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
         end
       end
@@ -170,14 +177,14 @@ module IdentityCache
       end
 
       def resolve_cache_miss(id)
-        object = self.includes(cache_fetch_includes).where(id: id).try(:first)
+        object = self.includes(cache_fetch_includes).reorder(nil).where(primary_key => id).try(:first)
         object.send(:populate_association_caches) if object
         object
       end
 
-      def all_embedded_associations
+      def recursively_embedded_associations
         all_cached_associations.select do |cached_association, options|
-          options[:embed].present?
+          options[:embed] == true
         end
       end
 
@@ -185,23 +192,19 @@ module IdentityCache
         (cached_has_manys || {}).merge(cached_has_ones || {}).merge(cached_belongs_tos || {})
       end
 
-      def all_cached_associations_needing_population
+      def embedded_associations
         all_cached_associations.select do |cached_association, options|
-          options[:population_method_name].present? # non-embedded belongs_to associations don't need population
+          options[:embed]
         end
       end
 
-      def cache_fetch_includes(additions = {})
-        additions = hashify_includes_structure(additions)
-        embedded_associations = all_cached_associations.select { |name, options| options[:embed] }
-
-        associations_for_identity_cache = embedded_associations.map do |child_association, options|
+      def cache_fetch_includes
+        associations_for_identity_cache = recursively_embedded_associations.map do |child_association, options|
           child_class = reflect_on_association(child_association).try(:klass)
 
-          child_includes = additions.delete(child_association)
-
+          child_includes = nil
           if child_class.respond_to?(:cache_fetch_includes, true)
-            child_includes = child_class.send(:cache_fetch_includes, child_includes)
+            child_includes = child_class.send(:cache_fetch_includes)
           end
 
           if child_includes.blank?
@@ -211,19 +214,15 @@ module IdentityCache
           end
         end
 
-        associations_for_identity_cache.push(additions) if additions.keys.size > 0
         associations_for_identity_cache.compact
       end
 
-      def find_batch(ids, options = {})
-        @id_column ||= columns.detect {|c| c.name == "id"}
+      def find_batch(ids)
+        @id_column ||= columns.detect {|c| c.name == primary_key}
         ids = ids.map{ |id| @id_column.type_cast(id) }
-        records = where('id IN (?)', ids).includes(cache_fetch_includes(options[:includes])).to_a
+        records = where(primary_key => ids).includes(cache_fetch_includes).to_a
         records_by_id = records.index_by(&:id)
-        records = ids.map{ |id| records_by_id[id] }
-        mismatching_ids = records.compact.map(&:id) - ids
-        IdentityCache.logger.error "[IDC id mismatch] fetch_batch_requested=#{ids.inspect} fetch_batch_got=#{mismatchig_ids.inspect} mismatching ids "  unless mismatching_ids.empty?
-        records
+        ids.map{ |id| records_by_id[id] }
       end
 
       def prefetch_associations(associations, records)
@@ -233,7 +232,7 @@ module IdentityCache
           case
           when details = cached_has_manys[association]
 
-            if details[:embed]
+            if details[:embed] == true
               child_records = records.map(&details[:cached_accessor_name].to_sym).flatten
             else
               ids_to_parent_record = records.each_with_object({}) do |record, hash|
@@ -258,14 +257,14 @@ module IdentityCache
             next_level_records = child_records
 
           when details = cached_belongs_tos[association]
-            if details[:embed]
+            if details[:embed] == true
               raise ArgumentError.new("Embedded belongs_to associations do not support prefetching yet.")
             else
               ids_to_child_record = records.each_with_object({}) do |child_record, hash|
                 parent_id = child_record.send(details[: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 = details[:association_class].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)
@@ -275,7 +274,7 @@ module IdentityCache
             next_level_records = parent_records
 
           when details = cached_has_ones[association]
-            if details[:embed]
+            if details[:embed] == true
               parent_records = records.map(&details[:cached_accessor_name].to_sym)
             else
               raise ArgumentError.new("Non-embedded has_one associations do not support prefetching yet.")
@@ -317,9 +316,9 @@ module IdentityCache
     private
 
     def populate_association_caches # :nodoc:
-      self.class.send(:all_cached_associations_needing_population).each do |cached_association, options|
+      self.class.send(:embedded_associations).each do |cached_association, options|
         send(options[:population_method_name])
-        reflection = options[:embed] && self.class.reflect_on_association(cached_association)
+        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) }
@@ -327,10 +326,10 @@ module IdentityCache
       end
     end
 
-    def fetch_denormalized_cached_association(ivar_name, association_name) # :nodoc:
+    def fetch_recursively_cached_association(ivar_name, association_name) # :nodoc:
       ivar_full_name = :"@#{ivar_name}"
       if IdentityCache.should_cache?
-        populate_denormalized_cached_association(ivar_name, association_name)
+        populate_recursively_cached_association(ivar_name, association_name)
         assoc = IdentityCache.unmap_cached_nil_for(instance_variable_get(ivar_full_name))
         assoc.is_a?(ActiveRecord::Associations::CollectionAssociation) ? assoc.reader : assoc
       else
@@ -338,7 +337,7 @@ module IdentityCache
       end
     end
 
-    def populate_denormalized_cached_association(ivar_name, association_name) # :nodoc:
+    def populate_recursively_cached_association(ivar_name, association_name) # :nodoc:
       ivar_full_name = :"@#{ivar_name}"
 
       value = instance_variable_get(ivar_full_name)
@@ -405,7 +404,8 @@ module IdentityCache
     end
 
     def was_new_record? # :nodoc:
-      !destroyed? && transaction_changed_attributes.has_key?('id') && transaction_changed_attributes['id'].nil?
+      pk = self.class.primary_key
+      !destroyed? && transaction_changed_attributes.has_key?(pk) && transaction_changed_attributes[pk].nil?
     end
   end
 end

data/lib/identity_cache/version.rb

@@ -1,4 +1,4 @@
 module IdentityCache
-  VERSION = "0.0.7"
+  VERSION = "0.1.0"
   CACHE_VERSION = 3
 end