arid_cache 0.0.5

data/.gitignore

@@ -0,0 +1,22 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+test/**/*.log

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Karl Varga
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,121 @@
+== ARID Cache
+
+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.
+
+=== Counts for free
+
+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>.
+
+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>.
+  
+=== Auto-expiring cache keys
+  
+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.
+
+Caches on your model classes (like on the results of named scopes) will not expire however.
+
+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
+  
+These methods are also available on model instances.
+
+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
+
+=== Support for pagination and options to <tt>find</tt>
+
+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.
+
+You can pass options like <tt>:include</tt> (or any other valid <tt>find</tt> options) to augment the results of your cached query.
+
+=== Efficiency
+
+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.
+
+== Examples
+
+==== Given the following model:
+
+  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_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.
+
+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.
+
+==== Some examples of pagination:
+
+  User.cached_active.paginate(:page => 1, :per_page => 30)
+  User.cached_active.paginate(:page => 1)
+  User.cached_active.paginate(:page => 3)
+
+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_active.paginate(:page => 1, :include => :preferences)
+  User.cached_active.paginate(:page => 1, :order => 'created_at DESC') # don't change the order, just enforce it
+
+You can limit the results returned using <tt>:limit</tt> and <tt>:offset</tt>:
+
+  user.cached_pets(:limit => 2, :include => :toys)
+  user.cached_pets(:limit => 2, :offset => 3, :include => :toys)
+  
+==== You can dynamically create caches
+
+  User.cached_most_active_users do
+    self.active.find(:order => 'activity DESC', :limit => 10)
+  end
+
+Dynamic caches that make use of other cached collections:
+
+  @tracks  = @genre.cached_highlight_tracks(:order => 'release_date DESC', :include => [:album, :artist]) do
+    cached_tracks(:order => 'release_date DESC', :limit => 10, :include => [:album, :artist])
+  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)
+  end
+    
+More docs to come...
+  
+== Note on Patches/Pull Requests
+
+* 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.
+
+== Copyright
+
+Copyright (c) 2009 Karl Varga. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    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.
+      
+      ARID Cache 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 is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+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
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "arid_cache #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.5

data/arid_cache.gemspec

