arid_cache 1.4.3 → 1.4.4

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ./
   specs:
-    arid_cache (1.4.2)
+    arid_cache (1.4.4)
       will_paginate
 
 GEM

data/README.rdoc

@@ -10,6 +10,7 @@ AridCache simplifies caching by supporting auto-expiring cache keys - as well as
 
 == Changes
 
+* v1.4.4: Fix empty relations return nil instead of an empty array
 * v1.4.2: Add <tt>:proxy_out</tt> and <tt>:proxy_in</tt> options; <tt>AridCache::Proxies::IdProxy</tt>.  Support proxies as +Procs+.
 * v1.4.1: Default <tt>:page</tt> to <tt>1</tt> if it is +nil+
 * v1.4.0: Rails 3 fully supported!

data/VERSION

@@ -1 +1 @@
-1.4.3
+1.4.4

data/arid_cache.gemspec

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

@@ -12,6 +12,7 @@ module AridCache
     # into that class.  We have to keep whatever is cached as small as possible tho,
     # so it's probably best to cache a Hash and load it with CachedResult.
     class ResultProcessor
+      attr_reader :options
 
       def initialize(result, opts={})
         @result = result
@@ -65,13 +66,12 @@ module AridCache
               @result = @result.collect { |r| r } # force it to load
             end
             run_user_proxy(:in, @result)
-          elsif is_activerecord_reflection?
-
+          elsif is_activerecord_reflection? # Don't trigger it unless we really have to
             if @options.count_only?
               lazy_cache.count = @result.count
             else
               lazy_cache.ids = @result.collect { |r| r[:id] }
-              lazy_cache.klass = @result.respond_to?(:proxy_reflection) ? @result.proxy_reflection.klass : (is_empty? ? result_klass : @result.first.class)
+              lazy_cache.klass = Utilities.collection_klass(@result) || result_klass
               lazy_cache.count = @result.size
             end
             lazy_cache
@@ -95,7 +95,7 @@ module AridCache
 
       # Apply any options like pagination or ordering and return the result, which
       # is either some base type, or usually, a list of active records.
-      def to_result
+      def to_result  
         if @options.count_only?
           get_count
 
@@ -125,7 +125,7 @@ module AridCache
         elsif @options.proxy?(:in)
           filter_results(@cached || @result)
 
-        elsif (@cached || @result).is_a?(AridCache::CacheProxy::CachedResult) && (@cached || @result).klass == NilClass
+        elsif (@cached || @result).is_a?(AridCache::CacheProxy::CachedResult) && (@cached || @result).klass == NilClass && !(@cached || @result).has_ids?
           nil
 
         elsif @options.raw?
@@ -278,8 +278,6 @@ module AridCache
       def result_klass
         is_cached_result? ? @result.klass : (@cached.is_a?(AridCache::CacheProxy::CachedResult) ? @cached.klass : @options[:receiver_klass])
       end
-
-
     end
   end
 end

data/lib/arid_cache/cache_proxy/utilities.rb

@@ -64,6 +64,20 @@ module AridCache
           klass.find_all_by_id(ids, find_opts)
         end
       end
+
+      # Infer the class of the objects in a collection.  The collection could be empty.
+      # If the collection is a relation or proxy reflection we can get the class from it.
+      #
+      # Return the class or nil if no class can be inferred.
+      def collection_klass(collection)
+        if collection.respond_to?(:proxy_reflection)
+          collection.proxy_reflection.klass
+        elsif defined?(::ActiveRecord::Relation) && collection.is_a?(::ActiveRecord::Relation)
+          collection.klass
+        elsif collection.respond_to?(:first) && collection.first
+          collection.first.class
+        end
+      end
     end
   end
 end

data/spec/arid_cache/cache_proxy/result_processor_spec.rb

@@ -6,6 +6,16 @@ describe AridCache::CacheProxy::ResultProcessor do
     AridCache::CacheProxy::ResultProcessor.new(value, opts)
   end
 
+  # Yield the block once with raw_with_options off, and once with raw_with_options on.
+  # The block should make RSpec assertions.
+  def with_deprecated_support
+    current = AridCache.raw_with_options
+    yield
+    AridCache.raw_with_options = !!current
+    yield
+    AridCache.raw_with_options = current
+  end
+
   before :each do
     AridCache.raw_with_options = true
   end
@@ -491,9 +501,9 @@ describe AridCache::CacheProxy::ResultProcessor do
       new_result(@obj).is_activerecord_reflection?.should be_true
     end
 
-    it "should set klass" do
+    it "should not be able to infer the result klass" do
       cache = new_result(@obj).to_cache
-      cache.klass.should be(User)
+      cache.klass.should be(NilClass)
     end
   end
 
@@ -538,6 +548,19 @@ describe AridCache::CacheProxy::ResultProcessor do
         new_result(@obj).to_cache.should be_a(AridCache::CacheProxy::CachedResult)
       end
 
+      it "should not be able to infer the class of the results (without knowing the receiver class)" do
+        result = new_result(@ob)
+        result.options[:receiver_klass].should be_nil
+        cached = result.to_cache
+        cached.klass.should be(NilClass)
+      end
+
+      it "should return an empty array" do
+        result = new_result(@obj).to_result
+        result.should be_a(Array)
+        result.should be_empty
+      end
+
       it "should be a reflection" do
         new_result(@obj).is_activerecord_reflection?.should be_true
       end
@@ -572,4 +595,32 @@ describe AridCache::CacheProxy::ResultProcessor do
       @options[:result_klass].should be(@obj.class)
     end
   end
+
+  describe "cached result with NilClass" do
+    before :each do
+      @cached = AridCache::CacheProxy::CachedResult.new
+      @cached.klass = nil
+    end
+
+    it "should have NilClass" do
+      @cached.klass.should be(NilClass)
+    end
+
+    it "should return nil if no ids" do
+      with_deprecated_support {
+        @cached.has_ids?.should be_false
+        new_result(@cached).to_result.should be_nil
+      }
+    end
+
+    it "should return empty array" do
+      with_deprecated_support {
+        @cached.ids = []
+        @cached.has_ids?.should be_true
+        result = new_result(@cached).to_result
+        result.should be_a(Array)
+        result.should be_empty
+      }
+    end
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: arid_cache
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 15
   prerelease: 
   segments: 
   - 1
   - 4
-  - 3
-  version: 1.4.3
+  - 4
+  version: 1.4.4
 platform: ruby
 authors: 
 - Karl Varga
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-21 00:00:00 -07:00
+date: 2011-04-27 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency