last_mod_cache 1.0.0 → 1.0.1

data/README.rdoc

@@ -38,6 +38,15 @@ Any model that includes the LastModCache module will have several "with_cache" m
   # Dynamic finders are also available in caching versions
   MyModel.find_by_name_with_cache("test")
   MyModel.find_all_by_name_and_value_with_cache("test", 4)
+  
+  # Associations can also be loaded from cache if the associated classes include LastModCache
+  class Widget < ActiveRecord::Base
+    include LastModCache
+  end
+  
+  MyModel.belongs_to :widget
+  
+  MyModel.first.widget_with_cache
 
 == Configuring
 

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.0.1

data/lib/last_mod_cache.rb

@@ -4,13 +4,18 @@ module LastModCache
   extend ActiveSupport::Concern
   
   DYNAMIC_FINDER_METHOD_PATTERN = /^find_(all_)?by_(.+)_with_cache$/
+  ASSOCIATION_WITH_CACHE_PATTERN = /^(.+)_with_cache$/
   
   included do
     class_eval do
       class << self
+        # Alias class method_missing
         alias_method_chain(:method_missing, :last_mod_cache)
       end
     end
+    # Alias instance method missing
+    alias_method_chain(:method_missing, :last_mod_cache)
+    
     class_attribute :last_mod_cache, :updated_at_column, :instance_reader => false, :instance_writer => false
     self.last_mod_cache = Rails.cache if defined?(Rails)
     self.updated_at_column = :updated_at
@@ -29,16 +34,33 @@ module LastModCache
     #   BlogPosts.where(:blog_id => my_blog.id).order("published_at DESC").limit(20).with_cache
     def with_cache(cache_options = nil)
       raise NotImplementedError.new("LastModCache is not available on #{klass}") unless klass.include?(LastModCache)
-      bind_variables = nil
-      if respond_to?(:bind_values)
-        bind_variables = bind_values.collect do |column, value|
-          column.type_cast(value)
-        end
-      end
-      klass.all_with_cache(:sql => to_sql, :cache => cache_options, :bind_values => bind_variables) do
+      bind_variables = respond_to?(:bind_values) ? bind_values.collect{|column, value| column.type_cast(value)} : []
+      klass.all_with_cache(:sql => to_sql, :bind_values => bind_variables, :cache => cache_options) do
         to_a
       end
     end
+    
+    # Add +first_with_cache+ to the end of a relation chain to perform the find and store the results in cache.
+    # Options for cache storage can be set with the optional +cache_options+ parameter. This method is
+    # equivalent to calling +first+ on the relation so that no more relations can be chained after it is called.
+    #
+    # Example:
+    #
+    #   Blog.where(:name => "My Blog").first_with_cache
+    def first_with_cache(cache_options = nil)
+      raise NotImplementedError.new("LastModCache is not available on #{klass}") unless klass.include?(LastModCache)
+      limited_scope = limit(1)
+      conn = klass.connection
+      key_scope = limited_scope.select(["#{conn.quote_table_name(klass.table_name)}.#{conn.quote_column_name(klass.primary_key)} AS #{conn.quote_column_name('id')}", "#{conn.quote_table_name(klass.table_name)}.#{conn.quote_column_name(klass.updated_at_column)} AS #{conn.quote_column_name('updated_at')}"])
+      bind_variables = limited_scope.respond_to?(:bind_values) ? limited_scope.bind_values.collect{|column, value| column.type_cast(value)} : []
+      Proxy.new do
+        id, timestamp = klass.send(:id_and_updated_at, :sql => key_scope.to_sql, :bind_values => bind_variables)
+        record = last_mod_cache.fetch(klass.send(:updated_at_cache_key, :first_with_cache, {:sql => limited_scope.to_sql, :bind_values => bind_values}, timestamp), cache_options) do
+          limited_scope.where(klass.primary_key => id).first if id
+        end
+        record.freeze if record
+      end
+    end
   end
   
   # Class methods mixed into an ActiveRecord model that includes LastModCache.
