arid_cache 1.0.4 → 1.1.0

data/.gitignore

@@ -17,6 +17,8 @@ tmtags
 coverage
 rdoc
 pkg
+Gemfile.lock
+.bundle/*
 
 ## PROJECT::SPECIFIC
 test/**/*.log

data/README.rdoc

@@ -6,9 +6,29 @@ AridCache supports caching large, expensive ActiveRecord collections by caching
 
 AridCache simplifies caching by supporting auto-expiring cache keys - as well as common options like <tt>:expires_in</tt> - and provides methods to help you manage your caches at the global, model class, model instance and per-cache level.
 
+== Changes
+
+v1.0.5: Support <tt>:raw</tt> and <tt>:clear</tt> options.
+
 == Install
 
-Add this to your <tt>config/environment.rb</tt> file:
+<b>Rails 3:</b>
+
+Add the gem to your `Gemfile`
+
+  gem 'arid_cache'
+
+Then
+
+  bundle install
+
+For some reason AridCache is not being included into ActiveRecord, so add the following to an initializer to get around that until I fix it:
+
+  AridCache.init_rails
+
+<b>Rails 2:</b>
+
+Add the gem to your <tt>config/environment.rb</tt> file:
 
   config.gem 'arid_cache'
 
@@ -16,8 +36,6 @@ Then
 
   rake gems:install
 
-(Requires having GemCutter in your gem sources.)
-
 == Introduction
 
 The name AridCache comes from <b>A</b>ctive<b>R</b>ecord *ID* Cache.  It's also very DRY...get it? :)
@@ -148,7 +166,7 @@ Or via the cache configuration:
     top_tracks(:auto_expire => true)
   end
 
-If you need to examine values in the cache yourself you can build the AridCache key by calling <tt>arid_cache_key('method')</tt> on your object.  Using the examples above we would call,
+If you need to examine values in the cache yourself you can build the AridCache key by calling <tt>arid_cache_key('method')</tt> on your object, whether it is a class or instance.  Using the examples above we would call,
 
   Album.arid_cache_key('featured_albums') => arid-cache-album-featured_albums
   album.arid_cache_key('top_tracks')      => arid-cache-albums/2-top_tracks
@@ -174,7 +192,12 @@ Alternatively you can pass a <b><tt>:force => true</tt></b> option in your <tt>c
   Album.cached_featured_albums(:force => true)  => returns featured albums
   album.cached_top_tracks(:force => true)       => returns top tracks
 
-You can pass an <b><tt>:expires_in</tt></b> option to your caches to manage your cache expiry (if your cache store supports this option).
+If you just want to clear a cache without forcing a refresh pass <b><tt>:clear => true</tt></b>.  The cached value will be deleted with no unnecessary queries or cache reads being performed.  It is safe to pass this option even if there is nothing in the cache yet.  The method returns the result of calling <tt>delete</tt> on your cache object.  For example:
+
+    Album.cached_featured_albums(:clear => true)  => returns false
+    Rails.cache.read(Album.arid_cache_key(:featured_albums)) => returns nil
+
+You can pass an <b><tt>:expires_in</tt></b> option to your caches to manage your cache expiry (if your cache store supports this option, which most do).
 
   Album.cached_featured_albums(:expires_in => 1.day)
   album.cached_top_tracks(:expires_in => 1.day)
@@ -186,7 +209,7 @@ Or via the cache configuration,
     featured_albums
   end
 
-If you would like to be able to pass more options to your cache store (like <tt>:raw</tt>, <tt>:unless_exist</tt>, etc), just add them to the <tt>AridCache::CacheProxy::OPTIONS_FOR_CACHE</tt> class constant, for example
+If you would like to be able to pass more options to your cache store (like <tt>:unless_exists</tt>, etc), just add them to the <tt>AridCache::CacheProxy::OPTIONS_FOR_CACHE</tt> class constant, for example
 
   AridCache::CacheProxy::OPTIONS_FOR_CACHE.push(:raw, :unless_exist)
 
