arid_cache 0.2.3 → 0.2.4

data/.gitignore

@@ -21,3 +21,4 @@ pkg
 ## PROJECT::SPECIFIC
 test/**/*.log
 test/tmp/*
+tmp

data/README.rdoc

@@ -40,7 +40,7 @@ You can also define caches that use compositions of methods or named scopes, or
 
 If the result of your <tt>cached_</tt> call is an array of ActiveRecords, AridCache only stores the IDs in the cache (because it's a bad idea to store records in the cache).
 
-On subsequent calls we call <tt>find</tt> on the target class passing in the ActiveRecord IDs that were stored in the cache.  AridCache will preserve the original ordering of your collection (you can change this using the <tt>:order</tt>).
+On subsequent calls we call <tt>find_all_by_id</tt> on the target class passing in the ActiveRecord IDs that were stored in the cache.  AridCache will preserve the original ordering of your collection (you can change this using the <tt>:order</tt>).
 
 The idea here is to cache collections that are expensive to query.  Once the cache is loaded, retrieving the cached records from the database simply involves a <tt>SELECT * FROM table WHERE id IN (ids, ...)</tt>.
 
@@ -136,11 +136,13 @@ AridCache cache keys are defined based on the methods you call to interact with
   Album.cached_featured_albums  => cache key is arid-cache-album-featured_albums
   album.cached_top_tracks       => cache key is arid-cache-albums/<id>-top_tracks
     
-Caches on model instances can be set to automatically incorporate the ActiveRecord <tt>cache_key</tt> which includes the <tt>updated_at</tt> timestamp of that instance, making them auto-expire when the instance is updated.  To turn it on pass <tt>:auto_expire => true</tt> to your cache.
+Caches on model instances can be set to automatically incorporate the ActiveRecord <tt>cache_key</tt> which includes the <tt>updated_at</tt> timestamp of that instance, making them auto-expire when the instance is updated.  
+
+To incorporate the the <tt>cache_key</tt> pass <b><tt>:auto_expire => true</tt></b> to your cache method:
 
   album.cached_top_tracks(:auto_expire => true) => cache key like arid-cache-albums/2-20091211120100-top_tracks
 
-Or via the cache configuration,
+Or via the cache configuration:
 
   Album.instance_caches do
     top_tracks(:auto_expire => true)
@@ -163,14 +165,16 @@ AridCache provides methods to help you clear your caches:
   Model.clear_instance_caches => expires instance-level caches for this model
   Model.clear_class_caches    => expires class-level caches for this model
   
-(The <tt>Model.clear_caches</tt> methods are also available on all model instances.  Your cache store will need to support the <tt>delete_matched</tt> method for these to work.)
+The <tt>Model.clear_caches</tt> methods are also available on all model instances.
 
-Alternatively you can pass a <tt>:force => true</tt> option in your <tt>cached_</tt> calls to force a refresh of a particular cache, while still returning the refreshed results.  For example:
+<B>Your cache store needs to support the <tt>delete_matched</tt> method for the above to work. Currently MemCacheStore and MemoryStore do not.</b>
+ 
+Alternatively you can pass a <b><tt>:force => true</tt></b> option in your <tt>cached_</tt> calls to force a refresh of a particular cache, while still returning the refreshed results.  For example:
 
   Album.cached_featured_albums(:force => true)  => returns featured albums
   album.cached_top_tracks(:force => true)       => returns top tracks
 
-You can pass an <tt>:expires_in</tt> option to your caches to manage your cache expiry (if your cache store supports this option).
+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).
 
   Album.cached_featured_albums(:expires_in => 1.day)
   album.cached_top_tracks(:expires_in => 1.day)
@@ -277,7 +281,7 @@ The version of Rails shouldn't matter much, but it's working on 2.3.4.
 
 == Known Issues
 
-1. Caches that contains duplicate records (for example from the result of a join), will only return unique records on subsequent calls.  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([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.
+1. Caches that contains duplicate records (for example from the result of a join), will only return unique records on subsequent calls.  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.
 
 == Wish List / Coming Soon
 
@@ -285,6 +289,7 @@ The version of Rails shouldn't matter much, but it's working on 2.3.4.
 * 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
 

data/VERSION

@@ -1 +1 @@
-0.2.3
+0.2.4

data/arid_cache.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{arid_cache}
-  s.version = "0.2.3"
+  s.version = "0.2.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Karl Varga"]
-  s.date = %q{2010-01-19}
+  s.date = %q{2010-01-20}
   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.rb

@@ -107,7 +107,7 @@ module AridCache
         elsif limit_or_offset?
           fetch_and_limit
         else
-          klass.find(cached.ids, opts_for_find)
+          klass.find_all_by_id(cached.ids, opts_for_find)
         end        
       end
       
@@ -116,17 +116,17 @@ module AridCache
           klass.paginate(cached.ids, opts_for_find.merge(opts_for_paginate))
         else # paginate in memory
           paged_ids = cached.ids.paginate(opts_for_paginate)
-          paged_ids.replace(klass.find(paged_ids, opts_for_find(paged_ids)))
+          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)
-          klass.find(cached.ids, opts_for_find)
+          klass.find_all_by_id(cached.ids, opts_for_find)
         else
           offset, limit = combined_options.delete(:offset) || 0, combined_options.delete(:limit) || cached.count
           ids = cached.ids[offset, limit]
-          klass.find(ids, opts_for_find(ids))
+          klass.find_all_by_id(ids, opts_for_find(ids))
         end          
       end
       
@@ -230,11 +230,12 @@ module AridCache
         cached.respond_to?(:count) ? cached.count : cached
       end
       
-      OPTIONS_FOR_PAGINATE = [:page, :per_page, :total_entries]
+      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) }
+        paginate_opts[:finder] = :find_all_by_id unless paginate_opts.include?(:finder)
         paginate_opts[:per_page] = klass.per_page if klass && !paginate_opts.include?(:per_page)
         paginate_opts
       end
@@ -276,7 +277,9 @@ module AridCache
       # 
       # TODO: is it quicker to sort in memory?
       def preserve_order(ids)
-        if ::ActiveRecord::Base.is_mysql_adapter?
+        if ids.empty?
+          nil
+        elsif ::ActiveRecord::Base.is_mysql_adapter?
           "FIELD(id,#{ids.join(',')})" 
         else
           order = ''

data/test/arid_cache_test.rb

@@ -291,7 +291,33 @@ class AridCacheTest < ActiveSupport::TestCase
     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')
+    cached_result = Rails.cache.read(key)
+    cached_result.ids.push(24342234, 243234132)
+    Rails.cache.write(key, cached_result)
+    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')
+    cached_result = Rails.cache.read(key)
+    cached_result.ids.push(24342234, 243234132)
+    Rails.cache.write(key, cached_result)
+    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 }
+    assert_nothing_raised { @user.cached_empty_collection }
+  end
+                
   #
   # Tests requiring manual verification by looking at the SQL logs.
   # TODO move these to a separate class.
@@ -311,7 +337,7 @@ class AridCacheTest < ActiveSupport::TestCase
     @user.cached_companies(:page => 2, :per_page => 3)
     @user.cached_companies(:page => 1, :per_page => 3)
   end  
-        
+
   protected
 
     def assert_queries(num = 1)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: arid_cache
 version: !ruby/object:Gem::Version 
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors: 
 - Karl Varga
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-19 00:00:00 +08:00
+date: 2010-01-20 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency