arid_cache 0.1.1 → 0.2.1

data/.gitignore

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

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Karl Varga
+Copyright (c) 2009 Karl Varga <kjvarga@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,120 +1,279 @@
-== ARID Cache
+= AridCache
 
-ARID Cache makes caching easy and effective.  ARID cache supports caching on all your model named scopes, class methods and instance methods right out of the box.  ARID cache prevents caching logic from cluttering your models and clarifies your logic by making explicit calls to cached result sets.
+AridCache makes caching easy and effective.  AridCache supports caching on all of your ActiveRecord model named scopes, class and instance methods right out of the box.  AridCache keeps caching logic out of your model methods and clarifies your view code by making calls to cached result sets explicit.
 
-ARID Cache is designed for handling large, expensive ActiveRecord collections but is equally useful for caching anything else as well.
+AridCache supports caching large, expensive ActiveRecord collections by caching only the model IDs, provides efficient in-memory pagination of your cached collections, and gives you collection counts for free.  Non-ActiveRecord collection data is cached unchanged allowing you to cache the results of any expensive operation simply by prepending your method call with <tt>cached_</tt>.
 
-=== Counts for free
+AridCache simplifies caching by supporting auto-expiring cache keys - as well as common options like <tt>:expires_in</tt> - and provides methods to help you manage your caches at the global, model class, model instance and per-cache level.
 
-ARID Cache gives you counts for free.  When a large collection is stored in the cache
-ARID Cache stores the count as well so the next time you want request the count it
-just takes a single read from the cache.  This is also supported for your non-ActiveRecord
-collections if the collection <tt>responds_to?(:count)</tt>.
+== Install
 
-Given that we have a cache like <tt>album.cached_tracks</tt> we can get the count by calling <tt>album.cached_tracks_count</tt>.
+Add this to your <tt>config/environment.rb</tt> file:
   
-=== Auto-expiring cache keys
+  config.gem 'arid_cache'
   
-Caches on model instances 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.
+Then
 
-Caches on your model classes (like on the results of named scopes) will not expire however.
+  rake gems:install
 
-ARID cache provides methods to help you expire your caches.
-  
-  AridCache.clear_all_caches  => expires all ARID Cache caches
-  Model.clear_all_caches      => expires class and instance-level caches for this model
-  Model.clear_instance_caches => expires instance-level caches for this model
-  Model.clear_class_caches    => expires class-level caches for this model
+(Requires having GemCutter in your gem sources.)
+
+== Introduction
+
+The name AridCache comes from <b>A</b>ctive<b>R</b>ecord *ID* Cache.  It's also very DRY...get it? :)
+
+Out of the box AridCache supports caching on all your ActiveRecord class and instance methods and named scopes...basically if a class or class instance <tt>respond_to?</tt> something, you can cache it.
+
+The way you interact with the cache via your model methods is to prepend the method call with <tt>cached_</tt>.  The part of the method call after <tt>cached_</tt> serves as the basis for the cache key.  For example,
+
+  User.cached_count            # cache key is arid-cache-user-count
+  genre.cached_top_ten_tracks  # cache key is arid-cache-genres/<id>-top_ten_tracks
   
-These methods are also available on model instances.
+You can also define caches that use compositions of methods or named scopes, or other complex queries, without having to add a new method to your class.  This way you can also create different caches that all use the same method.  For example,
 
-ARID Cache keys are based on the method you call to create the cache.  For example:
-  Album.cached_featured_albums  => cache key is arid-cache-album-featured_albums
-  album.cached_top_tracks       => cache key like arid-cache-albums/2-20090930200-top_tracks
+  # cache key is arid-cache-user-most_active_users
+  User.cached_most_active_users do
+    active.find(:order => 'activity DESC', :limit => 5)
+  end
+
+=== ActiveRecord Collections
 
-=== Support for pagination and options to <tt>find</tt>
+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).
 
-ARID cache performs pagination and applies <tt>:limit</tt> and <tt>:offset</tt> to the IDs in memory and only selects the page/sub-set from the database, directly from the target table.
+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>).
 
-You can pass options like <tt>:include</tt> (or any other valid <tt>find</tt> options) to augment the results of your cached query.
+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>.
 
-=== Efficiency
+Consider how long it would take to get the top 10 favorited tracks of all time from a database with a million tracks and 100,000 users.  Now compare that to selecting 10 tracks by ID from the track table.  The performance gain is huge.
 
-ARID Cache 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.
+=== Base Types and Other Collections
 
-== Examples
+Arrays of non-ActiveRecords are stored as-is so you can cache arrays of strings and other types without problems.
 
-==== Given the following model:
+Any other objects (including single ActiveRecord objects) are cached and returned as-is.
+
+=== Example
+
+An example of caching using existing methods on your class:
 
   class User < ActiveRecord::Base
-    include AridCache
     has_many    :pets
     has_one     :preferences
     named_scope :active, :conditions => [ 'updated_at <= ', 5.minutes.ago ]
   end
 
-==== ARID Cache provides these methods:
- 
-  User.cached_active         # caches the user IDs and the count
-  User.cached_active_count   # gets the count for free
+  User.cached_count          # uses the built-in count method
+  User.cached_active         # only stores the IDs of the active users in the cache
+  User.cached_active_count   # returns the count of active users directly from the cache
 
-  user.cached_pets           # caches the pets IDs and the count
-  user.cached_pets_count     # gets the count for free
-   
-When we call these methods again, instead of doing a full select - usually including
-complex joins or over very large tables which makes this expensive - it just
-selects where the IDs are the cached IDs.
+  user.cached_pets_count     # only selects the count until the collection is requested
+  user.cached_pets           # loads the collection and stores the pets IDs in the cache
 
-It also gives you paging using WillPaginate.  The IDs from the cache are paginated and
-only that page is selected from the database - again directly from the table, without
-any complex joins.
+== Defining Your Caches
 
-==== Some examples of pagination:
+=== Dynamically
 
-  User.cached_active.paginate(:page => 1, :per_page => 30)
-  User.cached_active.paginate(:page => 1)
-  User.cached_active.paginate(:page => 3)
+To dynamically define caches just pass a block to your <tt>cached_</tt> calls.  Caches can be defined on your classes or class instances.  For example,
 