@@ -69,8 +91,8 @@ module LastModCache
       cache_options, options = extract_cache_options(options)
       conditions = options.delete(:conditions)
       Proxy.new do
-        id, timestamp = id_and_updated_at(conditions)
-        block ||= lambda{ all(options.merge(:limit => 1, :conditions => {:id => id})).first if id }
+        id, timestamp = id_and_updated_at(:conditions => conditions)
+        block ||= lambda{ all(options.merge(:limit => 1, :conditions => {primary_key => id})).first if id }
         record = last_mod_cache.fetch(updated_at_cache_key(:first_with_cache, options.merge(:conditions => conditions), timestamp), cache_options, &block)
         record.freeze if record
       end
@@ -86,9 +108,9 @@ module LastModCache
       cache_options, options = extract_cache_options(options)
       finder = lambda{ options.blank? ? find(id_or_ids) : find(id_or_ids, options) }
       if id_or_ids.is_a?(Array)
-        all_with_cache(options.merge(:conditions => {:id => id_or_ids}, :cache => cache_options), &finder)
+        all_with_cache(options.merge(:conditions => {primary_key => id_or_ids}, :cache => cache_options), &finder)
       else
-        first_with_cache(options.merge(:conditions => {:id => id_or_ids}, :cache => cache_options), &finder)
+        first_with_cache(options.merge(:conditions => {primary_key => id_or_ids}, :cache => cache_options), &finder)
       end
     end
     
@@ -128,6 +150,15 @@ module LastModCache
       end
     end
     
+    # Get the maximum value in the updated at column and the count of all records in the database.
+    # This information can be used to generate self-expiring cache keys for models that change infrequently.
+    def max_updated_at_and_count
+      result = connection.select_one("SELECT MAX(#{connection.quote_column_name(updated_at_column)}) AS #{connection.quote_column_name('updated_at')}, COUNT(*) AS #{connection.quote_column_name('row_size')} FROM #{connection.quote_table_name(table_name)}")
+      updated_at = result['updated_at']
+      updated_at = columns_hash[updated_at_column.to_s].type_cast(updated_at) if updated_at.is_a?(String)
+      [updated_at, result['row_size'].to_i]
+    end
+    
     private
     
     # Construct a cache key based on a timestamp.
@@ -137,20 +168,16 @@ module LastModCache
       key
     end
     
-    # Get the maximum value in the updated at column and the count of all records in the database.
-    def max_updated_at_and_count
-      result = connection.select_one("SELECT MAX(#{connection.quote_column_name(updated_at_column)}) AS #{connection.quote_column_name('updated_at')}, COUNT(*) AS #{connection.quote_column_name('row_size')} FROM #{connection.quote_table_name(table_name)}")
-      updated_at = result['updated_at']
-      updated_at = columns_hash[updated_at_column.to_s].type_cast(updated_at) if updated_at.is_a?(String)
-      [updated_at, result['row_size'].to_i]
-    end
-    
     # Get the id and updated at value for the first row that matches the conditions.
-    def id_and_updated_at(conditions)
+    def id_and_updated_at(options)
       column = columns_hash[updated_at_column.to_s]
-      sql = "SELECT #{connection.quote_column_name(primary_key)} AS #{connection.quote_column_name('id')}, #{connection.quote_column_name(updated_at_column)} AS #{connection.quote_column_name('updated_at')} FROM #{connection.quote_table_name(table_name)}"
-      sql << " WHERE #{sanitize_sql_for_conditions(conditions)}" if conditions
-      result = connection.select_one(sql)
+      sql = options[:sql]
+      unless sql
+        sql = "SELECT #{connection.quote_column_name(primary_key)} AS #{connection.quote_column_name('id')}, #{connection.quote_column_name(updated_at_column)} AS #{connection.quote_column_name('updated_at')} FROM #{connection.quote_table_name(table_name)}"
+        sql << " WHERE #{sanitize_sql_for_conditions(options[:conditions])}" if options[:conditions]
+      end
+      # Support older versions for ActiveRecord that don't implement bind_values
+      result = (options[:bind_values].blank? ? connection.select_all(sql) : connection.select_all(sql, nil, options[:bind_values])).first
       if result
         updated_at = result['updated_at']
         updated_at = columns_hash[updated_at_column.to_s].type_cast(updated_at) if updated_at.is_a?(String)
@@ -203,11 +230,23 @@ module LastModCache
       sql = self.class.send(:sanitize_sql, ["UPDATE #{conn.quote_table_name(self.class.table_name)} SET #{conn.quote_column_name(col_name)} = ? WHERE #{conn.quote_column_name(self.class.primary_key)} = ?", timestamp, id])
       conn.update(sql)
     end
+
+    def method_missing_with_last_mod_cache(method, *args, &block) #:nodoc:
+      match = method.to_s.match(ASSOCIATION_WITH_CACHE_PATTERN)
+      association_name = match[1].to_sym if match
+      reflection = self.class.reflect_on_association(association_name) if association_name
+      if reflection && (reflection.macro == :belongs_to)
+        foreign_key = reflection.respond_to?(:foreign_key) ? reflection.foreign_key : reflection.primary_key_name
+        reflection.klass.first_with_cache(:conditions => {(reflection.options[:primary_key] || reflection.klass.primary_key) => self[foreign_key]})
+      else
+        method_missing_without_last_mod_cache(method, *args, &block)
+      end
+    end
   end
   
   # Proxy class that sends all method calls to a block.
   class Proxy #:nodoc:
-    required_methods = {"__send__" => true, "__id__" => true}
+    required_methods = {"__send__" => true, "__id__" => true, "object_id" => true}
     instance_methods.each do |m|
       undef_method(m) unless required_methods.include?(m.to_s)
     end

data/spec/last_mod_cache_spec.rb

@@ -78,6 +78,28 @@ describe LastModCache do
     end
   end
   
+  context "cache key information" do
+    it "should get the maximum updated at timestamp and the count of all rows in a table" do
+      model_one_record_one
+      model_one_record_two
+      model_one_record_two.updated_at.should_not be_nil
+      LastModCache::Test::ModelOne.max_updated_at_and_count.should == [model_one_record_two.updated_at, 2]
+      
+      model_one_record_three
+      LastModCache::Test::ModelOne.max_updated_at_and_count.should == [model_one_record_three.updated_at, 3]
+    end
+    
+    it "should get the maximum updated at timestamp and the count of all rows in a table when using a custom timestamp column" do
+      model_four_record_one
+      model_four_record_two
+      model_four_record_two.last_modified.should_not be_nil
+      LastModCache::Test::ModelFour.max_updated_at_and_count.should == [model_four_record_two.last_modified, 2]
+      
+      model_four_record_three
+      LastModCache::Test::ModelFour.max_updated_at_and_count.should == [model_four_record_three.last_modified, 3]
+    end
+  end
+  
   context "find all" do
     before :each do
       model_one_record_one
@@ -280,20 +302,20 @@ describe LastModCache do
       model_one_record_one
       model_one_record_two
       model_one_record_three
-      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :first_with_cache, :conditions => {:id => model_one_record_two.id}, :updated_at => model_one_record_two.updated_at.to_f}
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :first_with_cache, :conditions => {"id" => model_one_record_two.id}, :updated_at => model_one_record_two.updated_at.to_f}
       LastModCache::Test::ModelOne.find_with_cache(model_one_record_two.id).should == model_one_record_two
       Rails.cache.read(cache_key).should == model_one_record_two
     end
     
     it "should find a single record by id from the cache" do
-      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :first_with_cache, :conditions => {:id => model_one_record_two.id}, :updated_at => model_one_record_two.updated_at.to_f}
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :first_with_cache, :conditions => {"id" => model_one_record_two.id}, :updated_at => model_one_record_two.updated_at.to_f}
       Rails.cache.write(cache_key, model_one_record_two)
       LastModCache::Test::ModelOne.poke_column_value(model_one_record_two.id, :value, 0)
       LastModCache::Test::ModelOne.find_with_cache(model_one_record_two.id).value.should == 2
     end
     
     it "should invalidate a single record by id cache entry when the record is modified" do
