arid_cache 1.3.2 → 1.3.3

data/.gitignore

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

data/Gemfile

@@ -14,5 +14,5 @@ gem 'machinist', '=1.0.6'
 gem 'faker', '=0.3.1'
 gem 'rspec', '~>1.3.1', :require => 'spec'
 gem 'test-unit', '=1.2.3'
-gem 'mocha', '=0.9.8'
-gem 'arid_cache', :path => "./"
+gem 'arid_cache', :path => "./"
+gem 'rr', '~>1.0.2'

data/Gemfile.lock

@@ -0,0 +1,58 @@
+PATH
+  remote: .
+  specs:
+    arid_cache (1.3.2)
+      will_paginate
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activerecord (2.3.11)
+      activesupport (= 2.3.11)
+    activesupport (2.3.11)
+    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)
+    rake (0.8.7)
+    rr (1.0.2)
+    rspec (1.3.1)
+    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.11)
+  activesupport (= 2.3.11)
+  arid_cache!
+  faker (= 0.3.1)
+  jeweler (= 1.4.0)
+  machinist (= 1.0.6)
+  rr (~> 1.0.2)
+  rspec (~> 1.3.1)
+  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/VERSION

@@ -1 +1 @@
-1.3.2
+1.3.3

data/arid_cache.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{arid_cache}
-  s.version = "1.3.2"
+  s.version = "1.3.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Karl Varga"]
-  s.date = %q{2011-04-07}
+  s.date = %q{2011-04-08}
   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,6 +21,7 @@ AridCache is designed for handling large, expensive ActiveRecord collections but
   s.files = [
     ".gitignore",
      "Gemfile",
+     "Gemfile.lock",
      "LICENSE",
      "README.rdoc",
      "Rakefile",
@@ -44,6 +45,7 @@ AridCache is designed for handling large, expensive ActiveRecord collections but
      "spec/arid_cache/cache_proxy/cached_result_spec.rb",
      "spec/arid_cache/cache_proxy/options_spec.rb",
      "spec/arid_cache/cache_proxy/result_processor_spec.rb",
+     "spec/arid_cache/cache_proxy/utilities_spec.rb",
      "spec/arid_cache/cache_proxy_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
@@ -74,6 +76,7 @@ AridCache is designed for handling large, expensive ActiveRecord collections but
      "spec/arid_cache/cache_proxy/cached_result_spec.rb",
      "spec/arid_cache/cache_proxy/options_spec.rb",
      "spec/arid_cache/cache_proxy/result_processor_spec.rb",
+     "spec/arid_cache/cache_proxy/utilities_spec.rb",
      "spec/arid_cache/cache_proxy_spec.rb",
      "spec/spec_helper.rb",
      "spec/support/ar_query.rb",

data/lib/arid_cache/cache_proxy/result_processor.rb

@@ -66,19 +66,22 @@ module AridCache
             end
             Utilities.object_class(@options[:receiver]).send(@options[:proxy], @result)
           elsif is_activerecord_reflection?
-            lazy_cache.klass = @result.proxy_reflection.klass if @result.respond_to?(:proxy_reflection)
             if @options.count_only?
               lazy_cache.count = @result.count
             else
+              lazy_cache.klass = @result.proxy_reflection.klass if @result.respond_to?(:proxy_reflection)
               lazy_cache.ids = @result.collect { |r| r[:id] }
               lazy_cache.count = @result.size
             end
             lazy_cache
-          elsif is_activerecord? || is_empty?
+          elsif is_activerecord?
             lazy_cache.ids = @result.collect { |r| r[:id] }
             lazy_cache.count = @result.size
             lazy_cache.klass = @result.first.class
             lazy_cache
+          elsif @result.nil? # so we can distinguish a cached nil vs an empty cache
+            lazy_cache.klass = NilClass
+            lazy_cache
           else
             @result
           end
@@ -109,8 +112,10 @@ module AridCache
             filtered
           end
 
-        elsif @options.raw?
+        elsif (@cached || @result).is_a?(AridCache::CacheProxy::CachedResult) && (@cached || @result).klass == NilClass
+          nil
 
+        elsif @options.raw?
           result =
             if @cached.is_a?(AridCache::CacheProxy::CachedResult)
               @cached
@@ -144,13 +149,9 @@ module AridCache
         end
       end
 
-      # Lazy-initialize a new cached result.  Default the klass of the result to
-      # that of the receiver.
+      # Lazy-initialize a new cached result.
       def lazy_cache
-        return @lazy_cache if @lazy_cache
-        @lazy_cache = AridCache::CacheProxy::CachedResult.new
-        @lazy_cache.klass = @options[:result_klass]
-        @lazy_cache
+        @lazy_cache ||= AridCache::CacheProxy::CachedResult.new
       end
 
       # Return the result after processing it to apply limits or pagination in memory.
@@ -233,7 +234,7 @@ module AridCache
 
       # Return the klass to use for building results (only applies to ActiveRecord results)
       def result_klass
-        @options[:result_klass] = is_cached_result? ? @result.klass : (@cached.is_a?(AridCache::CacheProxy::CachedResult) ? @cached.klass : Utilities.object_class(@options[:receiver]))
+        is_cached_result? ? @result.klass : (@cached.is_a?(AridCache::CacheProxy::CachedResult) ? @cached.klass : Utilities.object_class(@options[:receiver]))
       end
     end
   end

data/lib/arid_cache/cache_proxy.rb

@@ -23,7 +23,7 @@ module AridCache
       end
 
       def klass
-        self['klass'].constantize unless self['klass'].nil?
+        self[:klass].respond_to?(:constantize) ? self['klass'].constantize : self['klass']
       end
     end
 
@@ -71,7 +71,6 @@ module AridCache
       @options = Options.new(@blueprint.nil? ? opts : @blueprint.opts.merge(opts))
       @options[:receiver] = receiver
       @cache_key = @receiver.arid_cache_key(@method, @options.opts_for_cache_key)
-      @cached = Rails.cache.read(@cache_key, @options.opts_for_cache)
     end
 
     #
@@ -99,14 +98,14 @@ module AridCache
       # Return a ResultProcessor instance.  Seed the cache if we need to, otherwise
       # use what is in the cache.
       def result_processor
-        seed_cache? ? seed_cache : ResultProcessor.new(@cached, @options)
+        seed_cache? ? seed_cache : ResultProcessor.new(cached, @options)
       end
 
       # Return a boolean indicating whether we need to seed the cache.  Seed the cache
       # if :force => true, the cache is empty or records have been requested and there
       # are none in the cache yet.
       def seed_cache?
-        @cached.nil? || @options.force? || (@cached.is_a?(CachedResult) && !@options.count_only? && !@cached.has_ids?)
+        cached.nil? || @options.force? || (cached.is_a?(CachedResult) && !@options.count_only? && !cached.has_ids? && cached.klass != NilClass)
       end
 
       # Seed the cache by executing the stored block (or by calling a method on the object)
@@ -120,8 +119,18 @@ module AridCache
         @result
       end
 
+      # Write +data+ to the cache
       def write_cache(data)
         Rails.cache.write(@cache_key, data, @options.opts_for_cache)
       end
+
+      # Return the contents of the cache.  Read from the cache if we have not yet done so.
+      def cached
+        unless @cached_initialized
+          @cached = Rails.cache.read(@cache_key, @options.opts_for_cache)
+          @cached_initialized = true # so we don't read multiple times when the value is nil
+        end
+        @cached
+      end
   end
-end
+end

data/spec/arid_cache/cache_proxy/cached_result_spec.rb

@@ -10,12 +10,12 @@ describe AridCache::CacheProxy::CachedResult 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
@@ -25,12 +25,12 @@ describe AridCache::CacheProxy::CachedResult 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
@@ -40,14 +40,19 @@ describe AridCache::CacheProxy::CachedResult 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
+
+  it "should handle initializing with a klass" do
+    @result = AridCache::CacheProxy::CachedResult.new([], X, 0)
+    @result.klass.should == X
+  end
+end

data/spec/arid_cache/cache_proxy/options_spec.rb

@@ -86,12 +86,12 @@ describe AridCache::CacheProxy::Options do
 
   describe "deprecated raw" do
     it "should be deprecated" do
-      AridCache.expects(:raw_with_options).returns(false)
+      mock(AridCache).raw_with_options { false }
       new_options(:raw => true).deprecated_raw?.should be_true
     end
 
     it "should not be deprecated" do
-      AridCache.expects(:raw_with_options).returns(true)
+      mock(AridCache).raw_with_options { true }
       new_options(:raw => true).deprecated_raw?.should be_false
     end
   end

data/spec/arid_cache/cache_proxy/result_processor_spec.rb

@@ -6,6 +6,10 @@ describe AridCache::CacheProxy::ResultProcessor do
     AridCache::CacheProxy::ResultProcessor.new(value, opts)
   end
 
+  before :all do
+    AridCache.store.delete! # so no options get stored and interfere with other tests
+  end
+
   describe "empty array" do
     before :each do
       @result = new_result([])
@@ -18,7 +22,10 @@ describe AridCache::CacheProxy::ResultProcessor do
       @result.is_hashes?.should be_false
       @result.is_cached_result?.should be_false
       @result.order_in_database?.should be_false
-      @result.to_cache.should be_a(AridCache::CacheProxy::CachedResult)
+    end
+
+    it "should be cached as an array" do
+      @result.to_cache.should be_a(Array)
     end
   end
 
@@ -253,7 +260,6 @@ describe AridCache::CacheProxy::ResultProcessor do
 
       # Comparing the hashes directly doesn't work because the updated_at Time are
       # not considered equal...don't know why, cause the to_s looks the same.
-      # debugger
       value.should be_a(Array)
       value.first.should be_a(Hash)
       value.first.each_pair do |k, v|
@@ -261,7 +267,7 @@ describe AridCache::CacheProxy::ResultProcessor do
       end
 
       # Cache is seeded, it should use the cached result
-      User.expects(:abc).never
+      dont_allow(User).abc
       value = @user.cached_companies(:raw => true)
       value.should be_a(Array)
       value.first.should be_a(Hash)

data/spec/arid_cache/cache_proxy/utilities_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe AridCache::CacheProxy::Utilities do
+  describe 'order_by' do
+    it "id column should be prefixed by the table name" do
+      stub(::ActiveRecord::Base).is_mysql_adapter? { true }
+      AridCache::CacheProxy::Utilities.order_by([1,2,3], Company).should =~ %r[#{Company.table_name}]
+    end
+
+    it "id column should be prefixed by the table name" do
+      stub(::ActiveRecord::Base).is_mysql_adapter? { false }
+      AridCache::CacheProxy::Utilities.order_by([1,2,3], Company).should =~ %r[#{Company.table_name}]
+    end
+  end
+end

data/spec/arid_cache/cache_proxy_spec.rb

@@ -1,98 +1,184 @@
 require 'spec_helper'
 
 describe AridCache::CacheProxy do
-  # describe 'preserve_order' do
-  #   before :each do
-  #     @proxy = AridCache::CacheProxy.new(Company, 'dummy-key', {})
-  #   end
-  # 
-  #   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 "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::CachedResult" do
-  #     @user.cached_companies(:raw => true).should be_a(AridCache::CacheProxy::CachedResult)
-  #   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
-  
+  before :all do
+    AridCache.store.delete! # so no options get stored
+  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
+
+    describe "with options" do
+      before :all do
+        AridCache.raw_with_options = true
+      end
+
+      after :all do
+        AridCache.raw_with_options = false
+      end
+
+      it "should use the new raw handling" do
+        AridCache.raw_with_options.should be_true
+      end
+
+      it "should return raw results" do
+        @user.cached_companies(:raw => true).should == @user.companies.collect(&:id)
+      end
+
+      it "result should have the same ids as the normal result" do
+        @user.cached_companies(:raw => true).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 apply options even if the cache has already been seeded" do
+        lambda {
+          companies = @user.cached_companies
+          @user.cached_companies(:raw => true, :limit => 1).should == companies.collect(&:id)[0,1]
+        }.should query(1)
+      end
+
+      it "should not use the raw option when reading from the cache" do
+        mock.proxy(Rails.cache).read(@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 "deprecated" do
+      it "should use the deprecated handling" do
+        AridCache.raw_with_options.should be_false
+      end
+
+      it "should return a CacheProxy::CachedResult" do
+        @user.cached_companies(:raw => true).should be_a(AridCache::CacheProxy::CachedResult)
+      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
+        mock.proxy(Rails.cache).read(@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
+  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
+      dont_allow(Rails.cache).read
+      lambda {
+        @user.cached_companies(:clear => true)
+      }.should query(0)
+    end
+  end
+
+  describe "nils" do
+    before :each do
+      @obj = Class.new do
+        include AridCache
+
+        instance_caches do
+          empty { nil }
+        end
+      end.new
+      @obj.cached_empty(:clear => true)
+    end
+
+    it "should cache nils" do
+      @obj.cached_empty.should be_nil
+    end
+
+    it "should only write to the cache once" do
+      mock.proxy(Rails.cache).read.with_any_args.twice
+      mock.proxy(Rails.cache).write.with_any_args.once
+      @obj.cached_empty
+      @obj.cached_empty
+    end
+
+    it "should return nil for the count" do
+      @obj.cached_empty_count.should be_nil
+    end
+
+    it "should return nil for :raw => true" do
+      @obj.cached_empty(:raw => true).should be_nil
+    end
+
+    it "should be cached as a CachedResult" do
+      @obj.cached_empty
+      cached = Rails.cache.read(@obj.arid_cache_key(:empty))
+      cached.should be_a(AridCache::CacheProxy::CachedResult)
+      cached.klass.should == NilClass
+    end
+  end
+
   describe "arrays" do
     before :each do
       @o = Class.new do
@@ -103,22 +189,56 @@ describe AridCache::CacheProxy do
       end.new
     end
 
-    # it "should cache the result" do
-    #   @o.cached_result { result }.should == @o.result 
-    # end
-    # 
-    # it "should respect the :limit option" do
-    #   @o.cached_result(:limit => 4) { result }.should == [1,2,3,4]
-    # end
+    it "should cache the result" do
+      @o.cached_result.should == @o.result
+    end
+
+    it "should respect the :limit option" do
+      @o.cached_result(:limit => 4).should == [1,2,3,4]
+    end
 
     it "should respect the :offset option" do
-      @o.cached_result(:offset => 2) { result }.should == [3,4,5]
-    end
-  
-    # it "should apply pagination" do
-    #   result = @o.cached_result(:page => 2, :per_page => 2) { result }
-    #   result.should == @o.paginate(:page => 2, :per_page => 2)
-    #   result.total_entries.should == @o.result.size
-    # end
+      @o.cached_result(:offset => 2).should == [3,4,5]
+    end
+
+    it "should apply pagination" do
+      result = @o.cached_result(:page => 2, :per_page => 2)
+      result.should == @o.result.paginate(:page => 2, :per_page => 2)
+      result.total_entries.should == @o.result.size
+    end
+  end
+
+  describe "CachedResult" do
+    before :each do
+      class User
+        instance_caches do
+          get_result
+        end
+
+        def get_result
+          AridCache::CacheProxy::CachedResult.new(companies.collect(&:id), Company, companies.count)
+        end
+      end
+      @user = User.make
+      @user.companies << Company.make
+      @user.companies << Company.make
+    end
+
+    it "should store a CachedResult" do
+      @user.cached_get_result
+      Rails.cache.read(@user.arid_cache_key(:get_result)).should == @user.get_result
+    end
+
+    it "should return records" do
+      @user.cached_get_result.should == @user.companies
+    end
+
+    it "should return a count" do
+      @user.cached_get_result_count.should == @user.companies.count
+    end
+
+    it "should return the CachedResult with :raw => true" do
+      @user.cached_get_result(:raw => true).should == @user.get_result
+    end
   end
-end
+end

data/spec/spec_helper.rb

@@ -15,7 +15,7 @@ Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].e
 
 Spec::Runner.configure do |config|
   include ActiveRecordQueryMatchers
-  config.mock_with :mocha
+  config.mock_with :rr
 
   config.before(:all) do
     Sham.reset(:before_all)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: arid_cache
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 29
   prerelease: 
   segments: 
   - 1
   - 3
-  - 2
-  version: 1.3.2
+  - 3
+  version: 1.3.3
 platform: ruby
 authors: 
 - Karl Varga
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-07 00:00:00 -07:00
+date: 2011-04-08 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -89,6 +89,7 @@ extra_rdoc_files:
 files: 
 - .gitignore
 - Gemfile
+- Gemfile.lock
 - LICENSE
 - README.rdoc
 - Rakefile
@@ -112,6 +113,7 @@ files:
 - spec/arid_cache/cache_proxy/cached_result_spec.rb
 - spec/arid_cache/cache_proxy/options_spec.rb
 - spec/arid_cache/cache_proxy/result_processor_spec.rb
+- spec/arid_cache/cache_proxy/utilities_spec.rb
 - spec/arid_cache/cache_proxy_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -170,6 +172,7 @@ test_files:
 - spec/arid_cache/cache_proxy/cached_result_spec.rb
 - spec/arid_cache/cache_proxy/options_spec.rb
 - spec/arid_cache/cache_proxy/result_processor_spec.rb
+- spec/arid_cache/cache_proxy/utilities_spec.rb
 - spec/arid_cache/cache_proxy_spec.rb
 - spec/spec_helper.rb
 - spec/support/ar_query.rb