last_mod_cache 1.0.0

data/MIT_LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Brian Durand
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,108 @@
+= LastModCache
+
+This module adds a simple caching layer on ActiveRecord models. Models must include a column that contains a timestamp of when the record was last modified (i.e. an +updated_at+ column). This timestamp will be used to automatically invalidate cache entries as records are modified so your cache is always up to date.
+
+== Example
+
+Any model that includes the LastModCache module will have several "with_cache" methods added for finding records with a caching layer.
+
+  class MyModelMigration < ActiveRecord::Migration
+    def self.up
+      create_table :my_models do |t|
+        t.string :name
+        t.integer :value
+        t.timestamps # Include the magical updated_at column
+      end
+      
+      # Very important: the updated_at column must be indexed in order to use the caching methods effectively.
+      # You will take a big performance hit if this isn't done.
+      add_index :my_models, :updated_at
+    end
+  end
+  
+  class MyModel < ActiveRecord::Base
+    include LastModCache
+  end
+  
+  # Rails 2 style finders with caching
+  MyModel.first_with_cache(:conditions => {:name => "test"})
+  MyModel.all_with_cache(:conditions => {:value => 0}, :limit => 10)
+  
+  # Rails 3 style finders with caching
+  MyModel.where(:name => "test").limit(10).with_cache
+  
+  # Find by ids with cache
+  MyModel.find_with_cache(100)
+  MyModel.find_with_cache([100, 101, 102])
+  
+  # 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)
+
+== Configuring
+
+By default, the +updated_at+ column will be used for checking time stamps on your records. This can be overridden either by setting the +updated_at_column+ on your model.
+
+  class MyModel < ActiveRecord::Base
+    include LastModCache
+    self.updated_at_column = :last_modified_time
+  end
+
+It is very important that you have an index on the column being used since it will queried on directly as part of the caching algorithm.
+
+The default Rails.cache will be used if available. If you'd like to specify a different cache for your models, you can specify it by setting +last_mod_cache+ on your model.
+
+  class MyModel < ActiveRecord::Base
+    include LastModCache
+    self.last_mod_cache = ActiveSupport::Cache::MemoryStore.new
+  end
+
+The cache can be any implementation of ActiveSupport::Cache::CacheStore.
+
+== Performance Notes
+
+This module provides a very easy method of adding caching to your models, but not necessarily the most efficient. It is intended to provide a quick method of boosting performance and reducing database load. In critical sections of your code, you may want to handle caching differently.
+
+The response from all of the +with_cache+ methods will be a lazy loaded only be when necessary (similar to how the ActiveRecord 3 finder methods work). This allows them to interact nicely with other caching layers so that you're not loading records that are never used.
+
+The objects returned from the cache will be frozen. If you'll need to modify a record, don't use the cache.
+
+=== Eager Loading Associations
+
+Any eager loaded associations on the model will be loaded before the value is cached. This can really boost performance for complex data structures. However, associations are *not* included in the timestamp calculation, so use with caution since you could get stale associations from the cache. If your code is susceptible to this condition, you can work around it be providing a call back in you associated model that calls <tt>update_timestamp!</tt>.
+
+  class MyModel < ActiveRecord::Base
+    include LastModCache
+    has_many :my_associations
+  end
+  
+  class MyAssociation < ActiveRecord::Base
+    belongs_to :my_model
+    after_save do |record|
+      record.my_model.update_timestamp!
+    end
+  end
+
+=== Caching a single record
+
+When finding a single record with +first_with_cache+ or +find_with_cache+
+
+1. The database is queried to get the id and updated at timestamp on the record
+2. The id and timestamp are used to generate a cache key and the cache is checked
+3. If the key is not found in the cache, the database will be queried again for the record by id
+
+This will really only boost performance on records with many large columns or when you include associations to be cached with the record. You should verify that adding caching actually gives you a benefit.
+
+=== Caching multiple records
+
+When finding multiple records with +all_with_cache+ or +with_cache+
+
+1. The database is queried for the maximum value in the updated at column and the count of the number of rows in the table
+2. This is used to generate a cache key and the cache is checked
+3. If the key is not found in the cache, the database query will be done and the results will be cached
+
+This can give a pretty good performance boost especially for things like getting all the values in a small table to display in a view. If the table is updated frequently, the benefits will be reduced because any updates to the table will invalidate all the cache entries.
+
+=== MySQL Timestamp Accuracy
+
+Since MySQL only stores datetimes with a precision of 1 second, there is a small possibility that stale data could be in the cache if a record is updated twice within one second and in between is read into the cache. All the other major databases use much higher precision on timestamps and are not affected by this issue. As a work around, you can use a FLOAT column for your timestamps instead of a DATETIME.

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'rubygems/package_task'
+require 'rake'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'RVM likes to call it tests'
+task :tests => :test
+
+begin
+  require 'rspec'
+  require 'rspec/core/rake_task'
+  desc 'Run the unit tests'
+  RSpec::Core::RakeTask.new(:test)
+rescue LoadError
+  task :test do
+    STDERR.puts "You must have rspec 2.0 installed to run the tests"
+  end
+end
+
+spec_file = File.expand_path('../last_mod_cache.gemspec', __FILE__)
+if File.exist?(spec_file)
+  spec = eval(File.read(spec_file))
+
+  Gem::PackageTask.new(spec) do |p|
+    p.gem_spec = spec
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/last_mod_cache.rb