-      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :first_with_cache, :conditions => {:id => model_one_record_two.id}, :updated_at => model_one_record_two.updated_at.to_f}
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :first_with_cache, :conditions => {"id" => model_one_record_two.id}, :updated_at => model_one_record_two.updated_at.to_f}
       Rails.cache.write(cache_key, model_one_record_two)
       model_one_record_two.update_attribute(:value, 0)
       LastModCache::Test::ModelOne.find_with_cache(model_one_record_two.id).value.should == 0
@@ -303,27 +325,27 @@ describe LastModCache do
       model_one_record_one
       model_one_record_two
       model_one_record_three
-      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :conditions => {:id => [model_one_record_one.id, model_one_record_two.id]}, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3}
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :conditions => {"id" => [model_one_record_one.id, model_one_record_two.id]}, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3}
       LastModCache::Test::ModelOne.find_with_cache([model_one_record_one.id, model_one_record_two.id]).should == [model_one_record_one, model_one_record_two]
       Rails.cache.read(cache_key).should == [model_one_record_one, model_one_record_two]
     end
     
     it "should find multiple records by id from the cache" do
-      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :conditions => {:id => [model_one_record_one.id, model_one_record_two.id]}, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3}
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :conditions => {"id" => [model_one_record_one.id, model_one_record_two.id]}, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3}
       Rails.cache.write(cache_key, [model_one_record_one, model_one_record_two])
       LastModCache::Test::ModelOne.poke_column_value(model_one_record_one.id, :value, 0)
       LastModCache::Test::ModelOne.find_with_cache([model_one_record_one.id, model_one_record_two.id]).first.value.should == 1
     end
     
     it "should invalidate a multiple records by id cache entry when any record is modified" do
-      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :conditions => {:id => [model_one_record_one.id, model_one_record_two.id]}, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3}
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :conditions => {"id" => [model_one_record_one.id, model_one_record_two.id]}, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3}
       Rails.cache.write(cache_key, [model_one_record_one, model_one_record_two])
       model_one_record_one.update_attribute(:value, 0)
       LastModCache::Test::ModelOne.find_with_cache([model_one_record_one.id, model_one_record_two.id]).first.value.should == 0
     end
     
     it "should invalidate a multiple records by id cache entry when any record is deleted" do
-      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :conditions => {:id => [model_one_record_one.id, model_one_record_three.id]}, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3}
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :conditions => {"id" => [model_one_record_one.id, model_one_record_three.id]}, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3}
       Rails.cache.write(cache_key, [model_one_record_one, model_one_record_three])
 
       LastModCache::Test::ModelOne.poke_column_value(model_one_record_one.id, :value, 0)
@@ -356,7 +378,7 @@ describe LastModCache do
       model_one_record_two.reload
       LastModCache::Test::ModelTwo.find_with_cache(model_two_record_two.id).value.should == 2
       
-      cache_key = {:class => "LastModCache::Test::ModelTwo", :method => :first_with_cache, :conditions => {:id => model_two_record_two.id}, :updated_at => model_one_record_two.updated_at.to_f}
+      cache_key = {:class => "LastModCache::Test::ModelTwo", :method => :first_with_cache, :conditions => {"id" => model_two_record_two.id}, :updated_at => model_one_record_two.updated_at.to_f}
       LastModCache::Test.cache.write(cache_key, model_two_record_two.dup)
       LastModCache::Test::ModelTwo.poke_column_value(model_two_record_two.id, :value, 0)
       LastModCache::Test::ModelTwo.find_with_cache(model_two_record_two.id).value.should == 2
@@ -451,7 +473,7 @@ describe LastModCache do
     it "should cache the result of a relation chain" do
       relation = LastModCache::Test::ModelOne.where(:name => ["one", "two"]).order("value DESC")
       relation.with_cache.should == [model_one_record_two, model_one_record_one]
