arid_cache 0.2.7 → 1.0.0

data/README.rdoc

@@ -265,7 +265,7 @@ For example, assume we have a <tt>named_scope :active</tt> on <tt>User</tt> whic
 
 == Compatibility
 
-Tested on Ruby 1.8.6 and 1.8.7.  Should be compatible with 1.9.
+Tested on Ruby 1.8.6, 1.8.7 and 1.9.1. 
 
 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:
   

data/Rakefile

@@ -8,7 +8,7 @@ begin
     gem.summary = %Q{Automates efficient caching of your ActiveRecord collections, gives you counts for free and supports pagination.}
     gem.description = <<-END.gsub(/^\s+/, '')
       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.
     END
     gem.email = "kjvarga@gmail.com"
@@ -30,13 +30,13 @@ end
 #   spec.libs << 'lib' << 'spec'
 #   spec.spec_files = FileList['spec/**/*_spec.rb']
 # end
-# 
+#
 # Spec::Rake::SpecTask.new(:rcov) do |spec|
 #   spec.libs << 'lib' << 'spec'
 #   spec.pattern = 'spec/**/*_spec.rb'
 #   spec.rcov = true
 # end
-# 
+#
 # task :spec => :check_dependencies
 
 require 'rake/testtask'
@@ -58,3 +58,11 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+desc "Release a new patch version"
+task :release_new_version do
+  Rake::Task['version:bump:patch'].invoke
+  Rake::Task['github:release'].invoke
+  Rake::Task['git:release'].invoke
+  Rake::Task['gemcutter:release'].invoke
+end

data/VERSION

@@ -1 +1 @@
-0.2.7
+1.0.0

data/arid_cache.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{arid_cache}
-  s.version = "0.2.7"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Karl Varga"]
-  s.date = %q{2010-01-21}
+  s.date = %q{2010-07-05}
   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.
 }
@@ -44,6 +44,7 @@ AridCache is designed for handling large, expensive ActiveRecord collections but
      "test/lib/blueprint.rb",
      "test/log/.gitignore",
      "test/models/company.rb",
+     "test/models/empty_user_relation.rb",
      "test/models/user.rb",
      "test/test_helper.rb"
   ]
@@ -61,6 +62,7 @@ AridCache is designed for handling large, expensive ActiveRecord collections but
      "test/lib/active_support/cache/file_store_extras.rb",
      "test/lib/blueprint.rb",
      "test/models/company.rb",
+     "test/models/empty_user_relation.rb",
      "test/models/user.rb",
      "test/test_helper.rb"
   ]

data/lib/arid_cache/cache_proxy.rb

@@ -1,25 +1,25 @@
 module AridCache
   class CacheProxy
     attr_accessor :object, :key, :opts, :blueprint, :cached, :cache_key, :block, :records, :combined_options, :klass
-    
+
     # AridCache::CacheProxy::Result
     #
     # This struct is stored in the cache and stores information we need
     # to re-query for results.
     Result = Struct.new(:ids, :klass, :count) do
-      
+
       def has_count?
         !count.nil?
       end
-        
+
       def has_ids?
         !ids.nil?
       end
-            
+
       def klass=(value)
         self['klass'] = value.is_a?(Class) ? value.name : value.class.name
       end
-      
+
       def klass
         self['klass'].constantize unless self['klass'].nil?
       end
@@ -27,17 +27,17 @@ module AridCache
 
     #
     # Managing your caches
-    # 
-    
+    #
+
     def self.clear_caches
       Rails.cache.delete_matched(%r[arid-cache-.*])