@@ -0,0 +1,224 @@
+require 'active_record'
+
+module LastModCache
+  extend ActiveSupport::Concern
+  
+  DYNAMIC_FINDER_METHOD_PATTERN = /^find_(all_)?by_(.+)_with_cache$/
+  
+  included do
+    class_eval do
+      class << self
+        alias_method_chain(:method_missing, :last_mod_cache)
+      end
+    end
+    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
+    
+    ActiveRecord::Relation.send(:include, RelationCache) unless ActiveRecord::Relation.include?(RelationCache)
+  end
+  
+  # Module added to ActiveRecord::Relation to add the +with_cache+ method.
+  module RelationCache
+    # Add +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 +to_a+ on the relation so that no more relations can be chained after it is called.
+    #
+    # Example:
+    #
+    #   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
+        to_a
+      end
+    end
+  end
+  
+  # Class methods mixed into an ActiveRecord model that includes LastModCache.
+  module ClassMethods
+    # Find all records that match a query and store it in the cache. The cache entry will be invalidated whenever
+    # the +updated_at+ column is advanced on any record in the table.
+    #
+    # The +options+ parameter can contain any options allowed in the +all+ method with the addition of a
+    # <tt>:cache</tt> option which can be used to pass options to the cache itself.
+    def all_with_cache(options = {}, &block)
+      options = deep_clone(options)
+      cache_options, options = extract_cache_options(options)
+      block ||= lambda{ all(options) }
+      Proxy.new do
+        max_updated_at, count = max_updated_at_and_count
+        records = last_mod_cache.fetch(updated_at_cache_key(:all_with_cache, options, max_updated_at, count), cache_options, &block)
+        records.freeze
+      end
+    end
+    
+    # Find the first that matches a query and store it in the cache. The cache entry will be invalidated whenever
+    # the +updated_at+ column on that record is changed.
+    #
+    # The +options+ parameter can contain any options allowed in the +first+ method with the addition of a
+    # <tt>:cache</tt> option which can be used to pass options to the cache itself.
+    def first_with_cache(options = {}, &block)
+      options = deep_clone(options)
+      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 }
+        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
+    end
+    
+    # Find a record by id or ids in database and store it in the cache. The cache entry will be invalidated whenever
+    # the +updated_at+ column on that record is changed.
+    #
+    # The +options+ parameter can contain any options allowed in the +first+ method with the addition of a
+    # <tt>:cache</tt> option which can be used to pass options to the cache
+    def find_with_cache(id_or_ids, options = nil)
+      options = options ? deep_clone(options) : {}
+      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)
+      else
+        first_with_cache(options.merge(:conditions => {:id => id_or_ids}, :cache => cache_options), &finder)
+      end
+    end
+    
+    # Get the cache configuration for the class.
+    def last_mod_cache_config
+      if defined?(@last_mod_cache_config) && @last_mod_cache_config
+        @last_mod_cache_config
+      else
+        superclass.last_mod_cache_config if superclass.respond_to?(:last_mod_cache_config)
+      end
+    end
+    
+    # Hook into method_missing to add "_with_cache" as a suffix to dynamic finder methods.
+    def method_missing_with_last_mod_cache(method, *args, &block) #:nodoc:
+      match = method.to_s.match(DYNAMIC_FINDER_METHOD_PATTERN)
+      if match
+        finder_column_names = match[2].split("_and_")
+        finder_values = args.dup
+        options = finder_values.extract_options!
+        
+        unless finder_column_names.size == finder_values.size
+          raise ArgumentError.new("wrong number of arguments (#{finder_values.size} for #{finder_column_names.size})")
+        end
+        
+        unless (column_names & finder_column_names).size == finder_column_names.size
+          raise NoMethodError.new("dynamic finder #{method} does not exist on #{name}")
+        end
+        
+        conditions = {}
+        finder_column_names.zip(finder_values).each do |col, val|
+          conditions[col] = val
+        end
+        options = options.merge(:conditions => conditions)
+        match[1] ? all_with_cache(options) : first_with_cache(options)
+      else
+        method_missing_without_last_mod_cache(method, *args, &block)
+      end
+    end
+    
+    private
+    
+    # Construct a cache key based on a timestamp.
+    def updated_at_cache_key(method, options, timestamp, row_count = nil)
+      key = options.merge(:class => name, :method => method, :updated_at => timestamp.to_f)
+      key[:row_count] = row_count if row_count
+      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)
+      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)
+      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)
+        [result['id'], updated_at]
+      else
+        []
+      end
+    end
+    
+    # Pull the :cache options from the options hash.
+    def extract_cache_options(options)
+      if options.include?(:cache)
+        options.dup
+        cache_options = options.delete(:cache)
+        [cache_options, options]
+      else
+        [{}, options]
+      end
+    end
+    
+    # Create a deep clone of a hash where all values are cloned as well. This is used
+    # to isolate any hash values sent to a Proxy object so that the values can't be changed
+    # after the Proxy is created.
+    def deep_clone(obj)
+      case obj
+      when Hash
+        clone = {}
+        obj.each do |k, v|
+          clone[k] = deep_clone(v)
+        end
+        obj = clone
+      when Array
+        obj.collect{|a| deep_clone(a)}
+      when String
+        obj.clone
+      else
+        obj
+      end
+    end
+  end
+  
+  module InstanceMethods
+    # Force an update to the timestamp column. This method can be invoked to force cache entries to expire.
+    # Validations and callbacks will *not* be called. If you need those called, simply call +update_attribute+ instead.
+    def update_timestamp!
+      col_name = self.class.updated_at_column
+      self.send("#{col_name}=", Time.now)
+      timestamp = self.send(col_name)
+      conn = self.class.connection
+      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
+  end
+  
+  # Proxy class that sends all method calls to a block.
+  class Proxy #:nodoc:
+    required_methods = {"__send__" => true, "__id__" => true}
+    instance_methods.each do |m|
+      undef_method(m) unless required_methods.include?(m.to_s)
+    end
+    
+    def initialize(&block)
+      @block = block
+    end
+    
+    def method_missing(method, *args, &block)
+      @object = @block.call unless defined?(@object)
+      @object.send(method, *args, &block)
+    end
+  end
+end