-      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3, :sql => relation.to_sql, :bind_values => nil}
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3, :sql => relation.to_sql, :bind_values => []}
       Rails.cache.read(cache_key).should == [model_one_record_two, model_one_record_one]
       Rails.cache.write(cache_key, [model_one_record_one, model_one_record_three])
       relation.with_cache.should == [model_one_record_one, model_one_record_three]
@@ -481,19 +503,30 @@ describe LastModCache do
     end
   end
   
-  context "eager load associations" do
+  context "associations" do
     before :each do
-      model_one_record_one.widget = LastModCache::Test::Widget.create!(:name => "widget_1")
+      model_one_record_two.things.create(:name => "thing_0")
+      LastModCache::Test::Widget.create!(:name => "widget_0")
+      model_one_record_one.widget = widget
+      LastModCache::Test::Widget.create!(:name => "widget_2")
       model_one_record_one.things.create(:name => "thing_1")
       model_one_record_one.things.create(:name => "thing_2")
       model_one_record_one.save!
       model_one_record_one.reload
-      model_one_record_two
-      model_one_record_three
+      model_one_record_three.things.create(:name => "thing_3")
     end
     
+    let(:widget){ LastModCache::Test::Widget.create!(:name => "widget_1") }
     let(:includes){ [:widget, {:things => :widget}] }
     
+    it "should cache belongs_to associations" do
+      model_one_record_one.widget_with_cache.name.should == "widget_1"
+      cache_key = {:class => "LastModCache::Test::Widget", :method => :first_with_cache, :updated_at => widget.updated_at.to_f, :conditions => {"id" => widget.id}}
+      Rails.cache.read(cache_key).name.should == "widget_1"
+      Rails.cache.write(cache_key, LastModCache::Test::Widget.new(:name => "widget_a"))
+      model_one_record_one.widget_with_cache.name.should == "widget_a"
+    end
+    
     it "should cache included associations when finding many records" do
       cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :conditions => {:name => "one"}, :include => includes, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3}
       LastModCache::Test::ModelOne.all_with_cache(:conditions => {:name => "one"}, :include => includes).should == [model_one_record_one]
@@ -523,7 +556,7 @@ describe LastModCache do
     end
     
     it "should cache included associations when finding a record by id" do
-      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :first_with_cache, :conditions => {:id => model_one_record_one.id}, :include => includes, :updated_at => model_one_record_one.updated_at.to_f}
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :first_with_cache, :conditions => {"id" => model_one_record_one.id}, :include => includes, :updated_at => model_one_record_one.updated_at.to_f}
       LastModCache::Test::ModelOne.find_with_cache(model_one_record_one.id, :include => includes).should == model_one_record_one
       cached = Rails.cache.read(cache_key)
       if cached.respond_to?(:association)
@@ -539,7 +572,7 @@ describe LastModCache do
     it "should cache included associations when finding with a Relation" do
       relation = LastModCache::Test::ModelOne.where(:name => "one").includes(includes)
       relation.with_cache.should == [model_one_record_one]
-      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3, :sql => relation.to_sql, :bind_values => nil}
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3, :sql => relation.to_sql, :bind_values => []}
       cached = Rails.cache.read(cache_key).first
       if cached.respond_to?(:association)
         cached.association(:widget).loaded?.should == true
@@ -554,7 +587,7 @@ describe LastModCache do
     it "should cache eager load associations when finding with a Relation" do
       relation = LastModCache::Test::ModelOne.where(:name => "one").eager_load(includes)
       relation.with_cache.should == [model_one_record_one]
-      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3, :sql => relation.to_sql, :bind_values => nil}
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3, :sql => relation.to_sql, :bind_values => []}
       cached = Rails.cache.read(cache_key).first
       if cached.respond_to?(:association)
         cached.association(:widget).loaded?.should == true