-You can also include options for find, such as <tt>:join</tt>, <tt>:include</tt> and <tt>order</tt>...basically any options that find supports.
+  User.cached_most_active_users do
+    active.find(:order => 'activity DESC', :limit => 5)
+  end
+  
+  => [#<User id: 23>, #<User id: 30>, #<User id: 5>, #<User id: 2>, #<User id: 101>]
+  
+  user.cached_favorite_pets do
+    pets.find(:all, :conditions => { 'favorite' => true })
+  end
+  
+  => [#<Pet id: 11>, #<Pet id: 21>, #<Pet id: 3>]
 
-  User.cached_active.paginate(:page => 1, :include => :preferences)
-  User.cached_active.paginate(:page => 1, :order => 'created_at DESC') # don't change the order, just enforce it
+=== Configuring Caches on your Models
 
-You can limit the results returned using <tt>:limit</tt> and <tt>:offset</tt>:
+We can clean up our views significantly by configuring caches on our model rather than defining them dynamically and passing options in each time.  You configure caches by calling <tt>instance_caches(options={})</tt> or <tt>class_caches(options={})</tt> with a block and defining your caches inside the block (you don't need to prepend <tt>cached_</tt> when defining these caches because we are not returning results, just storing options).
 
-  user.cached_pets(:limit => 2, :include => :toys)
-  user.cached_pets(:limit => 2, :offset => 3, :include => :toys)
-  
-==== You can dynamically create caches
+You can pass a hash of options to <tt>instance_caches</tt> and <tt>class_caches</tt> to have those options applied to all caches in the block.  The following is a more complex example that also demonstrates nested cached calls.
 
-  User.cached_most_active_users do
-    self.active.find(:order => 'activity DESC', :limit => 10)
+  # app/models/genre.rb
+  class Genre
+    class_caches do
+      most_popular do
+        popular(:limit => 10, :order => 'popularity DESC')
+      end
+    end
+    
+    instance_caches(:order => 'release_date DESC') do
+      highlight_tracks(:include => [:album, :artist]) do
+        cached_tracks(:limit => 10, :include => [:album, :artist])
+      end
+      highlight_artists do
+        cached_artists(:limit => 10)
+      end
+      highlight_albums(:include => :artist) do
+        cached_albums(:limit => 3, :include => :artist)
+      end
+    end
   end
+  
+  # app/controllers/genre_controller.rb
+  @most_popular = Genre.cached_most_popular
+  @tracks  = @genre.cached_highlight_tracks
+  @artists = @genre.cached_highlight_artists
+  @albums  = @genre.cached_highlight_albums
 
-Dynamic caches that make use of other cached collections:
+You can configure your caches in this manner wherever you want, but I think the model is a good place.  If you wanted to move all your cache configurations to a file in <tt>lib</tt> or elsewhere, your calls would look like,
 
-  @tracks  = @genre.cached_highlight_tracks(:order => 'release_date DESC', :include => [:album, :artist]) do
-    cached_tracks(:order => 'release_date DESC', :limit => 10, :include => [:album, :artist])
+  Genre.class_caches do
+    ...
   end
-  @artists = @genre.cached_highlight_artists do
-    cached_artists(:limit => 10)
-  end
-  @albums  = @genre.cached_highlight_albums(:order => 'release_date DESC', :include => :artist) do
-    cached_albums(:order => 'release_date DESC', :limit => 3, :include => :artist)
+  Genre.instance_caches do
+    ...
   end
+
+==  Cache Keys & Managing your Caches
+
+=== Cache Keys
+
+AridCache cache keys are defined based on the methods you call to interact with the cache.  For example:
+
+  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
     
-More docs to come...
+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.
+
+  album.cached_top_tracks(:auto_expire => true) => cache key like arid-cache-albums/2-20091211120100-top_tracks
+
+Or via the cache configuration,
+
+  Album.instance_caches do
+    top_tracks(:auto_expire => true)
+  end
+
+If you need to examine values in the cache yourself you can build the AridCache key by calling <tt>arid_cache_key('method')</tt> on your object.  Using the examples above we would call,
+
+  Album.arid_cache_key('featured_albums') => arid-cache-album-featured_albums
+  album.arid_cache_key('top_tracks')      => arid-cache-albums/2-top_tracks
+  album.arid_cache_key('top_tracks', :auto_expire => true) => arid-cache-albums/2-20091211120100-top_tracks
   
-== Note on Patches/Pull Requests
+== Managing your Caches
+
+=== Deleting & Expiring Caches
+
+AridCache provides methods to help you clear your caches:
+  
+  AridCache.clear_caches      => expires all AridCache caches
+  Model.clear_caches          => expires class and instance-level caches for this model
+  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.)
+
+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:
+
+  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).
+
+  Album.cached_featured_albums(:expires_in => 1.day)
+  album.cached_top_tracks(:expires_in => 1.day)
+
+Or via the cache configuration,
+
+  Album.instance_caches(:expires_in => 1.day) do
+    top_tracks
+    featured_albums
+  end
+
+If you would like to be able to pass more options to your cache store (like <tt>:raw</tt>, <tt>:unless_exist</tt>, etc), just add them to the <tt>AridCache::CacheProxy::OPTIONS_FOR_CACHE</tt> class constant, for example
+
+  AridCache::CacheProxy::OPTIONS_FOR_CACHE.push(:raw, :unless_exist)
+
+== Extras 
+
+=== Cached Counts
+
+AridCache gives you counts for free.  When a collection is stored in the cache
+AridCache stores the count as well so the next time you request the count it
+just takes a single read from the cache.
+
+To get the count just append <tt>_count</tt> to your <tt>cached_</tt> call.  For example, if we have a cache like <tt>album.cached_tracks</tt> we can get the count by calling,
+  
+  album.cached_tracks        => returns an array of tracks
+  album.cached_tracks_count  => returns the count with a single read from the cache
+
+This is also supported for your non-ActiveRecord collections if the collection <tt>responds_to?(:count)</tt>.  For example,
+
+  album.cached_similar_genres       => returns ['Pop', 'Rock', 'Rockabilly']
+  album.cached_similar_genres_count => returns 3
+  
+Sometimes you may want the collection count without loading and caching the collection itself.  AridCache is smart enough that if you only ask for a count it will only query for the count.  This is only possible if the return value of your method is a named scope or association proxy (since these are lazy-loaded unlike a call to <tt>find()</tt>).
+
+In the example above if we only ever call <tt>album.cached_tracks_count</tt>, only the count will be cached.  If we subsequently call <tt>album.cached_tracks</tt> the collection will be loaded and the IDs cached as per normal.
+
+Other methods for caching counts are provided for us by virtue of ActiveRecord's built-in methods and named scopes, for example,
+
+  Artist.cached_count  # takes advantage of the built-in method Artist.count
+
+=== Pagination
+
+AridCache supports pagination using WillPaginate.  If you are not changing the order of the cached collection the IDs are paginated in memory and only that page is selected from the database - directly from the target table, which is extremely fast.
+
+An advantage of using AridCache is that since we already have the size of the collection in the cache no query is required to set the <tt>:total_entries</tt> on the <tt>WillPaginate::Collection</tt>.
+
+To paginate just pass a <tt>:page</tt> option in your call to <tt>cached_</tt>.  If you don't pass a value for <tt>:per_page</tt> AridCache gets the value from <tt>Model.per_page</tt>.
+
+Some examples of pagination:
+
+  User.cached_active(:page => 1, :per_page => 30)
+  User.cached_active(:page => 2)                  # uses User.per_page 
+  user.cached_pets(:page => 1)                    # uses Pet.per_page
+
+If you want to paginate using a different ordering, pass an <tt>:order</tt> option.  Because the order is being changed AridCache cannot paginate in memory.  Instead, the cached IDs are passed to your <tt>Model.paginate</tt> method along with any other options and the database will order the collection and apply limits etc.
+
+For example, the following queries will work:
+
+  user.cached_companies(:page => 1, :per_page => 3, :order => 'name DESC')
+  user.cached_companies(:page => 1, :per_page => 3, :order => 'name ASC')
+  
+=== Limit & Offset
+
+You apply <tt>:limit</tt> and <tt>:offset</tt> options in a similar manner to the <tt>:page</tt> and <tt>:per_page</tt> options.  The limit and offset will be applied in memory and only the resulting subset selected from the target table - unless you specify a new order.
+
+  user.cached_pets(:limit => 2, :include => :toys)
+  user.cached_pets(:limit => 2, :offset => 3, :include => :toys)
+  genre.cached_top_ten_tracks { cached_tracks(:limit => 10, :order => 'popularity DESC') }
+  
+=== Other Options to <tt>find</tt>
+  
+You can pass options like <tt>:include</tt> (or any other valid <tt>find</tt> options) to augment the results of your cached query.  Just because all of the options are supported, does not mean it's a good idea to use them, though.  Take a look at your logs to see how AridCache is interacting with the cache and the database if you don't get the results you expect.
+
+For example, assume we have a <tt>named_scope :active</tt> on <tt>User</tt> which gives the active users.  We can call:
+  
+  User.cached_active.paginate(:page => 2, :per_page => 10, :include => :preferences)
+  User.cached_active(:limit => 10, :offset => 10, :include => :preferences)
+
+(These calls return similar results, except that the first call returns a <tt>WillPaginate::Collection</tt> and the second just returns an <tt>Array</tt>.)
+  
+== 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.
+* In-memory pagination of cached collections speeds up your queries.  See _Pagination_.
+* If you only request a count AridCache will only select the count.  See <i>Cached Counts</i>.
+* If a collection has already been loaded, you get the count for free.  See <i>Cached Counts</i>.
+
+== 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.
+
+== Contributions
+
+Contributions are welcome!  Please,
 
 * Fork the project.
 * Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but
-  bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
+* Add tests for it (this is important so I don't break it in a future release).
+* Commit (don't mess with the Rakefile, version, or history).
+* Send me a pull request.
 
 == Copyright
 

data/Rakefile

@@ -7,16 +7,17 @@ begin
     gem.name = "arid_cache"
     gem.summary = %Q{Automates efficient caching of your ActiveRecord collections, gives you counts for free and supports pagination.}
     gem.description = <<-END.gsub(/^\s+/, '')
-      ARID Cache makes caching easy and effective.  ARID cache supports caching on all your model named scopes, class methods and instance methods right out of the box.  ARID cache prevents caching logic from cluttering your models and clarifies your logic by making explicit calls to cached result sets.
+      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.
       
-      ARID Cache is designed for handling large, expensive ActiveRecord collections but is equally useful for caching anything else as well.
+      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"
     gem.homepage = "http://github.com/kjvarga/arid_cache"
     gem.authors = ["Karl Varga"]
     gem.add_dependency "will_paginate"
-    gem.add_development_dependency "rspec", ">= 1.2.9"
     gem.add_development_dependency "will_paginate"
+    gem.add_development_dependency "faker"
+    gem.add_development_dependency "machinist"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new
@@ -24,21 +25,29 @@ rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
-end
+# require 'spec/rake/spectask'
+# Spec::Rake::SpecTask.new(:spec) do |spec|
+#   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
 
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
 end
 
-task :spec => :check_dependencies
-
-task :default => :spec
+task :test => :check_dependencies
+task :default => :test
 
 require 'rake/rdoctask'
 Rake::RDocTask.new do |rdoc|

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.1

data/arid_cache.gemspec

@@ -5,13 +5,13 @@
 
 Gem::Specification.new do |s|
   s.name = %q{arid_cache}
-  s.version = "0.1.1"
+  s.version = "0.2.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Karl Varga"]
-  s.date = %q{2009-12-25}
-  s.description = %q{ARID Cache makes caching easy and effective.  ARID cache supports caching on all your model named scopes, class methods and instance methods right out of the box.  ARID cache prevents caching logic from cluttering your models and clarifies your logic by making explicit calls to cached result sets.
-ARID Cache is designed for handling large, expensive ActiveRecord collections but is equally useful for caching anything else as well.
+  s.date = %q{2010-01-15}
+  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.
 }
   s.email = %q{kjvarga@gmail.com}
   s.extra_rdoc_files = [
@@ -40,8 +40,8 @@ ARID Cache is designed for handling large, expensive ActiveRecord collections bu
      "test/console",
      "test/db/prepare.rb",
      "test/db/schema.rb",
-     "test/fixtures/companies.yml",
-     "test/fixtures/users.yml",
+     "test/lib/active_support/cache/file_store_extras.rb",
+     "test/lib/blueprint.rb",
      "test/log/.gitignore",
      "test/models/company.rb",
      "test/models/user.rb",
@@ -58,6 +58,8 @@ ARID Cache is designed for handling large, expensive ActiveRecord collections bu
      "test/arid_cache_test.rb",
      "test/db/prepare.rb",
      "test/db/schema.rb",
+     "test/lib/active_support/cache/file_store_extras.rb",
+     "test/lib/blueprint.rb",
      "test/models/company.rb",
      "test/models/user.rb",
      "test/test_helper.rb"
@@ -69,17 +71,20 @@ ARID Cache is designed for handling large, expensive ActiveRecord collections bu
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<will_paginate>, [">= 0"])
-      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
       s.add_development_dependency(%q<will_paginate>, [">= 0"])
+      s.add_development_dependency(%q<faker>, [">= 0"])
+      s.add_development_dependency(%q<machinist>, [">= 0"])
     else
       s.add_dependency(%q<will_paginate>, [">= 0"])
-      s.add_dependency(%q<rspec>, [">= 1.2.9"])
       s.add_dependency(%q<will_paginate>, [">= 0"])
+      s.add_dependency(%q<faker>, [">= 0"])
+      s.add_dependency(%q<machinist>, [">= 0"])
     end
   else
     s.add_dependency(%q<will_paginate>, [">= 0"])
-    s.add_dependency(%q<rspec>, [">= 1.2.9"])
     s.add_dependency(%q<will_paginate>, [">= 0"])
+    s.add_dependency(%q<faker>, [">= 0"])
+    s.add_dependency(%q<machinist>, [">= 0"])
   end
 end
 

data/lib/arid_cache/active_record.rb

@@ -1,18 +1,21 @@
 module AridCache
   module ActiveRecord      
     def self.included(base)
+      base.extend         ClassMethods
       base.extend         MirrorMethods
       base.send :include, MirrorMethods
       base.class_eval do
         alias_method_chain :method_missing, :arid_cache 
+        alias_method_chain :respond_to?,    :arid_cache 
       end
       class << base
         alias_method_chain :method_missing, :arid_cache 
+        alias_method_chain :respond_to?,    :arid_cache 
       end
     end
     
     module MirrorMethods
-      def clear_all_caches
+      def clear_caches
         AridCache.cache.clear_class_caches(self)
         AridCache.cache.clear_instance_caches(self)
       end
@@ -24,44 +27,69 @@ module AridCache
       def clear_instance_caches
         AridCache.cache.clear_instance_caches(self)
       end
-                  
-      def get_singleton
-        class << self; self; end
-      end
       
-      # Return a cache key for the given key e.g.
+      # Return an AridCache key for the given key fragment for this object.
+      #
+      # Supported options:
+      #   :auto_expire => true/false   # (default false) whether or not to use the <tt>cache_key</tt> method on instance caches
+      #
+      # Examples:
       #   User.arid_cache_key('companies')       => 'user-companies'
-      #   User.first.arid_cache_key('companies') => 'users/20090120091123-companies'
-      def arid_cache_key(key)
-        key = (self.is_a?(Class) ? self.name.downcase : self.cache_key) + '-' + key.to_s
-        'arid-cache-' + key
+      #   User.first.arid_cache_key('companies') => 'users/1-companies'
+      #   User.first.arid_cache_key('companies', :auto_expire => true) => 'users/20090120091123-companies'
+      #
+      def arid_cache_key(key, options={})
+        object_key = if self.is_a?(Class)
+          self.name.downcase
+        elsif options[:auto_expire]
+          self.cache_key
+        else
+          "#{self.class.name.downcase.pluralize}/#{self.id}"
+        end
+        'arid-cache-' + object_key + '-' + key.to_s
       end
 
-      def respond_to?(method, include_private = false) #:nodoc:
-        if (method.to_s =~ /^class_cache_.*|cache_.*|cached_.*(_count)?$/).nil?
-          super(method, include_private)
+      def respond_to_with_arid_cache?(method, include_private = false) #:nodoc:
+        if (method.to_s =~ /^cached_.*(_count)?$/).nil?
+          respond_to_without_arid_cache?(method, include_private)
         elsif method.to_s =~ /^cached_(.*)_count$/
           AridCache.store.has?(self, "#{$1}_count") || AridCache.store.has?(self, $1) || super("#{$1}_count", include_private) || super($1, include_private)
         elsif method.to_s =~ /^cached_(.*)$/
           AridCache.store.has?(self, $1) || super($1, include_private)
         else
-          super(method, include_private)
+          respond_to_without_arid_cache?(method, include_private)
         end
       end
             
       protected
 
-      # Intercept methods beginning with <tt>cached_</tt>
       def method_missing_with_arid_cache(method, *args, &block) #:nodoc:
-        opts = args.empty? ? {} : args.first
-        if method.to_s =~ /^cache_(.*)$/
-          AridCache.define(self, $1, opts, &block)
-        elsif method.to_s =~ /^cached_(.*)$/
+        if method.to_s =~ /^cached_(.*)$/
+          opts = args.empty? ? {} : args.first
           AridCache.lookup(self, $1, opts, &block)
         else
           method_missing_without_arid_cache(method, *args)
         end
       end
     end
+    
+    module ClassMethods
+      
+      def instance_caches(opts={}, &block)
+        AridCache::Store::InstanceCacheConfiguration.new(self, opts).instance_eval(&block) && nil
+      end
+
+      def class_caches(opts={}, &block)
+        AridCache::Store::ClassCacheConfiguration.new(self, opts).instance_eval(&block) && nil     
+      end  
+
+      def is_mysql_adapter?
+        @is_mysql_adapter ||= ::ActiveRecord::Base.connection.adapter_name =~ /MySQL/
+      end  
+      
+      def is_mysql_adapter=(value)
+        @is_mysql_adapter = value
+      end 
+    end
   end
 end