-    end 
-    
+    end
+
     def self.clear_class_caches(object)
       key = (object.is_a?(Class) ? object : object.class).name.downcase + '-'
       Rails.cache.delete_matched(%r[arid-cache-#{key}.*])
-    end 
-        
+    end
+
     def self.clear_instance_caches(object)
       key = (object.is_a?(Class) ? object : object.class).name.pluralize.downcase
       Rails.cache.delete_matched(%r[arid-cache-#{key}.*])
@@ -46,11 +46,11 @@ module AridCache
     #
     # 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
@@ -62,14 +62,14 @@ module AridCache
       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)
     end
-            
+
     def fetch_count
       if refresh_cache?
         execute_count
@@ -83,13 +83,16 @@ module AridCache
         cached # what else can we do? return it
       end
     end
-          
+
     def fetch
       if refresh_cache?
         execute_find
       elsif cached.is_a?(AridCache::CacheProxy::Result)
         if cached.has_ids?
+
+          # Infer the class of the objects we are returning
           self.klass = cached.klass || object_base_class
+
           fetch_from_cache
         else
           execute_find
@@ -98,59 +101,90 @@ module AridCache
         cached # some base type, return it
       end
     end
-      
+
     private
 
+      # Return a list of records from the database using the ids from
+      # the cached Result.
+      #
+      # The result is paginated if the :page option is preset, otherwise
+      # a regular list of ActiveRecord results is returned.
+      #
+      # If no :order is specified, the current ordering of the ids is
+      # preserved with some fancy SQL.
       def fetch_from_cache
         if paginate?
-          fetch_and_paginate
-        elsif limit_or_offset?
-          fetch_and_limit
-        else
-          klass.find_all_by_id(cached.ids, opts_for_find)
-        end        
-      end
-      
-      def fetch_and_paginate
-        if combined_options.include?(:order) # order and paginate in the database
-          klass.paginate(cached.ids, { :total_entries => cached.ids.size }.merge(opts_for_find.merge(opts_for_paginate)))
-        else # paginate in memory
-          paged_ids = cached.ids.paginate(opts_for_paginate)
-          paged_ids.replace(klass.find_all_by_id(paged_ids, opts_for_find(paged_ids)))
-        end        
-      end
-      
-      def fetch_and_limit
-        if combined_options.include?(:order)
+
+          # Return a paginated collection
+
+          if cached.ids.empty?
+
+            # No ids, return an empty WillPaginate result
+
+            [].paginate(opts_for_paginate)
+
+          elsif combined_options.include?(:order)
+
+            # An order has been specified.  We have to go to the database
+            # and paginate there because the contents of the requested
+            # page will be different.
+
+            klass.paginate(cached.ids, { :total_entries => cached.ids.size }.merge(opts_for_find.merge(opts_for_paginate)))
+
+          else
+
+            # Order is unchanged.  We can paginate in memory and only select
+            # those ids that we actually need.  This is the most efficient.
+
+            paged_ids = cached.ids.paginate(opts_for_paginate)
+            paged_ids.replace(klass.find_all_by_id(paged_ids, opts_for_find(paged_ids)))
+
+          end
+
+        elsif cached.ids.empty?
+
+          # We are returning a regular (non-paginated) result.
+          # If we don't have any ids, that's an empty result
+          # in any language.
+
+          []
+
+        elsif combined_options.include?(:order)
+
+          # An order has been specified, so use it.
+
           klass.find_all_by_id(cached.ids, opts_for_find)
+
         else
+
+          # No order has been specified, so we have to maintain
+          # the current order.  We do this by passing some extra
+          # SQL which orders by the current array ordering.
+
           offset, limit = combined_options.delete(:offset) || 0, combined_options.delete(:limit) || cached.count
           ids = cached.ids[offset, limit]
+
           klass.find_all_by_id(ids, opts_for_find(ids))
-        end          
+        end
       end
-      
+
       def paginate?
         combined_options.include?(:page)
       end
-      
-      def limit_or_offset?
-        combined_options.include?(:limit) || combined_options.include?(:offset)
-      end
-      
+
       def refresh_cache?
         cached.nil? || opts[:force]
       end
-      
+
       def get_records
         block = self.block || (blueprint && blueprint.proc)
         self.records = block.nil? ? object.instance_eval(key) : object.instance_eval(&block)
       end
-      
+
       def execute_find
-        get_records        
+        get_records
         cached = AridCache::CacheProxy::Result.new
-        
+
         if !records.is_a?(Enumerable) || (!records.empty? && !records.first.is_a?(::ActiveRecord::Base))
           cached = records # some base type, cache it as itself
         else
@@ -165,7 +199,7 @@ module AridCache
           end
         end
         Rails.cache.write(cache_key, cached, opts_for_cache)
-        
+
         self.cached = cached
         return_records(records)
       end
@@ -187,20 +221,20 @@ module AridCache
       # If you do want a specialized, modified, or subset of the collection it's best
       # to define it in a block and have a new cache for it:
       #
-      # model.my_special_collection { the_collection(:order => 'new order', :limit => 10) }      
+      # model.my_special_collection { the_collection(:order => 'new order', :limit => 10) }
       def return_records(records)
         if opts.include?(:page)
           records = records.respond_to?(:to_a) ? records.to_a : records
           records.respond_to?(:paginate) ? records.paginate(opts_for_paginate) : records
         elsif opts.include?(:limit)
           records = records.respond_to?(:to_a) ? records.to_a : records
-          offset = opts[:offset] || 0 
+          offset = opts[:offset] || 0
           records[offset, opts[:limit]]
         else
           records
-        end      
+        end
       end
-      
+
       def execute_count
         get_records
         cached = AridCache::CacheProxy::Result.new
@@ -224,14 +258,14 @@ module AridCache
         else
           cached = records # some base type, cache it as itself
         end
-        
+
         Rails.cache.write(cache_key, cached, opts_for_cache)
         self.cached = cached
         cached.respond_to?(:count) ? cached.count : cached
       end
-      
+
       OPTIONS_FOR_PAGINATE = [:page, :per_page, :total_entries, :finder]
-      
+
       # Filter options for paginate, if *klass* is set, we get the :per_page value from it.
       def opts_for_paginate
         paginate_opts = combined_options.reject { |k,v| !OPTIONS_FOR_PAGINATE.include?(k) }
@@ -239,11 +273,11 @@ module AridCache
         paginate_opts[:per_page] = klass.per_page if klass && !paginate_opts.include?(:per_page)
         paginate_opts
       end
-    
+
       OPTIONS_FOR_FIND = [ :conditions, :include, :joins, :limit, :offset, :order, :select, :readonly, :group, :having, :from, :lock ]
 
       # Preserve the original order of the results if no :order option is specified.
-      # 
+      #
       # @arg ids array of ids to order by unless an :order option is specified.  If not
       #      specified, cached.ids is used.
       def opts_for_find(ids=nil)
@@ -252,40 +286,40 @@ module AridCache
         find_opts[:order] = preserve_order(ids) unless find_opts.include?(:order)
         find_opts
       end
-      
+
       OPTIONS_FOR_CACHE = [ :expires_in ]
-      
+
       def opts_for_cache
         combined_options.reject { |k,v| !OPTIONS_FOR_CACHE.include?(k) }
       end
 
       OPTIONS_FOR_CACHE_KEY = [ :auto_expire ]
-      
+
       def opts_for_cache_key
         combined_options.reject { |k,v| !OPTIONS_FOR_CACHE_KEY.include?(k) }
       end
-            
+
       def object_base_class #:nodoc:
         object.is_a?(Class) ? object : object.class
       end
 
       # Generate an ORDER BY clause that preserves the ordering of the ids in *ids*.
       #
-      # The method we use depends on the database adapter because only MySQL 
+      # The method we use depends on the database adapter because only MySQL
       # supports the ORDER BY FIELD() function.  For other databases we use
       # a CASE statement.
-      # 
+      #
       # TODO: is it quicker to sort in memory?
       def preserve_order(ids)
         if ids.empty?
           nil
         elsif ::ActiveRecord::Base.is_mysql_adapter?
-          "FIELD(id,#{ids.join(',')})" 
+          "FIELD(id,#{ids.join(',')})"
         else
           order = ''
           ids.each_index { |i| order << "WHEN id=#{ids[i]} THEN #{i+1} " }
           "CASE " + order + " END"
         end
-      end 
+      end
   end
 end

data/test/arid_cache_test.rb

@@ -10,50 +10,50 @@ class AridCacheTest < ActiveSupport::TestCase
     assert_instance_of AridCache::Store, AridCache.store
     assert_same AridCache::CacheProxy, AridCache.cache
   end
-      
+
   test "should respond to methods" do
     assert User.respond_to?(:clear_caches)
-    assert @user.respond_to?(:clear_caches)    
+    assert @user.respond_to?(:clear_caches)
     assert_instance_of AridCache::Store, AridCache.store
     assert_same AridCache::CacheProxy, AridCache.cache
   end
-    
+
   test "should not clobber model methods" do
     assert_respond_to @user, :name
     assert_respond_to Company.first, :name
     assert_nothing_raised { @user.name }
     assert_nothing_raised { Company.first.name }
   end
-  
+
   test "should not clobber method_missing" do
     assert_nothing_raised { @user.is_high? }
-    assert @user.is_high?  
+    assert @user.is_high?
   end
-     
+
   test "should not clobber respond_to?" do
     assert @user.respond_to?(:respond_not_overridden)
   end
-     
+
   test "should raise an error on invalid dynamic caches" do
     assert_raises ArgumentError do
       @user.cached_invalid_companies
     end
   end
-  
+
   test "should create dynamic caches given valid arguments" do
     assert_nothing_raised { @user.cached_companies }
   end
-  
+
   test "counts queries correctly" do
     assert_queries(1) { User.all }
   end
-  
+
   test "returns valid results" do
     @one = @user.cached_companies
     assert_equal @user.companies, @one
     assert_equal @user.companies.count, @one.size
   end
-  
+
   test "paginates results" do
     results = @user.cached_companies(:page => 1, :per_page => 3, :order => 'name desc')
     assert_kind_of WillPaginate::Collection, results
@@ -61,34 +61,34 @@ class AridCacheTest < ActiveSupport::TestCase
     assert_equal @user.companies.count, results.total_entries
     assert_equal 1, results.current_page
   end
-  
+
   test "should work for different pages" do
     results = @user.cached_companies(:page => 2, :per_page => 3)
     assert_kind_of WillPaginate::Collection, results
     assert results.size <= 3
-    assert_equal @user.companies.count, results.total_entries  
-    assert_equal 2, results.current_page  
-  end  
-  
+    assert_equal @user.companies.count, results.total_entries
+    assert_equal 2, results.current_page
+  end
+
   test "ignores random parameters" do
     result = @user.cached_companies(:invalid => :params, 'random' => 'values', :user_id => 3)
     assert_equal @user.companies, result
   end
-  
+
   test "passes on options to find" do
     actual = @user.cached_companies(:order => 'users.id DESC')
     expected = @user.companies
     assert_equal expected, actual
     assert_equal expected.first, actual.first
   end
-    
+
   test "caches the count when it gets records" do
     assert_queries(1) do
       @user.cached_companies
       @user.cached_companies_count
     end
   end
-        
+
   test "gets the count only if it's requested first" do
     count = @user.companies.count
     assert_queries(1) do
@@ -100,7 +100,7 @@ class AridCacheTest < ActiveSupport::TestCase
       assert_equal count, @user.cached_companies_count
     end
   end
-  
+
   test "applies limit and offset" do
     result = @user.cached_limit_companies do
       companies
@@ -108,22 +108,22 @@ class AridCacheTest < ActiveSupport::TestCase
     limit_two_result = @user.cached_limit_companies(:limit => 2)
     assert_equal 2, limit_two_result.size
     assert_equal result[0, 2], limit_two_result
-    
+
     limit_three_result = @user.cached_limit_companies(:limit => 3)
     assert_equal 3, limit_three_result.size
     assert_equal result[0, 3], limit_three_result
-  
+
     limit_two_offset_one_result = @user.cached_limit_companies(:limit => 2, :offset => 1)
     assert_equal 2, limit_two_offset_one_result.size
     assert_equal result[1, 2], limit_two_offset_one_result
-    
+
     offset_one_result = @user.cached_limit_companies(:offset => 1)
     assert_equal result.size-1, offset_one_result.size
     assert_equal result[1, result.size], offset_one_result
-            
+
     assert_equal @user.companies.all(:limit => 2, :offset => 1), @user.cached_limit_companies(:limit => 2, :offset => 1)
-    assert_equal @user.companies.size, @user.cached_limit_companies.size    
-    
+    assert_equal @user.companies.size, @user.cached_limit_companies.size
+
     # Careful of this Rails bug: https://rails.lighthouseapp.com/projects/8994/tickets/1349-named-scope-with-group-by-bug
     User.cached_successful_limit_companies do
       User.successful.all
@@ -131,27 +131,27 @@ class AridCacheTest < ActiveSupport::TestCase
     assert_equal 2, User.cached_successful_limit_companies(:limit => 2).size
     assert_equal 3, User.cached_successful_limit_companies(:limit => 3).size
     assert_equal User.successful.all(:limit => 2, :offset => 1), User.cached_successful_limit_companies(:limit => 2, :offset => 1)
-    assert_equal User.successful.all.size, User.cached_successful_limit_companies.size  
+    assert_equal User.successful.all.size, User.cached_successful_limit_companies.size
   end
-  
+
   test "should requery the database for limits with order" do
     @user.cached_companies # prime the cache
     assert_equal @user.companies.find(:all, :limit => 3, :order => 'name DESC'), @user.cached_companies(:limit => 3, :order => 'name DESC')
     assert_equal @user.companies.find(:all, :limit => 3, :order => 'name ASC'), @user.cached_companies(:limit => 3, :order => 'name ASC')
   end
-  
+
   test "should activate will paginate" do
     assert_nothing_raised do
       User.paginate(:page => 1)
     end
   end
-  
+
   test "should requery the database for paginate with order" do
     @user.cached_companies # prime the cache
     assert_equal @user.companies.paginate(:page => 1, :per_page => 3, :order => 'name DESC'), @user.cached_companies(:page => 1, :per_page => 3, :order => 'name DESC')
     assert_equal @user.companies.paginate(:page => 1, :per_page => 3, :order => 'name ASC'), @user.cached_companies(:page => 1, :per_page => 3, :order => 'name ASC')
   end
-    
+
   test "pagination should not result in an extra query" do
     assert_queries(1) do
       @user.cached_big_companies(:page => 1)
@@ -160,7 +160,7 @@ class AridCacheTest < ActiveSupport::TestCase
       User.cached_companies(:page => 1)
     end
   end
-  
+
   test "should support a 'force' option" do
     # ActiveRecord caches the result of the proc, so we need to
     # use different instances of the user to test the force option.
@@ -177,7 +177,7 @@ class AridCacheTest < ActiveSupport::TestCase
       assert_equal size, uncached_user.cached_companies_count(:force => true)
     end
   end
-  
+
   test "should handle various different model instances" do
     one = User.first
     two = User.first :offset => 1
@@ -185,13 +185,13 @@ class AridCacheTest < ActiveSupport::TestCase
     assert_equal one.companies, one.cached_companies
     assert_equal two.companies, two.cached_companies
   end
-  
+
   test "should handle arrays of non-active record instances" do
     assert_equal @user.pet_names, @user.cached_pet_names
     assert_equal @user.pet_names, @user.cached_pet_names
     assert_equal @user.pet_names.count, @user.cached_pet_names_count
   end
-             
+
   test "should empty the Rails cache" do
     @user.cached_companies
     User.cached_companies
@@ -199,9 +199,9 @@ class AridCacheTest < ActiveSupport::TestCase
     assert Rails.cache.exist?(User.arid_cache_key('companies'))
     User.clear_caches
     assert !Rails.cache.exist?(@user.arid_cache_key('companies'))
-    assert !Rails.cache.exist?(User.arid_cache_key('companies'))   
+    assert !Rails.cache.exist?(User.arid_cache_key('companies'))
   end
-  
+
   test "should support expiring caches" do
     # The first query should put the count in the cache.  The second query
     # should read the count from the cache.  The third query should
@@ -213,16 +213,16 @@ class AridCacheTest < ActiveSupport::TestCase
       User.cached_companies_count(:expires_in => 1.second)
     end
   end
-  
+
   test "should support an auto-expire option" do
     assert_match %r[users/#{@user.id}-companies], @user.arid_cache_key('companies')
     assert_equal @user.arid_cache_key('companies'), @user.arid_cache_key('companies', :auto_expire => false)
     assert_match %r[users/#{@user.id}-\d{14}-companies], @user.arid_cache_key('companies', :auto_expire => true)
-    
+
     # It doesn't apply to class caches, but shouldn't affect it either
     assert_equal User.arid_cache_key('companies'), User.arid_cache_key('companies', :auto_expire => true)
   end
-  
+
   test "should turn off auto-expire by default" do
     assert_queries(2) do
       @user.cached_companies_count
@@ -230,7 +230,7 @@ class AridCacheTest < ActiveSupport::TestCase
       @user.cached_companies_count
     end
   end
-  
+
   test "should reload auto-expired caches" do
     assert_queries(2) do
       @user.cached_companies_count(:auto_expire => true)
@@ -240,29 +240,29 @@ class AridCacheTest < ActiveSupport::TestCase
       @user.cached_companies_count(:auto_expire => true)
     end
   end
-        
+
   test "should support configuring instance caches" do
     User.instance_caches { best_companies { companies } }
     assert_equal @user.companies, @user.cached_best_companies
   end
-  
+
   test "instance caches should work on all instances of the class" do
     User.instance_caches { best_companies { companies } }
     assert_equal @user.cached_best_companies, User.first.cached_best_companies
   end
-  
+
   test "should support configuring class caches" do
     User.class_caches { successful_users { successful } }
     assert_equal User.successful, User.cached_successful_users
   end
-  
+
   test "should create valid store keys" do
     assert_equal 'user-key', AridCache.store.send(:class_store_key, User, 'key')
     assert_equal 'users-key', AridCache.store.send(:instance_store_key, User, 'key')
     assert_equal AridCache.store.send(:instance_store_key, User, 'key'), AridCache.store.send(:object_store_key, @user, 'key')
     assert_equal AridCache.store.send(:class_store_key, User, 'key'), AridCache.store.send(:object_store_key, User, 'key')
   end
-  
+
   test "configuring caches should not perform any queries" do
     User.instance_caches do
       best_companies { companies }
@@ -271,7 +271,7 @@ class AridCacheTest < ActiveSupport::TestCase
       best_companies(:order => 'name DESC') { companies.find(:all, :order => 'name DESC') }
     end
   end
-  
+
   test "should support options in the cache configuration" do
     User.instance_caches(:auto_expire => true) do
       expires_in = 1.second
@@ -289,9 +289,9 @@ class AridCacheTest < ActiveSupport::TestCase
     # Call it twice to ensure that on the second call the order is applied when retrieving the
     # records by id
     assert_equal User.successful.find(:all, :order => 'name DESC'), User.cached_most_successful
-    assert_equal User.successful.find(:all, :order => 'name DESC'), User.cached_most_successful   
+    assert_equal User.successful.find(:all, :order => 'name DESC'), User.cached_most_successful
   end
-  
+
   test "should not raise an error if all cached ids cannot be found" do
     @user.cached_companies
     key = @user.arid_cache_key('companies')
@@ -301,7 +301,7 @@ class AridCacheTest < ActiveSupport::TestCase
     assert_nothing_raised { @user.cached_companies }
     assert_equal @user.cached_companies, @user.companies
   end
-  
+
   test "should not raise an error if all cached ids cannot be found while paginating" do
     @user.cached_companies
     key = @user.arid_cache_key('companies')
@@ -311,7 +311,7 @@ class AridCacheTest < ActiveSupport::TestCase
     assert_nothing_raised { @user.cached_companies(:page => 1, :order => 'name DESC') }
     assert_equal @user.cached_companies(:page => 1, :order => 'name DESC'), @user.companies.paginate(:page => 1, :order => 'name DESC')
   end
-  
+
   test "should handle empty collections" do
     @user.cached_empty_collection { [] }
     assert_nothing_raised { @user.cached_empty_collection }
@@ -337,12 +337,40 @@ class AridCacheTest < ActiveSupport::TestCase
     end
     assert_equal @user.companies.all(:order => 'name DESC'), AridCache.cache.fetch(@user, 'my-fancy-key', :order => 'name DESC') { companies }
   end
-                    
+
+  test "empty user relation should be empty" do
+    assert_equal [], @user.empty_user_relations
+  end
+
+  test "should not query the database for ids when the list is empty" do
+    assert_queries(1) do
+      @user.cached_empty_user_relations
+      result = @user.cached_empty_user_relations
+      assert_kind_of Array, result
+    end
+  end
+
+  test "should not query the database for ids when the list is empty and we are paginating" do
+    assert_queries(1) do
+      @user.cached_empty_user_relations(:page => 1)
+      result = @user.cached_empty_user_relations(:page => 1)
+      assert_kind_of WillPaginate::Collection, result
+    end
+  end
+
+  test "should not query the database for ids when the list is empty and we are applying limits etc" do
+    assert_queries(1) do
+      @user.cached_empty_user_relations(:limit => 10)
+      result = @user.cached_empty_user_relations(:limit => 10)
+      assert_kind_of Array, result
+    end
+  end
+
   #
   # Tests requiring manual verification by looking at the SQL logs.
   # TODO move these to a separate class.
   #
-   
+
   test "should preserve original ordering" do
     # TODO.  This one is hard to test because SQL usually keeps the same ordering
     # and it's difficult to make it do otherwise.  Best to just inspect the queries
@@ -350,13 +378,13 @@ class AridCacheTest < ActiveSupport::TestCase
     @user.cached_companies
     @user.cached_companies
   end
-  
+
   test "should paginate collections in memory" do
     # TODO.  Tough to test because we can't just count queries
     # have to look at the SQL in the logs for this one.
     @user.cached_companies(:page => 2, :per_page => 3)
     @user.cached_companies(:page => 1, :per_page => 3)
-  end  
+  end
 
   protected
 

data/test/db/schema.rb

@@ -4,12 +4,16 @@ ActiveRecord::Schema.define do
     t.column "email", :text
     t.timestamps
   end
-  
+
   create_table "companies", :force => true do |t|
     t.column "name",  :text
     t.column "owner_id", :integer
     t.column "country_id", :integer
-    t.column "employees", :integer    
+    t.column "employees", :integer
     t.timestamps
   end
+
+  create_table "empty_user_relations", :force => true do |t|
+    t.column "user_id", :integer
+  end
 end

data/test/models/empty_user_relation.rb

@@ -0,0 +1,5 @@
+require 'arid_cache'
+
+class EmptyUserRelation < ActiveRecord::Base
+  belongs_to :user
+end

data/test/models/user.rb

@@ -2,6 +2,7 @@ require 'arid_cache'
 
 class User < ActiveRecord::Base
   has_many :companies, :foreign_key => :owner_id
+  has_many :empty_user_relations  # This must always return an empty list
   named_scope :companies, :joins => :companies
   named_scope :successful, :joins => :companies, :conditions => 'companies.employees > 50', :group => 'users.id'
   

data/test/test_helper.rb

@@ -11,7 +11,7 @@ require 'test/unit' # required by ActiveSupport::TestCase
 require 'will_paginate'
 require 'ruby-debug'
 
-# Activate Will Paginate 
+# Activate Will Paginate
 WillPaginate.enable_activerecord
 
 # Add support for expiring file-cache store.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: arid_cache
 version: !ruby/object:Gem::Version 
-  version: 0.2.7
+  version: 1.0.0
 platform: ruby
 authors: 
 - Karl Varga
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-21 00:00:00 +08:00
+date: 2010-07-05 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -90,6 +90,7 @@ files:
 - test/lib/blueprint.rb
 - test/log/.gitignore
 - test/models/company.rb
+- test/models/empty_user_relation.rb
 - test/models/user.rb
 - test/test_helper.rb
 has_rdoc: true
@@ -129,5 +130,6 @@ test_files:
 - test/lib/active_support/cache/file_store_extras.rb
 - test/lib/blueprint.rb
 - test/models/company.rb
+- test/models/empty_user_relation.rb
 - test/models/user.rb
 - test/test_helper.rb