@@ -224,6 +247,9 @@ An advantage of using AridCache is that since we already have the size of the co
 
 To paginate just pass a <tt>:page</tt> option in your call to <tt>cached_</tt>.  If you don't pass a value for <tt>:per_page</tt> AridCache gets the value from <tt>Model.per_page</tt>, which is what <tt>WillPaginate</tt> uses.
 
+The supported pagination options are:
+  :page, :per_page, :total_entries, :finder
+
 Some examples of pagination:
 
   User.cached_active(:page => 1, :per_page => 30)
@@ -263,14 +289,59 @@ You apply <tt>:limit</tt> and <tt>:offset</tt> options in a similar manner to th
 
 === Other Options to <tt>find</tt>
 
+The supported options to <tt>find</tt> are:
+  :conditions, :include, :joins, :limit, :offset, :order,
+  :select, :readonly, :group, :having, :from, :lock
+
 You can pass options like <tt>:include</tt> (or any other valid <tt>find</tt> options) to augment the results of your cached query.  Just because all of the options are supported, does not mean it's a good idea to use them, though.  Take a look at your logs to see how AridCache is interacting with the cache and the database if you don't get the results you expect.
 
-For example, assume we have a <tt>named_scope :active</tt> on <tt>User</tt> which gives the active users.  We can call:
+For example, we could call:
+
+  User.cached_active(:page => 2, :per_page => 10, :include => :preferences)
+
+To return page two of the active users, with the <tt>preferences</tt> association eager-loaded for all the users.
+
+=== Accessing the cached IDs directly
+
+Sometimes you may want to access the cached list of record IDs without instantiating all the records.  This can be useful, for example, to determine if a particular track belongs to a user's favorite tracks.  If we have cached the list of favorite tracks, we just need to determine whether the track's ID appears in the cached list of IDs.
+
+The cached result is a <tt>AridCache::CacheProxy::Result</tt> and can be accessed by passing the <b><tt>:raw => true</tt></b> option in your cached call.  The <tt>AridCache::CacheProxy::Result</tt> is a type of <tt>Struct</tt> with methods to return the <tt>ids</tt>, <tt>count</tt> and <tt>klass</tt> of the cached records.
+
+Note that passing the <tt>:raw</tt> option to your cache store is not supported, because the AridCache option shares the same name.  If you really want to get the marshalled result from your cache you will have to use <tt>cache.read</tt>, manually passing in the AridCache key and <tt>:raw</tt> option.
+
+Usage example:
 
-  User.cached_active.paginate(:page => 2, :per_page => 10, :include => :preferences)
-  User.cached_active(:limit => 10, :offset => 10, :include => :preferences)
+  user = User.first
+  user.cached_favorite_tracks  => returns [#<Track:1>, #<Track:2>]
+  user.cached_favorite_tracks(:raw => true) => returns
+      {
+        :klass => "Track",  # stored as a string
+        :count => 1,
+          :ids => [1, 2]
+      }
+  user.cached_favorite_tracks(:raw => true).ids => returns [1, 2]
 
-(These calls return similar results, except that the first call returns a <tt>WillPaginate::Collection</tt> and the second just returns an <tt>Array</tt>.)
+The cache will be primed if it is empty, so you can be sure that it will always return a <tt>AridCache::CacheProxy::Result</tt>.
+
+In some circumstances - like when you are querying on a named scope - if you have only requested a count, only the count is computed, which means the ids array is <tt>nil</tt>.  When you call your cached method passing in <tt>:raw => true</tt> AridCache detects that the ids array has not yet been set, so in this case it will perform a query to seed the ids array before returning the result.  This can be seen in the following example:
+
+  class User
+    named_scope :guests, :conditions => { :account_type => ['guest'] }
+  end
+
+  User.cached_guests_count => returns 4
+  Rails.cache.read(User.arid_cache_key(:guests)) => returns
+    {
+      :klass => "User",
+      :count => 4,
+        :ids => nil                 # notice the ids array is nil in the cache
+    }
+  User.cached_guests(:raw => true) => returns
+    {
+      :klass => "User",
+      :count => 4,
+        :ids => [2, 235, 236, 237]  # the ids array is seeded before returning
+    }
 
 == Efficiency
 
@@ -281,13 +352,16 @@ For example, assume we have a <tt>named_scope :active</tt> on <tt>User</tt> whic
 
 == Compatibility
 
-Tested on Ruby 1.8.6, 1.8.7 and 1.9.1.
+Tested on Ruby 1.8.6, 1.8.7, REE 1.8.7 and 1.9.1.
+Tested in Rails 2.3.* and Rails 3
 
 For Ruby < 1.8.7 you probably want to include the following to extend the Array class with a <tt>count</tt> method.  Otherwise your <tt>cached_<key>_count</tt> calls probably won't work:
 
   Array.class_eval { alias count size }
 
-The version of Rails shouldn't matter much, but it's working on 2.3.4.
+For Rails 3 for some reason AridCache is not being included into ActiveRecord, so add the following to an initializer to get around that:
+
+  AridCache.init_rails
 
 == Resources & Metrics
 
@@ -300,14 +374,6 @@ The version of Rails shouldn't matter much, but it's working on 2.3.4.
 1. <b>Caches that contains duplicate records will only return unique records on subsequent calls</b>.  This is because of the way <tt>find</tt> works when selecting multiple ids.  For example, if your query returns <tt>[#<User id: 1>, #<User id: 1>, #<User id: 1>]</tt>, the IDs are cached as <tt>[1,1,1]</tt>.  On the next call to the cache we load the IDs using <tt>User.find_all_by_id([1,1,1])</tt> which returns <tt>[#<User id: 1>]</tt>, not <tt>[#<User id: 1>, #<User id: 1>, #<User id: 1>]</tt> as you might have expected.
 2. <b>You can't cache polymorphic arrays</b> e.g. [#<User id: 1>, #<Pet id: 5>] because it expects all ActiveRecords to be of the same class.  We could accept a <tt>:polymorphic => true</tt> option but I don't think this is a great idea because instantiating all the records would result in a lot of queries to the individual tables.
 
-== Wish List / Coming Soon
-
-* Some kind of memoize option.
-* Priming caches.  Warm up the cache for all models based on the information in the instance and class cache configurations.  Would need to know when you want to prime counts as well.
-* The ability to <tt>include AridCache</tt> on any class or module.
-* An option to bypass ID caching when you want to store records in the cache.
-* Option to turn off the <tt>respond_to?</tt> requirement for caches without blocks in cases where methods are implemented using method_missing and respond_to? hasn't been properly updated.
-
 == Contributors
 
 Contributions are welcome!  Please,

data/VERSION

@@ -1 +1 @@
-1.0.4
+1.1.0

data/arid_cache.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{arid_cache}
-  s.version = "1.0.4"
+  s.version = "1.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Karl Varga"]
-  s.date = %q{2010-10-29}
+  s.date = %q{2010-12-17}
   s.description = %q{AridCache makes caching easy and effective.  AridCache supports caching on all your model named scopes, class methods and instance methods right out of the box.  AridCache prevents caching logic from cluttering your models and clarifies your logic by making explicit calls to cached result sets.
 AridCache is designed for handling large, expensive ActiveRecord collections but is equally useful for caching anything else as well.
 }
@@ -21,7 +21,6 @@ AridCache is designed for handling large, expensive ActiveRecord collections but
   s.files = [
     ".gitignore",
      "Gemfile",
-     "Gemfile.lock",
      "LICENSE",
      "README.rdoc",
      "Rakefile",
@@ -35,13 +34,13 @@ AridCache is designed for handling large, expensive ActiveRecord collections but
      "lib/arid_cache/store.rb",
      "rails/init.rb",
      "spec/arid_cache/arid_cache_spec.rb",
+     "spec/arid_cache/cache_proxy_result_spec.rb",
      "spec/arid_cache/cache_proxy_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
      "spec/support/ar_query.rb",
      "spec/support/custom_methods.rb",
      "spec/support/matchers.rb",
-     "tasks/arid_cache_tasks.rake",
      "test/arid_cache_test.rb",
      "test/console",
      "test/lib/add_query_counting_to_active_record.rb",
@@ -62,6 +61,7 @@ AridCache is designed for handling large, expensive ActiveRecord collections but
   s.summary = %q{Automates efficient caching of your ActiveRecord collections, gives you counts for free and supports pagination.}
   s.test_files = [
     "spec/arid_cache/arid_cache_spec.rb",
+     "spec/arid_cache/cache_proxy_result_spec.rb",
      "spec/arid_cache/cache_proxy_spec.rb",
      "spec/spec_helper.rb",
      "spec/support/ar_query.rb",

data/lib/arid_cache/cache_proxy.rb

@@ -43,38 +43,25 @@ module AridCache
       Rails.cache.delete_matched(%r[arid-cache-#{key}.*])
     end
 
-    #
-    # Fetching results
-    #
-
-    def self.fetch_count(object, key, opts={}, &block)
-      CacheProxy.new(object, key, opts, &block).fetch_count
-    end
-
-    def self.fetch(object, key, opts={}, &block)
-      CacheProxy.new(object, key, opts, &block).fetch
-    end
-
-    def initialize(object, key, opts, &block)
+    def initialize(object, key, opts={}, &block)
       self.object = object
       self.key = key
-      self.opts = opts.symbolize_keys || {}
+      self.opts = opts.symbolize_keys
       self.blueprint = AridCache.store.find(object, key)
       self.block = block
       self.records = nil
 
       # The options from the blueprint merged with the options for this call
       self.combined_options = self.blueprint.nil? ? self.opts : self.blueprint.opts.merge(self.opts)
-
       self.cache_key = object.arid_cache_key(key, opts_for_cache_key)
-      self.cached = Rails.cache.read(cache_key, opts_for_cache)
-      self.klass = if self.cached && self.cached.is_a?(AridCache::CacheProxy::Result) # infer class of the results to return
-        self.cached.klass
-      else
-        object_base_class
-      end
     end
 
+    #
+    # Fetching results
+    #
+
+    # Return a count of ids in the cache, or return whatever is in the cache if it is
+    # not a CacheProxy::Result
     def fetch_count
       if refresh_cache?
         execute_count
@@ -89,20 +76,52 @@ module AridCache
       end
     end
 
+    # Return a list of records using the options provided.  If the item in the cache
+    # is not a CacheProxy::Result it is returned as-is.  If there is nothing in the cache
+    # the block defining the cache is exectued.  If the :raw option is true, returns the
+    # CacheProxy::Result unmodified, ignoring other options, except where those options
+    # are used to initialize the cache.
     def fetch
-      if refresh_cache?
-        execute_find
+      @raw_result = opts_for_cache_proxy[:raw] == true
+
+      result = if refresh_cache?
+        execute_find(@raw_result)
       elsif cached.is_a?(AridCache::CacheProxy::Result)
-        if cached.has_ids?
-          fetch_from_cache
-        else
-          execute_find
+        if cached.has_ids? && @raw_result
+          self.cached         # return it unmodified
+        elsif cached.has_ids?
+          fetch_from_cache    # return a list of active records after applying options
+        else                  # true if we have only calculated the count thus far
+          execute_find(@raw_result)
         end
       else
-        cached # some base type, return it
+        cached                # some base type, return it unmodified
       end
     end
 
+    # Clear the cached result for this cache only
+    def clear_cached
+      Rails.cache.delete(self.cache_key, opts_for_cache)
+    end
+
+    # Return the cached result for this object's key
+    def cached
+      @cached ||= Rails.cache.read(self.cache_key, opts_for_cache)
+    end
+
+    # Return the class of the cached results i.e. if the cached result is a
+    # list of Album records, then klass returns Album.  If there is nothing
+    # in the cache, then the class is inferred to be the class of the object
+    # that the cached method is being called on.
+    def klass
+      @klass ||= if self.cached && self.cached.is_a?(AridCache::CacheProxy::Result)
+        self.cached.klass
+      else
+        object_base_class
+      end
+    end
+
+
     private
 
       # Return a list of records from the database using the ids from
@@ -175,7 +194,14 @@ module AridCache
         self.records = block.nil? ? object.instance_eval(key) : object.instance_eval(&block)
       end
 
-      def execute_find
+      # Seed the cache by executing the stored block (or by calling a method on the object).
+      # Then apply any options like pagination or ordering before returning the result, which
+      # is either some base type, or usually, a list of active records.
+      #
+      # Options:
+      #   raw  - if true, return the CacheProxy::Result after seeding the cache, ignoring
+      #          other options. Default is false.
+      def execute_find(raw = false)
         get_records
         cached = AridCache::CacheProxy::Result.new
 
@@ -193,8 +219,11 @@ module AridCache
           end
         end
         Rails.cache.write(cache_key, cached, opts_for_cache)
-
         self.cached = cached
+
+        # Return the raw result?
+        return self.cached if raw
+
         # An order has been specified.  We have to go to the database
         # to order because we can't be sure that the current order is the same as the cache.
         if cached.is_a?(AridCache::CacheProxy::Result) && combined_options.include?(:order)
@@ -300,6 +329,13 @@ module AridCache
         combined_options.reject { |k,v| !OPTIONS_FOR_CACHE_KEY.include?(k) }
       end
 
+      OPTIONS_FOR_CACHE_PROXY = [:raw, :clear]
+
+      # Returns options that affect the cache proxy result
+      def opts_for_cache_proxy
+        combined_options.reject { |k,v| !OPTIONS_FOR_CACHE_PROXY.include?(k) }
+      end
+
       def object_base_class #:nodoc:
         object.is_a?(Class) ? object : object.class
       end

data/lib/arid_cache/helpers.rb

@@ -63,12 +63,19 @@ module AridCache
 
     private
 
+    # Dynamically define a method on the object's class to return cached results
     def method_for_cached(object, key, fetch_method=:fetch, method_name=nil)
       method_name = ("cached_" + (method_name || key)).gsub(/[^\w\!\?]/, '_')
       method_body = <<-END
         def #{method_name}(*args, &block)
           opts = args.empty? ? {} : args.first
-          AridCache.cache.send(#{fetch_method.inspect}, self, #{key.inspect}, opts, &block)
+
+          proxy = AridCache::CacheProxy.new(self, #{key.inspect}, opts, &block)
+          if opts[:clear] == true
+            proxy.clear_cached
+          else
+            proxy.#{fetch_method.to_s}
+          end
         end
       END
       # Get the correct object

data/spec/arid_cache/cache_proxy_result_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe AridCache::CacheProxy::Result do
+  before :each do
+    class X; end
+    @result = AridCache::CacheProxy::Result.new
+  end
+
+  it "should set the klass from a class" do
+    @result.klass = X
+    @result.klass.should be(X)
+  end
+  
+  it "should set the klass from an object" do
+    @result.klass = X.new
+    @result.klass.should be(X)
+  end
+  
+  it "should store the klass as a string" do
+    @result.klass = X
+    @result[:klass].should == X.name
+  end
+
+  it "should not have ids if it's nil" do
+    @result.ids = nil
+    @result.has_ids?.should be_false
+  end
+  
+  it "should have ids" do
+    @result.ids = [1,2,3]
+    @result.has_ids?.should be_true
+  end
+  
+  it "should have ids even if the array is empty" do
+    @result.ids = []
+    @result.has_ids?.should be_true
+  end
+
+  it "should not have a count if it's nil" do
+    @result.count = nil
+    @result.has_count?.should be_false
+  end
+  
+  it "should have a count" do
+    @result.count = 3
+    @result.has_count?.should be_true
+  end
+  
+  it "should have a count even if it is zero" do
+    @result.count = 0
+    @result.has_count?.should be_true
+  end
+end

data/spec/arid_cache/cache_proxy_spec.rb

@@ -1,19 +1,95 @@
 require 'spec_helper'
 
 describe AridCache::CacheProxy do
-  describe 'id in order clause' do
+  describe 'preserve_order' do
     before :each do
       @proxy = AridCache::CacheProxy.new(Company, 'dummy-key', {})
     end
-    
-    it "should be prefixed by the table name" do
+
+    it "id column should be prefixed by the table name" do
       ::ActiveRecord::Base.stubs(:is_mysql_adapter?).returns(true)
       @proxy.send(:preserve_order, [1,2,3]).should =~ %r[#{Company.table_name}]
     end
-    
-    it "should be prefixed by the table name" do
+
+    it "id column should be prefixed by the table name" do
       ::ActiveRecord::Base.stubs(:is_mysql_adapter?).returns(false)
       @proxy.send(:preserve_order, [1,2,3]).should =~ %r[#{Company.table_name}]
     end
   end
+
+  describe "with raw => true" do
+    before :each do
+      @user = User.make
+      @user.companies << Company.make
+      @user.companies << Company.make
+      @user.clear_instance_caches
+    end
+
+    it "should return a CacheProxy::Result" do
+      @user.cached_companies(:raw => true).should be_a(AridCache::CacheProxy::Result)
+    end
+
+    it "result should have the same ids as the normal result" do
+      @user.cached_companies(:raw => true).ids.should == @user.cached_companies.collect(&:id)
+    end
+
+    it "should ignore :raw => false" do
+      @user.cached_companies(:raw => false).should == @user.cached_companies
+    end
+
+    it "should only query once to seed the cache, ignoring all other options" do
+      lambda { @user.cached_companies(:raw => true, :limit => 0, :order => 'nonexistent_column desc') }.should query(1)
+    end
+
+    it "should ignore all other options if the cache has already been seeded" do
+      lambda {
+        companies = @user.cached_companies
+        @user.cached_companies(:raw => true, :limit => 0, :order => 'nonexistent_column').ids.should == companies.collect(&:id)
+      }.should query(1)
+    end
+
+    it "should not use the raw option when reading from the cache" do
+      Rails.cache.expects(:read).with(@user.arid_cache_key(:companies), {})
+      @user.cached_companies(:raw => true)
+    end
+
+    it "should work for calls to a method that ends with _count" do
+      @user.cached_bogus_count do
+        10
+      end
+      @user.cached_bogus_count(:raw => true).should == 10
+    end
+
+    it "should work for calls to a method that ends with _count" do
+      @user.cached_companies_count(:raw => true).should == @user.cached_companies_count
+    end
+  end
+
+  describe "with clear => true" do
+    before :each do
+      @user = User.make
+      @user.companies << Company.make
+      @user.companies << Company.make
+      @user.clear_instance_caches rescue Rails.cache.clear
+    end
+
+    it "should not fail if there is no cached value" do
+      lambda { @user.cached_companies(:clear => true) }.should_not raise_exception
+    end
+
+    it "should clear the cached entry" do
+      key = @user.arid_cache_key(:companies)
+      @user.cached_companies
+      Rails.cache.read(key).should_not be_nil
+      @user.cached_companies(:clear => true)
+      Rails.cache.read(key).should be_nil
+    end
+
+    it "should not read from the cache or database" do
+      Rails.cache.expects(:read).never
+      lambda {
+        @user.cached_companies(:clear => true)
+      }.should query(0)
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,5 +1,5 @@
 root_path = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-$LOAD_PATH.unshift(File.join(root_path, '/test/lib')) # make requiring from test/lib easy
+$LOAD_PATH.unshift(File.join(root_path, '/test/lib')) # add test/lib to the load path
 
 require 'bundler/setup'
 Bundler.require

data/test/arid_cache_test.rb

@@ -331,11 +331,11 @@ class AridCacheTest < ActiveSupport::TestCase
 
   test "should support calling store methods directly with a block" do
     assert_nothing_raised do
-      AridCache.cache.fetch(@user, 'my-fancy-key') do
+      AridCache.cache.new(@user, 'my-fancy-key') do
         companies
-      end
+      end.fetch
     end
-    assert_equal @user.companies.all(:order => 'name DESC'), AridCache.cache.fetch(@user, 'my-fancy-key', :order => 'name DESC') { companies }
+    assert_equal @user.companies.all(:order => 'name DESC'), AridCache.cache.new(@user, 'my-fancy-key', :order => 'name DESC') { companies }.fetch
   end
 
   test "empty user relation should be empty" do
@@ -371,14 +371,14 @@ class AridCacheTest < ActiveSupport::TestCase
     ::ActiveRecord::Base.connection.instance_eval { def adapter_name; "Mysql2"; end }
     assert_equal "Mysql2", ::ActiveRecord::Base.connection.adapter_name
     assert_equal true, ::ActiveRecord::Base.is_mysql_adapter?
-    
+
     # Restore it otherwise the other tests break
     ::ActiveRecord::Base.connection.instance_eval { def adapter_name; "SQLite3"; end }
     assert_equal "SQLite3", ::ActiveRecord::Base.connection.adapter_name
     ::ActiveRecord::Base.is_mysql_adapter = nil
     assert_equal false, ::ActiveRecord::Base.is_mysql_adapter?
   end
-  
+
   #
   # Tests requiring manual verification by looking at the SQL logs.
   # TODO move these to a separate class.

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: arid_cache
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 19
   prerelease: false
   segments: 
   - 1
+  - 1
   - 0
-  - 4
-  version: 1.0.4
+  version: 1.1.0
 platform: ruby
 authors: 
 - Karl Varga
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-29 00:00:00 -07:00
+date: 2010-12-17 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -89,7 +89,6 @@ extra_rdoc_files:
 files: 
 - .gitignore
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.rdoc
 - Rakefile
@@ -103,13 +102,13 @@ files:
 - lib/arid_cache/store.rb
 - rails/init.rb
 - spec/arid_cache/arid_cache_spec.rb
+- spec/arid_cache/cache_proxy_result_spec.rb
 - spec/arid_cache/cache_proxy_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 - spec/support/ar_query.rb
 - spec/support/custom_methods.rb
 - spec/support/matchers.rb
-- tasks/arid_cache_tasks.rake
 - test/arid_cache_test.rb
 - test/console
 - test/lib/add_query_counting_to_active_record.rb
@@ -158,6 +157,7 @@ specification_version: 3
 summary: Automates efficient caching of your ActiveRecord collections, gives you counts for free and supports pagination.
 test_files: 
 - spec/arid_cache/arid_cache_spec.rb
+- spec/arid_cache/cache_proxy_result_spec.rb
 - spec/arid_cache/cache_proxy_spec.rb
 - spec/spec_helper.rb
 - spec/support/ar_query.rb

data/Gemfile.lock

@@ -1,59 +0,0 @@
-PATH
-  remote: .
-  specs:
-    arid_cache (1.0.3)
-      will_paginate
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    activerecord (2.3.8)
-      activesupport (= 2.3.8)
-    activesupport (2.3.8)
-    columnize (0.3.1)
-    faker (0.3.1)
-    gemcutter (0.6.1)
-    git (1.2.5)
-    hoe (2.6.2)
-      rake (>= 0.8.7)
-      rubyforge (>= 2.0.4)
-    jeweler (1.4.0)
-      gemcutter (>= 0.1.0)
-      git (>= 1.2.5)
-      rubyforge (>= 2.0.0)
-    json_pure (1.4.6)
-    linecache (0.43)
-    machinist (1.0.6)
-    mocha (0.9.8)
-      rake
-    rake (0.8.7)
-    rspec (1.3.0)
-    ruby-debug (0.10.3)
-      columnize (>= 0.1)
-      ruby-debug-base (~> 0.10.3.0)
-    ruby-debug-base (0.10.3)
-      linecache (>= 0.3)
-    rubyforge (2.0.4)
-      json_pure (>= 1.1.7)
-    sqlite3-ruby (1.3.1)
-    test-unit (1.2.3)
-      hoe (>= 1.5.1)
-    will_paginate (2.3.15)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activerecord (= 2.3.8)
-  activesupport (= 2.3.8)
-  arid_cache!
-  faker (= 0.3.1)
-  jeweler (= 1.4.0)
-  machinist (= 1.0.6)
-  mocha (= 0.9.8)
-  rspec (= 1.3.0)
-  ruby-debug (= 0.10.3)
-  ruby-debug-base (= 0.10.3)
-  sqlite3-ruby (= 1.3.1)
-  test-unit (= 1.2.3)
-  will_paginate (= 2.3.15)

data/tasks/arid_cache_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :arid_cache do
-#   # Task goes here
-# end