@@ -0,0 +1,85 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{arid_cache}
+  s.version = "0.0.5"
+
+  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.email = %q{kjvarga@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "arid_cache.gemspec",
+     "init.rb",
+     "lib/arid_cache.rb",
+     "lib/arid_cache/active_record.rb",
+     "lib/arid_cache/cache_proxy.rb",
+     "lib/arid_cache/helpers.rb",
+     "lib/arid_cache/store.rb",
+     "rails/init.rb",
+     "spec/arid_cache_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "tasks/arid_cache_tasks.rake",
+     "test/arid_cache_test.rb",
+     "test/console",
+     "test/db/prepare.rb",
+     "test/db/schema.rb",
+     "test/fixtures/companies.yml",
+     "test/fixtures/users.yml",
+     "test/log/.gitignore",
+     "test/models/company.rb",
+     "test/models/user.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/kjvarga/arid_cache}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Automates efficient caching of your ActiveRecord collections, gives you counts for free and supports pagination.}
+  s.test_files = [
+    "spec/arid_cache_spec.rb",
+     "spec/spec_helper.rb",
+     "test/arid_cache_test.rb",
+     "test/db/prepare.rb",
+     "test/db/schema.rb",
+     "test/models/company.rb",
+     "test/models/user.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    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"])
+    else
+      s.add_dependency(%q<will_paginate>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_dependency(%q<will_paginate>, [">= 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"])
+  end
+end
+

data/init.rb

@@ -0,0 +1,6 @@
+begin
+  require File.join(File.dirname(__FILE__), 'lib', 'arid_cache') # From here
+rescue LoadError
+  require 'arid_cache' # From gem
+end
+AridCache.init_rails

data/lib/arid_cache/active_record.rb

@@ -0,0 +1,67 @@
+module AridCache
+  module ActiveRecord      
+    def self.included(base)
+      base.extend         MirrorMethods
+      base.send :include, MirrorMethods
+      base.class_eval do
+        alias_method_chain :method_missing, :arid_cache 
+      end
+      class << base
+        alias_method_chain :method_missing, :arid_cache 
+      end
+    end
+    
+    module MirrorMethods
+      def clear_all_caches
+        AridCache.cache.clear_class_caches(self)
+        AridCache.cache.clear_instance_caches(self)
+      end
+
+      def clear_class_caches
+        AridCache.cache.clear_class_caches(self)
+      end
+
+      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.
+      #   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
+      end
+
+      def respond_to?(method, include_private = false) #:nodoc:
+        if (method.to_s =~ /^class_cache_.*|cache_.*|cached_.*(_count)?$/).nil?
+          super(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)
+        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_(.*)$/
+          AridCache.lookup(self, $1, opts, &block)
+        else
+          method_missing_without_arid_cache(method, *args)
+        end
+      end
+    end
+  end
+end

data/lib/arid_cache/cache_proxy.rb

@@ -0,0 +1,209 @@
+module AridCache
+  class CacheProxy
+    attr_accessor :object, :key, :opts, :blueprint, :cached, :cache_key, :block, :records
+    
+    # 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
+      end
+      
+      def klass
+        self['klass'].constantize unless self['klass'].nil?
+      end
+    end
+
+    def self.clear_all_caches
+      Rails.cache.delete_matched(%r[arid-cache-.*])
+    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 
+        
+    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}.*])
+    end    
+    
+    def self.has?(object, key)
+      Rails.cache.exist?(object.arid_cache_key(key))
+    end
+
+    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
+
+    def initialize(object, key, opts, &block)
+      self.object = object
+      self.key = key
+      self.opts = opts || {}
+      self.blueprint = AridCache.store.find(object, key)
+      self.cache_key = object.arid_cache_key(key)
+      self.cached = Rails.cache.read(cache_key)
+      self.block = block
+      self.records = nil
+    end
+            
+    def fetch_count
+      if cached.nil? || opts[:force]
+        execute_count
+      elsif cached.is_a?(AridCache::CacheProxy::Result)
+        cached.has_count? ? cached.count : execute_count
+      elsif cached.is_a?(Fixnum)
+        cached
+      elsif cached.respond_to?(:count)
+        cached.count
+      else
+        cached # what else can we do? return it
+      end
+    end
+          
+    def fetch
+      if cached.nil? || opts[:force]
+        execute_find
+      elsif cached.is_a?(AridCache::CacheProxy::Result)
+        if cached.has_ids? # paginate and fetch here
+          klass = find_class_of_results
+          if opts.include?(:page)
+            klass.paginate(cached.ids, opts_for_paginate)
+          else
+            klass.find(cached.ids, opts_for_find)
+          end
+        else
+          execute_find
+        end
+      else
+        cached # some base type, return it
+      end
+    end
+      
+    private
+
+      def get_records
+        block = block || blueprint.proc
+        self.records = block.nil? ? object.instance_eval(key) : object.instance_eval(&block)
+      end
+      
+      def execute_find
+        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
+          cached.ids = records.collect(&:id)
+          cached.count = records.size
+          if records.respond_to?(:proxy_reflection) # association proxy
+            cached.klass = records.proxy_reflection.klass
+          elsif !records.empty?
+            cached.klass = records.first.class
+          else
+            cached.klass = object_base_class
+          end
+        end
+        Rails.cache.write(cache_key, cached)
+        
+        self.cached = cached
+        return_records(records)
+      end
+
+      # Convert records to an array before calling paginate.  If we don't do this
+      # and the result is a named scope, paginate will trigger an additional query
+      # to load the page rather than just using the records we have already fetched.
+      #
+      # If we are not paginating and the options include :limit (and optionally :offset)
+      # apply the limit and offset to the records before returning them.
+      #
+      # Otherwise we have an issue where all the records are returned the first time
+      # the collection is loaded, but on subsequent calls the options_for_find are
+      # included and you get different results.  Note that with options like :order
+      # this cannot be helped.  We don't want to modify the query that generates the
+      # collection because the idea is to allow getting different perspectives of the
+      # cached collection without relying on modifying the collection as a whole.
+      #
+      # 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') }      
+      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 
+          records[offset, opts[:limit]]
+        else
+          records
+        end      
+      end
+      
+      def execute_count
+        get_records
+        cached = AridCache::CacheProxy::Result.new
+
+        # Just get the count if we can.
+        #
+        # Because of how AssociationProxy works, if we even look at it, it'll
+        # trigger the query.  So don't look.
+        #
+        # Association proxy or named scope.  Check for an association first, because
+        # it doesn't trigger the select if it's actually named scope.  Calling respond_to?
+        # on an association proxy will hower trigger a select because it loads up the target
+        # and passes the respond_to? on to it.
+        if records.respond_to?(:proxy_reflection) || records.respond_to?(:proxy_options)
+          cached.count = records.count # just get the count
+          cached.klass = object_base_class
+        elsif records.is_a?(Enumerable) && (records.empty? || records.first.is_a?(::ActiveRecord::Base))
+          cached.ids = records.collect(&:id) # get everything now that we have it
+          cached.count = records.size
+          cached.klass = records.empty? ? object_base_class : records.first.class
+        else
+          cached = records # some base type, cache it as itself
+        end
+        
+        Rails.cache.write(cache_key, cached)
+        self.cached = cached
+        cached.respond_to?(:count) ? cached.count : cached
+      end
+                  
+      def opts_for_paginate
+        paginate_opts = blueprint.nil? ? opts.symbolize_keys : blueprint.opts.merge(opts.symbolize_keys)
+        paginate_opts[:total_entries] = cached.count
+        paginate_opts
+      end
+    
+      VALID_FIND_OPTIONS = [ :conditions, :include, :joins, :limit, :offset, :order, :select, :readonly, :group, :having, :from, :lock ]
+      
+      def opts_for_find
+        find_opts = blueprint.nil? ? opts.symbolize_keys : blueprint.opts.merge(opts.symbolize_keys) 
+        find_opts.delete_if { |k,v| !VALID_FIND_OPTIONS.include?(k) }
+      end
+      
+      def object_base_class
+        object.is_a?(Class) ? object : object.class
+      end
+      
+      def find_class_of_results
+        opts[:class] || (blueprint && blueprint.opts[:class]) || cached.klass || object_base_class
+      end
+  end
+end

data/lib/arid_cache/helpers.rb

@@ -0,0 +1,86 @@
+module AridCache
+  module Helpers
+
+    # Lookup something from the cache.
+    #
+    # If no block is provided, create one dynamically.  If a block is
+    # provided, it is only used the first time it is encountered.
+    # This allows you to dynamically define your caches while still
+    # returning the results of your query.
+    #
+    # @return a WillPaginate::Collection if the options include :page,
+    #  a Fixnum count if the request is for a count or the results of
+    #  the ActiveRecord query otherwise.
+    def lookup(object, key, opts, &block)
+      if !block.nil?
+        define(object, key, opts, &block)
+      elsif key =~ /(.*)_count$/
+        if AridCache.store.has?(object, $1)
+          method_for_cached(object, $1, :fetch_count, key)
+        elsif object.respond_to?(key)
+          define(object, key, opts, :fetch_count)
+        elsif object.respond_to?($1)
+          define(object, $1, opts, :fetch_count, key)
+        else
+          raise ArgumentError.new("#{object} doesn't respond to #{key} or #{$1}!  Cannot dynamically create query to get the count, please call with a block.")
+        end 
+      elsif object.respond_to?(key)
+        define(object, key, opts, &block)
+      else
+        raise ArgumentError.new("#{object} doesn't respond to #{key}!  Cannot dynamically create query, please call with a block.")
+      end
+      object.send("cached_#{key}", opts)
+    end
+
+    # Store the options and optional block for a call to the cache.
+    #
+    # If no block is provided, create one dynamically.
+    #
+    # @return an AridCache::Store::Blueprint.
+    def define(object, key, opts, fetch_method=:fetch, method_name=nil, &block)
+      if block.nil? && !object.respond_to?(key)
+        raise ArgumentError.new("#{object} doesn't respond to #{key}!  Cannot dynamically create a block for your cache item.")
+      end
+      
+      # FIXME: Pass default options to store.add
+      # Pass nil in for now until we get the cache_ calls working.
+      # This means that the first time you define a dynamic cache
+      # (by passing in a block), the options you used are not
+      # stored in the blueprint and applied to each subsequent call.
+      #
+      # Otherwise we have a situation where a :limit passed in to the
+      # first call persists when no options are passed in on subsequent calls,
+      # but if a different :limit is passed in that limit is applied.
+      #
+      # I think in this scenario one would expect no limit to be applied
+      # if no options are passed in.
+      #
+      # When the cache_ methods are supported, those options should be
+      # remembered and applied to the collection however.
+      blueprint = AridCache.store.add(object, key, block, nil)
+      method_for_cached(object, key, fetch_method, method_name)
+      blueprint
+    end
+
+    private
+
+    def method_for_cached(object, key, fetch_method=:fetch, method_name=nil)
+      method_name = "cached_" + (method_name || key)
+      if object.is_a?(Class)
+        (class << object; self; end).instance_eval do
+          define_method(method_name) do |*args, &block|
+            opts = args.empty? ? {} : args.first
+            AridCache.cache.send(fetch_method, self, key, opts, &block)
+          end
+        end
+      else
+        object.class_eval do
+          define_method(method_name) do |*args, &block|
+            opts = args.empty? ? {} : args.first
+            AridCache.cache.send(fetch_method, self, key, opts, &block)
+          end
+        end
+      end
+    end
+  end  
+end