data/spec/last_mod_cache_spec.rb

@@ -0,0 +1,608 @@
+require 'spec_helper'
+
+describe LastModCache do
+  before :each do
+    LastModCache::Test::ModelOne.delete_all
+    LastModCache::Test::ModelTwo.delete_all
+    LastModCache::Test::ModelThree.delete_all
+    LastModCache::Test::ModelFour.delete_all
+    Rails.cache.clear
+    LastModCache::Test.cache.clear
+  end
+  
+  let(:model_one_record_one){LastModCache::Test::ModelOne.create!(:name => "one", :value => 1)}
+  let(:model_one_record_two){LastModCache::Test::ModelOne.create!(:name => "two", :value => 2)}
+  let(:model_one_record_three){LastModCache::Test::ModelOne.create!(:name => "three", :value => 3)}
+  
+  let(:model_two_record_one){LastModCache::Test::ModelTwo.create!(:name => "one", :value => 1)}
+  let(:model_two_record_two){LastModCache::Test::ModelTwo.create!(:name => "two", :value => 2)}
+  let(:model_two_record_three){LastModCache::Test::ModelTwo.create!(:name => "three", :value => 3)}
+  
+  let(:model_three_record_one){LastModCache::Test::ModelThree.create!(:name => "one", :value => 1)}
+  let(:model_three_record_two){LastModCache::Test::ModelThree.create!(:name => "two", :value => 2)}
+  let(:model_three_record_three){LastModCache::Test::ModelThree.create!(:name => "three", :value => 3)}
+  
+  let(:model_four_record_one){LastModCache::Test::ModelFour.create!(:name => "one", :value => 1)}
+  let(:model_four_record_two){LastModCache::Test::ModelFour.create!(:name => "two", :value => 2)}
+  let(:model_four_record_three){LastModCache::Test::ModelFour.create!(:name => "three", :value => 3)}
+  
+  context "configuration" do
+    it "should use Rails.cache by default" do
+      LastModCache::Test::ModelOne.last_mod_cache.should == Rails.cache
+    end
+    
+    it "should be able to set the cache" do
+      LastModCache::Test::ModelTwo.last_mod_cache.should == LastModCache::Test.cache
+    end
+    
+    it "should inherit the cache from a parent class" do
+      LastModCache::Test::ModelThree.last_mod_cache.should == LastModCache::Test.cache
+    end
+    
+    it "should use update_at as the default updated at column" do
+      LastModCache::Test::ModelOne.updated_at_column.should == :updated_at
+    end
+    
+    it "should be able to set the updated at column" do
+      LastModCache::Test::ModelTwo.updated_at_column.should == :modified_at
+    end
+    
+    it "should inherit the updated at column from a parent class" do
+      LastModCache::Test::ModelThree.updated_at_column.should == :modified_at
+    end
+  end
+
+  context "updating the timestamp" do
+    it "should update" do
+      t = model_one_record_one.updated_at
+      model_one_record_one.update_timestamp!
+      model_one_record_one.updated_at.should > t
+      model_one_record_one.reload
+      model_one_record_one.updated_at.should > t
+    end
+    
+    it "should update when using a custom update at column" do
+      t = model_two_record_one.modified_at
+      model_two_record_one.update_timestamp!
+      model_two_record_one.modified_at.should > t
+      model_two_record_one.reload
+      model_two_record_one.modified_at.should > t
+    end
+    
+    it "should update when using a non-datetime column" do
+      t = model_four_record_one.last_modified
+      model_four_record_one.update_timestamp!
+      model_four_record_one.last_modified.should > t
+      model_four_record_one.reload
+      model_four_record_one.last_modified.should > t
+    end
+  end
+  
+  context "find all" do
+    before :each do
+      model_one_record_one
+      model_one_record_two
+      model_one_record_three
+    end
+    
+    it "should find all records with a query and put them in the cache" do
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :conditions => {:name => ["one", "two"]}, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3}
+      LastModCache::Test::ModelOne.all_with_cache(:conditions => {:name => ["one", "two"]}).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 all records with a query from the cache" do
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :conditions => {:name => ["one", "two"]}, :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_two.id, :value, 0)
+      LastModCache::Test::ModelOne.all_with_cache(:conditions => {:name => ["one", "two"]}).collect{|r| r.value}.should == [1, 2]
+    end
+    
+    it "should pass :cache option through to the cache" do
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :conditions => {:name => ["two"]}, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3}
+      Rails.cache.write(cache_key, [model_one_record_two], :namespace => "test")
+      LastModCache::Test::ModelOne.poke_column_value(model_one_record_two.id, :value, 0)
+      LastModCache::Test::ModelOne.all_with_cache(:cache => {:namespace => "test"}, :conditions => {:name => ["two"]}).collect{|r| r.value}.should == [2]
+    end
+    
+    it "should invalidate a find all cache whenever any record is modified" do
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :conditions => {:name => ["one", "two"]}, :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_two.id, :value, 0)
+      model_one_record_three.update_attribute(:value, 4)
+      LastModCache::Test::ModelOne.all_with_cache(:conditions => {:name => ["one", "two"]}).collect{|r| r.value}.should == [1, 0]
+    end
+    
+    it "should invalidate a find all cache whenever any record is deleted" do
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :conditions => {:name => ["two", "three"]}, :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_two.id, :value, 0)
+      model_one_record_one.destroy
+      LastModCache::Test::ModelOne.all_with_cache(:conditions => {:name => ["two", "three"]}).collect{|r| r.value}.should == [0, 3]
+    end
+    
+    it "should work with models that don't use the defaults" do
+      model_two_record_one
+      model_two_record_two
+      model_two_record_three
+      
+      timestamp = Time.now - 60
+      LastModCache::Test::ModelTwo.poke_column_value(model_two_record_two.id, :modified_at, timestamp)
+      model_two_record_two.reload
+      LastModCache::Test::ModelTwo.all_with_cache(:conditions => {:name => "two"}).collect{|r| r.value}.should == [2]
+      
+      cache_key = {:class => "LastModCache::Test::ModelTwo", :method => :all_with_cache, :updated_at => LastModCache::Test::ModelTwo.maximum(:modified_at).to_f, :conditions => {:name => "two"}, :row_count => 3}
+      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.all_with_cache(:conditions => {:name => "two"}).collect{|r| r.value}.should == [2]
+      
+      model_two_record_two.update_attribute(:value, 5)
+      model_two_record_two.reload
+      LastModCache::Test::ModelTwo.all_with_cache(:conditions => {:name => "two"}).collect{|r| r.value}.should == [5]
+      LastModCache::Test.cache.read(cache_key.merge(:updated_at => LastModCache::Test::ModelTwo.maximum(:modified_at).to_f)).should == [model_two_record_two]
+    end
+    
+    it "should work with a numeric timestamp column" do
+      model_four_record_one
+      model_four_record_two
+      model_four_record_three
+      
+      cache_key = {:class => "LastModCache::Test::ModelFour", :method => :all_with_cache, :updated_at => LastModCache::Test::ModelFour.maximum(:last_modified), :conditions => {:name => "two"}, :row_count => 3}
+      Rails.cache.write(cache_key, [model_four_record_two.dup])
+      LastModCache::Test::ModelFour.poke_column_value(model_four_record_two.id, :value, 0)
+      LastModCache::Test::ModelFour.all_with_cache(:conditions => {:name => "two"}).collect{|r| r.value}.should == [2]
+      
+      model_four_record_two.update_attribute(:value, 5)
+      model_four_record_two.reload
+      LastModCache::Test::ModelFour.all_with_cache(:conditions => {:name => "two"}).collect{|r| r.value}.should == [5]
+      Rails.cache.read(cache_key.merge(:updated_at => LastModCache::Test::ModelFour.maximum(:last_modified).to_f)).should == [model_four_record_two]
+    end
+    
+    it "should be lazy loaded" do
+      Rails.cache.should_not_receive(:read)
+      Rails.cache.should_not_receive(:write)
+      LastModCache::Test::ModelOne.should_not_receive(:connection)
+      LastModCache::Test::ModelOne.all_with_cache(:conditions => {:name => ["one", "two"]})
+      nil
+    end
+    
+    it "should always return a frozen object" do
+      LastModCache::Test::ModelOne.all_with_cache(:conditions => {:name => "two"}).should be_frozen
+      LastModCache::Test::ModelOne.all_with_cache(:conditions => {:name => "four"}).should be_frozen
+    end
+    
+    it "should not require any options" do
+      LastModCache::Test::ModelOne.all_with_cache.should == LastModCache::Test::ModelOne.all
+    end
+  end
+  
+  context "find one by query" do
+    before :each do
+      model_one_record_one
+      model_one_record_two
+      model_one_record_three
+    end
+    
+    it "should find a single record with a query and put it in the cache" do
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :first_with_cache, :updated_at => model_one_record_two.updated_at.to_f, :conditions => {:name => "two"}}
+      LastModCache::Test::ModelOne.first_with_cache(:conditions => {:name => "two"}).should == model_one_record_two
+      Rails.cache.read(cache_key).should == model_one_record_two
+    end
+    
+    it "should find a single record with a query from the cache" do
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :first_with_cache, :updated_at => model_one_record_two.updated_at.to_f, :conditions => {:name => "two"}}
+      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.first_with_cache(:conditions => {:name => "two"}).value.should == 2
+    end
+    
+    it "should invalidate a single record query cache entry when the record is modified" do
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :first_with_cache, :updated_at => model_one_record_two.updated_at.to_f, :conditions => {:name => "two"}}
+      Rails.cache.write(cache_key, model_one_record_two)
+      model_one_record_two.update_attribute(:value, 0)
+      LastModCache::Test::ModelOne.first_with_cache(:conditions => {:name => "two"}).value.should == 0
+    end
+    
+    it "should not find a record by query if the updated time for the record could not be found" do
+      LastModCache::Test::ModelOne.first_with_cache(:conditions => {:name => "not found"}).should == nil
+    end
+    
+    it "should not find a record by query if it has been deleted since it was cached" do
+      model_one_record_two
+      LastModCache::Test::ModelOne.first_with_cache(:conditions => {:name => "two"}).should == model_one_record_two
+      model_one_record_two.destroy
+      LastModCache::Test::ModelOne.first_with_cache(:conditions => {:name => "two"}).should == nil
+    end
+    
+    it "should work with models that don't use the defaults" do
+      model_four_record_one
+      model_four_record_two
+      model_four_record_three
+      
+      timestamp = Time.now - 60
+      LastModCache::Test::ModelTwo.poke_column_value(model_two_record_two.id, :modified_at, timestamp)
+      model_two_record_two.reload
+      LastModCache::Test::ModelTwo.first_with_cache(:conditions => {:name => "two"}).value.should == 2
+      
+      cache_key = {:class => "LastModCache::Test::ModelTwo", :method => :first_with_cache, :updated_at => timestamp.to_f, :conditions => {:name => "two"}}
+      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.first_with_cache(:conditions => {:name => "two"}).value.should == 2
+      
+      model_two_record_two.update_attribute(:value, 5)
+      model_two_record_two.reload
+      LastModCache::Test::ModelTwo.first_with_cache(:conditions => {:name => "two"}).value.should == 5
+      LastModCache::Test.cache.read(cache_key.merge(:updated_at => model_two_record_two.modified_at.to_f)).should == model_two_record_two
+    end
+    
+    it "should work with a numeric timestamp column" do
+      model_four_record_one
+      model_four_record_two
+      model_four_record_three
+      
+      cache_key = {:class => "LastModCache::Test::ModelFour", :method => :first_with_cache, :updated_at => model_four_record_two.last_modified, :conditions => {:name => "two"}}
+      Rails.cache.write(cache_key, model_four_record_two.dup)
+      LastModCache::Test::ModelFour.poke_column_value(model_four_record_two.id, :value, 0)
+      LastModCache::Test::ModelFour.first_with_cache(:conditions => {:name => "two"}).value.should == 2
+      
+      model_four_record_two.update_attribute(:value, 5)
+      model_four_record_two.reload
+      LastModCache::Test::ModelFour.first_with_cache(:conditions => {:name => "two"}).value.should == 5
+      Rails.cache.read(cache_key.merge(:updated_at => model_four_record_two.last_modified)).should == model_four_record_two
+    end
+    
+    it "should be lazy loaded" do
+      Rails.cache.should_not_receive(:read)
+      Rails.cache.should_not_receive(:write)
+      LastModCache::Test::ModelOne.should_not_receive(:connection)
+      LastModCache::Test::ModelOne.first_with_cache(:conditions => {:name => "two"})
+      nil
+    end
+    
+    it "should always return a frozen object or nil" do
+      LastModCache::Test::ModelOne.first_with_cache(:conditions => {:name => "two"}).should be_frozen
+      LastModCache::Test::ModelOne.first_with_cache(:conditions => {:name => "four"}).should == nil
+    end
+    
+    it "should not require any options" do
+      LastModCache::Test::ModelOne.first_with_cache.should == LastModCache::Test::ModelOne.first
+    end
+  end
+  
+  context "find by id" do
+    before :each do
+      model_one_record_one
+      model_one_record_two
+      model_one_record_three
+    end
+    
+    it "should find a single record by id and put it in the cache" 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}
+      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}
+      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}
+      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
+    end
+    
+    it "should find multiple records by id and put them in the cache" 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}
+      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}
+      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}
+      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}
+      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)
+      model_one_record_two.destroy
+      LastModCache::Test::ModelOne.find_with_cache([model_one_record_one.id, model_one_record_three.id]).first.value.should == 0
+    end
+    
+    it "should raise a RecordNotFound error if a record could not be found" do
+      lambda{LastModCache::Test::ModelOne.find_with_cache(-1).nil?}.should raise_error(ActiveRecord::RecordNotFound)
+    end
+    
+    it "should raise a RecordNotFound error if any of the records can't be found" do
+      lambda{LastModCache::Test::ModelOne.find_with_cache([model_one_record_one.id, -1]).nil?}.should raise_error(ActiveRecord::RecordNotFound)
+    end
+    
+    it "should raise a RecordNotFound error if the record has been deleted since it was cached" do
+      model_one_record_two
+      LastModCache::Test::ModelOne.find_with_cache(model_one_record_two.id).should == model_one_record_two
+      model_one_record_two.destroy
+      lambda{LastModCache::Test::ModelOne.find_with_cache(model_one_record_two.id).nil?}.should raise_error(ActiveRecord::RecordNotFound)
+    end
+    
+    it "should work with models that don't use the defaults" do
+      model_four_record_one
+      model_four_record_two
+      model_four_record_three
+      
+      timestamp = Time.now - 60
+      LastModCache::Test::ModelTwo.poke_column_value(model_two_record_two.id, :modified_at, timestamp)
+      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}
+      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
+      
+      model_two_record_two.update_attribute(:value, 5)
+      model_two_record_two.reload
+      LastModCache::Test::ModelTwo.find_with_cache(model_two_record_two.id).value.should == 5
+      LastModCache::Test.cache.read(cache_key.merge(:updated_at => model_two_record_two.modified_at.to_f)).should == model_two_record_two
+    end
+    
+    it "should be lazy loaded" do
+      Rails.cache.should_not_receive(:read)
+      Rails.cache.should_not_receive(:write)
+      LastModCache::Test::ModelOne.should_not_receive(:connection)
+      LastModCache::Test::ModelOne.find_with_cache(model_one_record_two.id)
+      LastModCache::Test::ModelOne.find_with_cache([model_one_record_one.id, model_one_record_two.id])
+      nil
+    end
+  end
+  
+  context "dynamic query methods" do
+    before :each do
+      model_one_record_one
+      model_one_record_two
+      model_one_record_three
+    end
+    
+    it "should pass dynamic find methods through the cache" do
+      relation = LastModCache::Test::ModelOne.where(:name => "two").limit(1)
+      LastModCache::Test::ModelOne.find_by_name_with_cache("two").should == model_one_record_two
+      timestamp = model_one_record_two.updated_at
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :first_with_cache, :updated_at => timestamp.to_f, :conditions => {"name" => "two"}}
+      Rails.cache.read(cache_key).should == model_one_record_two
+    end
+    
+    it "should pass dynamic find_all methods through the cache" do
+      LastModCache::Test::ModelOne.find_all_by_name_with_cache("two").should == [model_one_record_two]
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3, :conditions => {"name" => "two"}}
+      Rails.cache.read(cache_key).should == [model_one_record_two]
+    end
+    
+    it "should pass dynamic find methods with multiple conditions through the cache" do
+      model_one_record_one.update_attribute(:name, "two")
+      model_one_record_three.update_attribute(:name, "two")
+      LastModCache::Test::ModelOne.find_by_name_and_value_with_cache("two", 2).should == model_one_record_two
+      timestamp = model_one_record_two.updated_at
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :first_with_cache, :updated_at => timestamp.to_f, :conditions => {"name" => "two", "value" => 2}}
+      Rails.cache.read(cache_key).should == model_one_record_two
+    end
+    
+    it "should pass dynamic find_all methods with multiple conditions through the cache" do
+      model_one_record_one.update_attribute(:name, "two")
+      model_one_record_three.update_attribute(:name, "two")
+      LastModCache::Test::ModelOne.find_all_by_name_and_value_with_cache("two", 2).should == [model_one_record_two]
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :all_with_cache, :updated_at => LastModCache::Test::ModelOne.maximum(:updated_at).to_f, :row_count => 3, :conditions => {"name" => "two", "value" => 2}}
+      Rails.cache.read(cache_key).should == [model_one_record_two]
+    end
+    
+    it "should not interfere with normal method missing behavior" do
+      LastModCache::Test::ModelOne.find_by_name("one").should == model_one_record_one
+      LastModCache::Test::ModelOne.find_by_name_and_value("one", 1).should == model_one_record_one
+      lambda{ LastModCache::Test::ModelOne.this_is_not_a_method }.should raise_error(NoMethodError)
+    end
+    
+    it "should raise an error when the wrong number of arguments are passed" do
+      lambda{ LastModCache::Test::ModelOne.find_by_name_with_cache("one", 1) }.should raise_error(ArgumentError)
+      lambda{ LastModCache::Test::ModelOne.find_by_name_with_cache }.should raise_error(ArgumentError)
+    end
+    
+    it "should raise an error if a column doesn not exist" do
+      lambda{ LastModCache::Test::ModelOne.find_by_fleevium_with_cache("bloork") }.should raise_error(NoMethodError)
+      lambda{ LastModCache::Test::ModelOne.find_by_name_and_stuff_with_cache("one", :x) }.should raise_error(NoMethodError)
+    end
+    
+    it "should be lazy loaded" do
+      Rails.cache.should_not_receive(:read)
+      Rails.cache.should_not_receive(:write)
+      LastModCache::Test::ModelOne.should_not_receive(:connection)
+      LastModCache::Test::ModelOne.find_by_name_and_value_with_cache("one", 1)
+      LastModCache::Test::ModelOne.find_all_by_name_with_cache("one")
+      nil
+    end
+  end
+  
+  context ActiveRecord::Relation do
+    before :each do
+      model_one_record_one
+      model_one_record_two
+      model_one_record_three
+    end
+    
+    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}
+      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]
+    end
+    
+    it "should cache the result using bind variables if supported" do
+      name_column = LastModCache::Test::ModelOne.columns_hash["name"]
+      relation = LastModCache::Test::ModelOne.where("name IN (?, ?)")
+      if relation.respond_to?(:bind_values)
+        bind_relation = relation.bind([name_column, "one"]).bind([name_column, "two"]).order("value DESC")
+        bind_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 => bind_relation.to_sql, :bind_values => ["one", "two"]}
+        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])
+        bind_relation.with_cache.should == [model_one_record_one, model_one_record_three]
+      else
+        pending("ActiveRecord #{ActiveRecord::VERSION::STRING} does not support bind variables")
+      end
+    end
+    
+    it "should be lazy loaded" do
+      Rails.cache.should_not_receive(:read)
+      Rails.cache.should_not_receive(:write)
+      LastModCache::Test::ModelOne.should_not_receive(:connection)
+      LastModCache::Test::ModelOne.where(:name => "one").with_cache
+      nil
+    end
+  end
+  
+  context "eager load associations" do
+    before :each do
+      model_one_record_one.widget = LastModCache::Test::Widget.create!(:name => "widget_1")
+      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
+    end
+    
+    let(:includes){ [:widget, {:things => :widget}] }
+    
+    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]
+      cached = Rails.cache.read(cache_key).first
+      if cached.respond_to?(:association)
+        cached.association(:widget).loaded?.should == true
+        cached.association(:things).loaded?.should == true
+        cached.things.first.association(:widget).loaded?.should == true
+      else
+        cached.widget.loaded?.should == true
+        cached.things.loaded?.should == true
+      end
+    end
+    
+    it "should cache included associations when finding one record" do
+      cache_key = {:class => "LastModCache::Test::ModelOne", :method => :first_with_cache, :conditions => {:name => "one"}, :include => includes, :updated_at => model_one_record_one.updated_at.to_f}
+      LastModCache::Test::ModelOne.first_with_cache(:conditions => {:name => "one"}, :include => includes).should == model_one_record_one
+      cached = Rails.cache.read(cache_key)
+      if cached.respond_to?(:association)
+        cached.association(:widget).loaded?.should == true
+        cached.association(:things).loaded?.should == true
+        cached.things.first.association(:widget).loaded?.should == true
+      else
+        cached.widget.loaded?.should == true
+        cached.things.loaded?.should == true
+      end
+    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}
+      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)
+        cached.association(:widget).loaded?.should == true
+        cached.association(:things).loaded?.should == true
+        cached.things.first.association(:widget).loaded?.should == true
+      else
+        cached.widget.loaded?.should == true
+        cached.things.loaded?.should == true
+      end
+    end
+    
+    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}
+      cached = Rails.cache.read(cache_key).first
+      if cached.respond_to?(:association)
+        cached.association(:widget).loaded?.should == true
+        cached.association(:things).loaded?.should == true
+        cached.things.first.association(:widget).loaded?.should == true
+      else
+        cached.widget.loaded?.should == true
+        cached.things.loaded?.should == true
+      end
+    end
+    
+    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}
+      cached = Rails.cache.read(cache_key).first
+      if cached.respond_to?(:association)
+        cached.association(:widget).loaded?.should == true
+        cached.association(:things).loaded?.should == true
+        cached.things.first.association(:widget).loaded?.should == true
+      else
+        cached.widget.loaded?.should == true
+        cached.things.loaded?.should == true
+      end
+    end
+    
+    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}
+      cached = Rails.cache.read(cache_key).first
+      if cached.respond_to?(:association)
+        cached.association(:widget).loaded?.should == true
+        cached.association(:things).loaded?.should == true
+        cached.things.first.association(:widget).loaded?.should == true
+      else
+        cached.widget.loaded?.should == true
+        cached.things.loaded?.should == true
+      end
+    end
+  end
+  
+  context LastModCache::Proxy 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
+    end
+    
+    it "should only evaluate the block once" do
+      proxy = LastModCache::Proxy.new{ Object.new }
+      proxy.object_id.should == proxy.object_id
+    end
+    
+    it "should lazy evaluate the block" do
+      proxy = LastModCache::Proxy.new{ raise "never get here" }
+    end
+    
+    it "should handle missing methods" do
+      proxy = LastModCache::Proxy.new{ Object.new }
+      lambda{ proxy.not_a_method }.should raise_error(NoMethodError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,135 @@
+require 'sqlite3'
+
+active_record_version = ENV["ACTIVE_RECORD_VERSION"] || [">= 3.0.0"]
+active_record_version = [active_record_version] unless active_record_version.is_a?(Array)
+gem 'activerecord', *active_record_version
+
+require File.expand_path("../../lib/last_mod_cache.rb", __FILE__)
+
+puts "Testing with activerecord #{ActiveRecord::VERSION::STRING}"
+
+module Rails
+  def self.cache
+    unless defined?(@cache)
+      @cache = ActiveSupport::Cache::MemoryStore.new
+    end
+    @cache
+  end
+end
+
+module LastModCache
+  module Test
+    class << self
+      def setup
+        ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+        Thing.setup
+        Widget.setup
+        ModelOne.setup
+        ModelTwo.setup
+        ModelFour.setup
+      end
+      
+      def cache
+        unless defined?(@cache)
+          @cache = ActiveSupport::Cache::MemoryStore.new
+        end
+        @cache
+      end
+    end
+    
+    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]
+        connection.update(sanitize_sql_array(sql))
+      end
+    end
+    
+    class Thing < ActiveRecord::Base
+      belongs_to :widget
+      
+      class << self
+        def setup
+          connection.create_table(table_name) do |t|
+            t.string :name
+            t.integer :model_one_id
+            t.integer :widget_id
+            t.datetime :updated_at
+          end
+        end
+      end
+    end
+    
+    class Widget < ActiveRecord::Base
+      class << self
+        def setup
+          connection.create_table(table_name) do |t|
+            t.string :name
+            t.datetime :updated_at
+          end
+        end
+      end
+    end
+    
+    class ModelOne < ActiveRecord::Base
+      extend PokeRecordValue
+      include LastModCache
+      
+      has_many :things
+      belongs_to :widget
+      
+      class << self
+        def setup
+          connection.create_table(table_name) do |t|
+            t.string :name
+            t.integer :value
+            t.integer :widget_id
+            t.datetime :updated_at
+          end
+        end
+      end
+    end
+
+    class ModelTwo < ActiveRecord::Base
+      extend PokeRecordValue
+      include LastModCache
+      self.updated_at_column = :modified_at
+      self.last_mod_cache = Test.cache
+      
+      before_save{|r| r.modified_at = Time.now}
+      
+      class << self
+        def setup
+          connection.create_table(table_name) do |t|
+            t.string :name
+            t.integer :value
+            t.string :type
+            t.datetime :modified_at
+          end
+        end
+      end
+    end
+    
+    class ModelThree < ModelTwo
+    end
+
+    class ModelFour < ActiveRecord::Base
+      extend PokeRecordValue
+      include LastModCache
+      self.updated_at_column = :last_modified
+      
+      before_save{|r| r.last_modified = Time.now.to_f}
+      
+      class << self
+        def setup
+          connection.create_table(table_name) do |t|
+            t.string :name
+            t.integer :value
+            t.float :last_modified
+          end
+        end
+      end
+    end
+  end
+end
+
+LastModCache::Test.setup

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification 
+name: last_mod_cache
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Brian Durand
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-05 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: An extension for ActiveRecord models that adds a a very easy to use caching layer for models that include an updated at column.
+email: 
+- bdurand@embellishedvisions.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT_LICENSE
+files: 
+- README.rdoc
+- VERSION
+- Rakefile
+- MIT_LICENSE
+- lib/last_mod_cache.rb
+- spec/last_mod_cache_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/bdurand/last_mod_cache
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: An extension for ActiveRecord models that adds a very easy to use caching layer for models that include an updated at column.
+test_files: []
+