@@ -569,7 +602,7 @@ describe LastModCache do
     it "should cache preload associations when finding with a Relation" do
       relation = LastModCache::Test::ModelOne.where(:name => "one").preload(includes)
       relation.with_cache.should == [model_one_record_one]
-      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3, :sql => relation.to_sql, :bind_values => nil}
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3, :sql => relation.to_sql, :bind_values => []}
       cached = Rails.cache.read(cache_key).first
       if cached.respond_to?(:association)
         cached.association(:widget).loaded?.should == true
@@ -586,14 +619,20 @@ describe LastModCache do
     it "should proxy all methods except __id__" do
       proxy = LastModCache::Proxy.new{ nil }
       proxy.nil?.should == true
-      proxy.object_id.should == nil.object_id
       proxy.send(:nil?).should == true
-      proxy.__id__.should_not == nil.object_id
+      
+      proxy = LastModCache::Proxy.new{ "abc" }
+      proxy.nil?.should == false
+      proxy.size.should == 3
     end
     
     it "should only evaluate the block once" do
-      proxy = LastModCache::Proxy.new{ Object.new }
-      proxy.object_id.should == proxy.object_id
+      i = 0
+      obj = Object.new
+      proxy = LastModCache::Proxy.new{ i += 1; obj }
+      proxy.should == obj
+      proxy.nil?
+      i.should == 1
     end
     
     it "should lazy evaluate the block" do
@@ -605,4 +644,26 @@ describe LastModCache do
       lambda{ proxy.not_a_method }.should raise_error(NoMethodError)
     end
   end
+  
+  context "SQL caching" do
+    before :each do
+      model_one_record_one
+    end
+    
+    it "should cache sql used for finding one record" do
+      LastModCache::Test::ModelOne.connection.cache do
+        LastModCache::Test::ModelOne.find_by_name_with_cache("one").should == model_one_record_one
+        LastModCache::Test::ModelOne.connection.should_not_receive(:select)
+        LastModCache::Test::ModelOne.find_by_name_with_cache("one").should == model_one_record_one
+      end
+    end
+    
+    it "should cache sql used for finding many record" do
+      LastModCache::Test::ModelOne.connection.cache do
+        LastModCache::Test::ModelOne.find_all_by_name_with_cache("one").should == [model_one_record_one]
+        LastModCache::Test::ModelOne.connection.should_not_receive(:select)
+        LastModCache::Test::ModelOne.find_all_by_name_with_cache("one").should == [model_one_record_one]
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -39,12 +39,14 @@ module LastModCache
     
     module PokeRecordValue
       def poke_column_value(id, column, value)
-        sql = ["UPDATE #{connection.quote_table_name(table_name)} SET #{connection.quote_column_name(column)} = ? WHERE id = ?", value, id]
+        sql = ["UPDATE #{connection.quote_table_name(table_name)} SET #{connection.quote_column_name(column)} = ? WHERE #{connection.quote_column_name(primary_key)} = ?", value, id]
         connection.update(sanitize_sql_array(sql))
       end
     end
     
     class Thing < ActiveRecord::Base
+      include LastModCache
+      
       belongs_to :widget
       
       class << self
@@ -60,6 +62,7 @@ module LastModCache
     end
     
     class Widget < ActiveRecord::Base
+      include LastModCache
       class << self
         def setup
           connection.create_table(table_name) do |t|
@@ -116,12 +119,13 @@ module LastModCache
       extend PokeRecordValue
       include LastModCache
       self.updated_at_column = :last_modified
+      self.primary_key = "identifier"
       
       before_save{|r| r.last_modified = Time.now.to_f}
       
       class << self
         def setup
-          connection.create_table(table_name) do |t|
+          connection.create_table(table_name, :primary_key => :identifier) do |t|
             t.string :name
             t.integer :value
             t.float :last_modified

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: last_mod_cache
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: 
   segments: 
   - 1
   - 0
-  - 0
-  version: 1.0.0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Brian Durand
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-05 00:00:00 -05:00
+date: 2011-07-15 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency