arid_cache 1.3.4 → 1.3.5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    arid_cache (1.3.3)
+    arid_cache (1.3.4)
       will_paginate
 
 GEM

data/README.rdoc

@@ -8,7 +8,8 @@ AridCache simplifies caching by supporting auto-expiring cache keys - as well as
 
 == Changes
 
-* v1.3.4: Inherited caches: Caches, cache options and cache blocks are inherited by all subclasses
+* v1.3.5: Backwards-compatibility fix for caching an empty array with <tt>:raw => true</tt>
+* v1.3.4: Inherited cache configurations: Cache options and cache blocks are inherited from superclasses
 * v1.3.2: <tt>AridCache.raw_with_options</tt> configuration for better <tt>:raw</tt> handling on cached ActiveRecord collections
 * v1.3.1: Proxy support which allow you to control how your objects get serialized and unserialized
 * v1.3.0: Support limits, ordering and pagination on cached Enumerables
@@ -52,7 +53,7 @@ Then
 * <b>Preserves ordering</b> of your cached ActiveRecord collections
 * <b>Optimized</b> to make as few cache and database accesses as absolutely neccessary
 * Define your own <b>cache proxy</b> to serialize your objects as they go to and from the cache
-* <b>Inherited caches</b> - subclasses inherit all caches, cache options and blocks from superclasses.
+* <b>Inherited cache configurations</b> - subclasses inherit cache options and cache blocks from superclasses.
 
 == Introduction
 
@@ -454,6 +455,50 @@ All of the above calls work with <tt>raw => true</tt>.  With that option the res
 
 In practice you probably want to define your proxy method on <tt>ActiveRecord::Base</tt> so that it is available to all your models.  In future AridCache will probably have some built-in proxies that you can make use of.
 
+== Inherited Cache Options
+
+Subclasses automatically inherit cache definitions from their superclasses.  The options for a particular cache are merged, with options from subclasses overriding the superclass.  If a superclass defines a block for that cache, the one from the closest ancestor is used.
+
+Here is a simple example:
+
+  class Abc
+    include AridCache
+    instance_caches do
+      name(:limit => 2) { 'abc' }
+      actual_name(:limit => 2)
+    end
+
+    def actual_name
+      'abc'
+    end
+  end
+
+  class Def < Abc
+    instance_caches do
+      name(:limit => 1)
+      actual_name(:limit => 1)
+    end
+
+    def actual_name
+      'def'
+    end
+  end
+
+  > a, d = Abc.new, Def.new
+  > a.cached_name
+  "ab"
+  > a.cached_actual_name
+  "ab"
+  > d.cached_name
+  "a"
+
+So here +cached_name+ is using its own <tt>:limit => 1</tt> with the block from +Abc+.  So it's returning the first character of 'abc'.
+
+  > d.cached_actual_name
+  "d"
+
+Here +cached_actual_name+ is using its own <tt>:limit => 1</tt> but since no ancestor class defines a block on the cache, it uses the method from the instance.  So it's returning the first character of 'def'.
+
 == Efficiency
 
 * AridCache intercepts calls to <tt>cached_</tt> methods using <tt>method_missing</tt> then defines those methods on your models as they are called, so they bypass method missing on subsequent calls.

data/VERSION

@@ -1 +1 @@
-1.3.4
+1.3.5

data/arid_cache.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{arid_cache}
-  s.version = "1.3.4"
+  s.version = "1.3.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Karl Varga"]
-  s.date = %q{2011-04-11}
+  s.date = %q{2011-04-14}
   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.
 }

data/lib/arid_cache/cache_proxy/result_processor.rb

@@ -18,9 +18,9 @@ module AridCache
         @options = opts.is_a?(AridCache::CacheProxy::Options) ? opts : AridCache::CacheProxy::Options.new(opts)
       end
 
-      # Return true if the result is an enumerable and it is empty.
+      # Return true if the result is an array and it is empty.
       def is_empty?
-        is_enumerable? && @result.empty?
+        @result.is_a?(Array) && @result.empty?
       end
 
       # Return true if the result is an enumerable.
@@ -79,6 +79,11 @@ module AridCache
             lazy_cache.count = @result.size
             lazy_cache.klass = @result.first.class
             lazy_cache
+          elsif is_empty? && !AridCache.raw_with_options # deprecated behaviour
+            lazy_cache.ids = @result
+            lazy_cache.count = 0
+            lazy_cache.klass = result_klass
+            lazy_cache            
           elsif @result.nil? # so we can distinguish a cached nil vs an empty cache
             lazy_cache.klass = NilClass
             lazy_cache

data/spec/arid_cache/cache_proxy_spec.rb

@@ -11,62 +11,61 @@ describe AridCache::CacheProxy do
       @user.companies << Company.make
       @user.companies << Company.make
       @user.clear_instance_caches
+      AridCache.raw_with_options = true
     end
 
-    describe "with options" do
-      before :all do
-        AridCache.raw_with_options = true
-      end
-
-      after :all do
-        AridCache.raw_with_options = false
-      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 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 "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 "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 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 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 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 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
+    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
+    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
 
     describe "deprecated" do
+      before :each do
+        AridCache.raw_with_options = false
+      end                                 
+      
       it "should use the deprecated handling" do
         AridCache.raw_with_options.should be_false
       end
@@ -109,6 +108,25 @@ describe AridCache::CacheProxy do
       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
+
+      describe "empty array" do
+        before :each do
+          @user.cached_empty_array { [] }
+        end
+
+        it "should be stored as a CachedResult" do
+          @user.cached_empty_array(:raw => true).should be_a(AridCache::CacheProxy::CachedResult)
+        end
+
+        it "should have the class of the receiver" do
+          @user.cached_empty_array(:raw => true).klass.should be(User)
+        end
+
+        it "should return a CachedResult when the cache is empty" do
+          @user.cached_empty_array(:clear => true)
+          @user.cached_empty_array(:raw => true).should be_a(AridCache::CacheProxy::CachedResult)
+        end
+      end
     end
   end
 

data/spec/arid_cache/helpers_spec.rb

@@ -9,7 +9,8 @@ describe AridCache::Helpers do
     end
     
     it "should description" do
-      AridCache.subclasses_of(Aa).should == [Cc, Bb]
+      AridCache.subclasses_of(Aa).should include(Cc)
+      AridCache.subclasses_of(Aa).should include(Bb)
       AridCache.subclasses_of(Bb).should == [Cc]
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: arid_cache
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 1
   - 3
-  - 4
-  version: 1.3.4
+  - 5
+  version: 1.3.5
 platform: ruby
 authors: 
 - Karl Varga
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-11 00:00:00 -07:00
+date: 2011-04-14 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency