cache_advance 1.1.4

data/.gitignore

@@ -0,0 +1,3 @@
+rdoc
+pkg
+*.gem

data/CHANGELOG

@@ -0,0 +1,8 @@
+1.1.2
+
+	* Strip whitespace from keys in order to avoid errors from memcache.
+	* Symbolize cache names.
+
+1.1.1
+
+  * Fixed a bug where the enabled flag would expire, causing caches to be reenabled.

data/README.textile

@@ -0,0 +1,47 @@
+h1. cache advance
+
+CacheAdvance is a wrapper around the Rails caching system that provides a simple, centralized
+configuration file for defining caches and an even simpler way to apply them.
+
+Written by "Aubrey Holland":mailto:aubreyholland@gmail.com.
+
+h3. download
+
+Github: "Page":http://github.com/aub/cache_advance/tree/master
+
+Gem: <pre>gem install aub-cache_advance --source http://gems.github.com</pre>
+
+Note: if you install using the gem from Github, you'll need this
+in your environment.rb if you want to use Rails 2.1's dependency manager:
+
+<pre><code>
+config.gem 'aub-cache_advance', :lib => 'cache_advance', :source => 'http://gems.github.com'
+</code></pre>
+
+h3. cache definition
+
+Caches are defined in the file config/caches.rb, which will be loaded automatically by the gem.
+This file is similar in format to the rails routes config file, allowing you to specify named
+caches and configure their keys and how they will be expired.
+
+<pre><code>
+CacheAdvance::Caches.define_caches do |config|
+
+  config.qualifier(:params) do |request|
+    request.params
+  end
+
+  config.plugin :template_handler_observer_cache_plugin
+
+  config.content_block :expiration_time => 10.minutes, :qualifiers => [ :subdomain, :params ]
+
+  config.change_towns_all :expiration_types => [ :publication ]
+  config.change_towns_limited :expiration_types => [ :publication ]
+
+  config.publication_twitter_update :expiration_time => 10.minutes, :qualifiers => [ :subdomain ]
+
+  config.weather_widget :expiration_time => 10.minutes, :qualifiers => [ :subdomain ]
+end
+</code></pre>
+
+..............More later.

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+
+FileList['tasks/**/*.rake'].each { |file| load file }
+
+task :default => 'test'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = 'cache_advance'
+    gemspec.summary = 'A declarative system for caching with ActiveRecord'
+    gemspec.email = 'aubreyholland@gmail.com'
+    gemspec.homepage = 'http://github.com/aub/cache_advance/tree/master'
+    gemspec.description = 'hmm'
+    gemspec.authors = ['Aubrey Holland']
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+

data/TODO.textile

@@ -0,0 +1,6 @@
+- Fix to allow keys of > 256 characters with memcache
+- Make test coverage not pitiful
+- Add ability for cache to expire when a specific object changes
+- Apply plugins only to specific caches
+- Test with caching strategies other than memcache
+- Improve documentation

data/VERSION

@@ -0,0 +1 @@
+1.1.4

data/cache_advance.gemspec

@@ -0,0 +1,68 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{cache_advance}
+  s.version = "1.1.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Aubrey Holland"]
+  s.date = %q{2009-10-21}
+  s.description = %q{hmm}
+  s.email = %q{aubreyholland@gmail.com}
+  s.extra_rdoc_files = [
+    "README.textile"
+  ]
+  s.files = [
+    ".gitignore",
+     "CHANGELOG",
+     "README.textile",
+     "Rakefile",
+     "TODO.textile",
+     "VERSION",
+     "cache_advance.gemspec",
+     "lib/cache_advance.rb",
+     "lib/cache_advance/active_record_sweeper.rb",
+     "lib/cache_advance/cache_set.rb",
+     "lib/cache_advance/cached_key_list.rb",
+     "lib/cache_advance/lock.rb",
+     "lib/cache_advance/mapper.rb",
+     "lib/cache_advance/named_cache.rb",
+     "lib/cache_advance/named_cache_configuration.rb",
+     "rails/init.rb",
+     "script/console",
+     "test/active_record_sweeper_test.rb",
+     "test/cache_mock.rb",
+     "test/cache_set_test.rb",
+     "test/key_test.rb",
+     "test/mapper_test.rb",
+     "test/named_cache_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/aub/cache_advance/tree/master}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A declarative system for caching with ActiveRecord}
+  s.test_files = [
+    "test/active_record_sweeper_test.rb",
+     "test/cache_mock.rb",
+     "test/cache_set_test.rb",
+     "test/key_test.rb",
+     "test/mapper_test.rb",
+     "test/named_cache_test.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
+    else
+    end
+  else
+  end
+end

data/lib/cache_advance/active_record_sweeper.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+gem 'activerecord'
+require 'active_record/observer'
+
+module CacheAdvance
+  class ActiveRecordSweeper < ::ActiveRecord::Observer
+
+    def self.initialize_observed(classes)
+      observe(classes)
+    end
+
+    def reload_sweeper
+      observed_classes.each do |klass| 
+        klass.name.constantize.add_observer(self)
+      end
+    end
+
+    def after_create(object)
+      expire_caches_for(object)
+    end
+
+    alias_method :after_update, :after_create
+    alias_method :after_destroy, :after_create
+
+    protected
+    
+    def expire_caches_for(object)
+      class_symbol = object.class.name.underscore.to_sym
+      CacheAdvance.cache_set.expire_for_class(class_symbol)
+    end
+  end
+end

data/lib/cache_advance/cache_set.rb

@@ -0,0 +1,57 @@
+module CacheAdvance    
+  class CacheSet
+    attr_reader :named_caches
+    attr_reader :qualifiers
+    attr_reader :plugins
+    
+    def initialize(store)
+      @store, @named_caches, @qualifiers, @plugins = store, {}, {}, []
+    end
+    
+    def setup_complete
+      
+    end
+    
+    def apply(cache_name, request, options, &block)
+      cache_name = cache_name.to_sym
+      if CacheAdvance.caching_enabled
+        named_cache = @named_caches[cache_name]
+        raise UnknownNamedCacheException if named_cache.nil?
+        named_cache.value_for(request, options, &block)
+      else
+        block.call
+      end
+    end
+    
+    def add_qualifier(name, proc)
+      @qualifiers[name] = proc
+    end
+    
+    def add_plugin(plugin)
+      @plugins << plugin
+    end
+    
+    def add_named_cache(name, options)
+      name = name.to_sym
+      @named_caches[name] = NamedCache.new(name, options, self, @store)
+    end
+    
+    def define_caches
+      yield Mapper.new(self)
+    end
+    
+    def create_sweepers
+      @sweeper_type.initialize_observed(@named_caches.values.map { |c| c.expiration_types }.flatten.compact.uniq)
+    end
+    
+    def expire_for_class(class_name)
+      @named_caches.values.each do |named_cache|
+        named_cache.expire_for(class_name)
+      end
+    end
+    
+    def sweeper_type=(type)
+      @sweeper_type = type
+    end
+  end
+end

data/lib/cache_advance/cached_key_list.rb

@@ -0,0 +1,46 @@
+module CacheAdvance
+  class CachedKeyList
+    def initialize(store, cache_key, expiration_time=nil)
+      @store, @cache_key, @expiration_time = store, cache_key, expiration_time
+    end
+    
+    def all_keys
+      key_list.keys
+    end
+    
+    def add_key(key)
+      Lock.new(@store).execute_locked(@cache_key) do
+        data = key_list
+        unless data.has_key?(key)
+          data[key] = @expiration_time.nil? ? nil : Time.now + @expiration_time
+          @store.set(@cache_key, data)
+        end
+      end
+    end
+    
+    def delete_key(key)
+      Lock.new(@store).execute_locked(@cache_key) do
+        data = key_list
+        if data.has_key?(key)
+          data.delete(key)
+          @store.set(@cache_key, data)
+        end
+      end
+    end
+    
+    def clear
+      @store.set(@cache_key, {})
+    end
+    
+    protected
+    
+    def key_list
+      list = @store.get(@cache_key) || {}
+      if @expiration_time
+        now = Time.now
+        list.delete_if { |k,v| v <= now }
+      end
+      list
+    end
+  end
+end

data/lib/cache_advance/lock.rb

@@ -0,0 +1,40 @@
+module CacheAdvance
+  class Lock
+
+    class LockAcquisitionFailureException < Exception; end
+    
+    DEFAULT_RETRIES = 5
+    DEFAULT_EXPIRATION_TIME = 30
+
+    def initialize(store)
+      @store = store
+    end
+    
+    def execute_locked(key, lock_expiry = DEFAULT_EXPIRATION_TIME, retries = DEFAULT_RETRIES)
+      begin
+        acquire(key, lock_expiry, retries)
+        yield
+      ensure
+        release_lock(key)
+      end
+    end
+    
+    def acquire(key, lock_expiry = DEFAULT_EXPIRATION_TIME, retries = DEFAULT_RETRIES)
+      retries.times do |count|
+        begin
+          return if @store.set("lock/#{key}", Process.pid, lock_expiry) == "STORED\r\n"
+        end
+        exponential_sleep(count) unless count == retries - 1
+      end
+      raise LockAcquisitionFailureException, "Couldn't acquire memcache lock for: #{key}"
+    end
+
+    def release_lock(key)
+      @store.delete("lock/#{key}")
+    end
+
+    def exponential_sleep(count)
+      sleep((2**count) / 10.0)
+    end
+  end
+end

data/lib/cache_advance/mapper.rb

@@ -0,0 +1,29 @@
+gem 'activesupport'
+require 'active_support/core_ext'
+
+module CacheAdvance
+  class Mapper
+    def initialize(cache_set)
+      @cache_set = cache_set
+    end
+    
+    def qualifier(name, &proc)
+      @cache_set.add_qualifier(name, proc)
+    end
+    
+    def plugin(name)
+      if name.is_a?(Symbol)
+        plugin = name.to_s.camelcase.constantize.new
+      elsif name.is_a?(Class)
+        plugin = name.new
+      else
+        plugin = name
+      end
+      @cache_set.add_plugin(plugin)
+    end
+    
+    def method_missing(method, options={})
+      @cache_set.add_named_cache(method, options)
+    end
+  end
+end

data/lib/cache_advance/named_cache.rb

@@ -0,0 +1,124 @@
+module CacheAdvance
+  class NamedCache
+
+    ENABLED_CHECK_INTERVAL = 60
+    
+    def initialize(name, params, cache_set, store)
+      @name = name.to_s
+      @params = params
+      @cache_set = cache_set
+      @store = store
+      @cached_key_list = CachedKeyList.new(@store, "#{@name}/STORED_CACHES", expiration_time)
+      @enabled_check_time = Time.now + ENABLED_CHECK_INTERVAL
+      @enabled = nil
+    end
+        
+    def value_for(request, options, &block)
+      return block.call unless enabled?
+      
+      key = key_for(request, options[:key])
+      
+      if (value = read_from_store(key))
+        each_plugin { |p| p.send('after_read', @name, key, value, options) if p.respond_to?('after_read') }
+        return value
+      end
+      
+      each_plugin { |p| p.send('before_render', @name, key, options) if p.respond_to?('before_render') }
+      result = block.call
+      each_plugin { |p| p.send('after_render', @name, key, result, options) if p.respond_to?('after_render') }
+      each_plugin { |p| p.send('before_write', @name, key, result, options) if p.respond_to?('before_write') }
+      write_to_store(key, result)
+      each_plugin { |p| p.send('after_write', @name, key, result, options) if p.respond_to?('after_write') }      
+      result
+    end
+        
+    def expire_for(type)
+      if expiration_types.include?(type)
+        expire_all
+      end
+    end
+    
+    def expire_all
+      delete_all_from_store
+    end
+        
+    def all_cached_keys
+      @cached_key_list.all_keys
+    end
+    
+    def expiration_types
+      Array(@params[:expiration_types])
+    end
+    
+    def title
+      @params[:title] || @name.to_s
+    end
+    
+    def enabled=(state)
+      @enabled = !!state
+      @store.set(enabled_key, @enabled)
+    end
+    
+    def enabled?
+      if @enabled.nil? || Time.now >= @enabled_check_time
+        @enabled = [nil, true].include?(read_from_store(enabled_key, false))
+        @enabled_check_time = Time.now + ENABLED_CHECK_INTERVAL
+      end
+      @enabled
+    end
+    
+    protected
+        
+    def read_from_store(key, add_to_key_list=true)
+      data = @store.get(key)
+      # this is to prevent a situation where the cached key list forgets
+      # about keys that are actually cached.
+      if data && add_to_key_list
+        @cached_key_list.add_key(key)
+      end
+      data
+    end
+    
+    def write_to_store(key, value)
+      expiration_time ? @store.set(key, value, expiration_time) : @store.set(key, value)
+      @cached_key_list.add_key(key)
+    end
+
+    def delete_from_store(key)
+      @store.delete(key)
+      @cached_key_list.delete_key(key)
+    end
+        
+    def delete_all_from_store
+      @cached_key_list.all_keys.each { |key| delete_from_store(key) }
+      @cached_key_list.clear
+    end
+        
+    def each_plugin
+      @cache_set.plugins.each do |p|
+        yield p
+      end
+    end
+    
+    def key_for(request, suffix='')
+      qualifier_data = qualifiers.map do |q|
+        if (qualifier = @cache_set.qualifiers[q])
+          (qualifier.call(request) || '').to_s
+        end
+      end.join('/')
+      "#{@name}/#{suffix}/[#{qualifier_data}]".gsub(/\s/, '')
+    end
+        
+    def enabled_key
+      "#{@name}/ENABLED_STATUS"
+    end  
+      
+    def expiration_time
+      @params[:expiration_time]
+    end
+    
+    def qualifiers
+      Array(@params[:qualifiers])
+    end
+  end
+end

data/lib/cache_advance/named_cache_configuration.rb

@@ -0,0 +1,7 @@
+module CacheAdvance
+  class NamedCacheConfiguration
+    def initialize(options)
+      @options = options
+    end
+  end
+end

data/lib/cache_advance.rb

@@ -0,0 +1,21 @@
+%w( cache_set cached_key_list lock mapper named_cache named_cache_configuration).each do |file|
+  require File.join(File.dirname(__FILE__), 'cache_advance', file)
+end
+
+module CacheAdvance
+  class UnknownNamedCacheException < Exception; end
+
+  class << self
+    attr_reader :cache_set
+    attr_accessor :caching_enabled
+  end
+
+  @cache_set = nil
+  @caching_enabled = true
+
+  def self.define_caches(store)
+    @cache_set = CacheSet.new(store)
+    yield Mapper.new(@cache_set)
+    @cache_set.setup_complete # This allows the cache set to finalize some of its configuration
+  end
+end

data/rails/init.rb

@@ -0,0 +1,52 @@
+require 'cache_advance'
+require 'cache_advance/active_record_sweeper'
+
+require "#{RAILS_ROOT}/config/caches"
+require 'dispatcher'
+
+# Setup the sweeper and cache types as appropriate for Rails.
+CacheAdvance.cache_set.sweeper_type = CacheAdvance::ActiveRecordSweeper
+
+CacheAdvance.caching_enabled = config.action_controller.perform_caching
+
+# This is the helper method that can be used in rails views/controllers/helpers.
+# If caching is disabled, just make it yield the results of the block.
+if config.action_controller.perform_caching
+  ActionController::Base.helper do
+    def cache_it(cache, options={}, &block)
+      CacheAdvance.cache_set.plugins.each do |plugin|
+        options.merge!(plugin.cache_it_options(self)) if plugin.respond_to?('cache_it_options')
+      end
+      CacheAdvance.cache_set.apply(cache, request, options) do
+        capture(&block)
+      end
+    end
+  end
+else
+  ActionController::Base.helper do
+    def cache_it(cache, options={}, &block)
+      capture(&block)
+    end
+  end
+end
+ 
+ActionMailer::Base.helper do
+  def cache_it(cache, options={}, &block)
+    capture(&block)
+  end
+end
+
+# This will get called after the standard rails environment is initialized.
+config.after_initialize do
+  if config.action_controller.perform_caching
+    # This hooks the sweepers into the observer system and adds it to the list.
+    CacheAdvance.cache_set.create_sweepers
+    ActiveRecord::Base.observers << CacheAdvance::ActiveRecordSweeper
+
+    # In development mode, the models we observe get reloaded with each request. Using
+    # this hook allows us to reload the observer relationships each time as well.
+    ActionController::Dispatcher.to_prepare(:cache_advance_reload) do
+      CacheAdvance::ActiveRecordSweeper.instance.reload_sweeper
+    end
+  end
+end

data/script/console

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '..', 'test', 'test_helper')
+
+IRB.start

data/test/active_record_sweeper_test.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+require 'cache_advance/active_record_sweeper'
+
+class Article; end
+class Publication; end
+
+class ActiveRecordSweeperTest < Test::Unit::TestCase
+  
+  def setup
+    @sweeper = CacheAdvance::ActiveRecordSweeper.instance
+  end
+  
+  def test_should_call_observe_with_a_given_set_of_classes
+    CacheAdvance::ActiveRecordSweeper.expects(:observe).with([:publication, :article])
+    CacheAdvance::ActiveRecordSweeper.initialize_observed([:publication, :article])
+  end
+  
+  def test_should_re_add_observers
+    CacheAdvance::ActiveRecordSweeper.initialize_observed([:publication, :article])
+    Article.expects(:add_observer).with(@sweeper)
+    Publication.expects(:add_observer).with(@sweeper)
+    @sweeper.reload_sweeper
+  end
+  
+  def test_should_expire_caches_on_changes
+    CacheAdvance.cache_set.expects(:expire_for_class).with(:publication).times(3)
+    %w(after_create after_update after_destroy).each do |method|
+      @sweeper.send(method, Publication.new)
+    end
+  end
+end

data/test/cache_mock.rb

@@ -0,0 +1,21 @@
+module CacheAdvance
+  class CacheMock
+    def initialize
+      @values = {}
+    end
+
+    def get(key)
+      @values[key]
+    end
+    
+    def set(key, value, options={})
+      result = @values.has_key?(key) ? @values[key] : "STORED\r\n"
+      @values[key] = value
+      result
+    end
+    
+    def delete(key)
+      @values[key] = nil
+    end
+  end
+end

data/test/cache_set_test.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class Plugin; end
+
+require 'cache_advance/active_record_sweeper'
+
+class CacheSetTest < Test::Unit::TestCase
+  def setup
+    @cache = CacheAdvance::CacheMock.new
+    @cache_set = CacheAdvance::CacheSet.new(@cache)
+  end
+  
+  def test_define_caches_should_yield_a_mapper
+    @cache_set.define_caches do |mapper|
+      assert_equal CacheAdvance::Mapper, mapper.class
+    end
+  end
+  
+  def test_should_apply_the_cache_if_found
+    request = mock
+    options = { :key => 'hippo' }
+    @cache_set.add_named_cache(:kewl, {})
+    @cache_set.named_caches[:kewl].expects(:value_for).with(request, options)
+    @cache_set.apply(:kewl, request, options) { }
+  end
+  
+  def test_apply_should_throw_exception_with_invalid_name
+    assert_raise CacheAdvance::UnknownNamedCacheException do
+      @cache_set.apply(:total_hack, mock(), {}) { }
+    end
+  end
+  
+  def test_should_pass_expiration_types_to_the_sweeper
+    @cache_set.sweeper_type = CacheAdvance::ActiveRecordSweeper
+    @cache_set.add_named_cache(:kewl, { :expiration_types => [:publication, :article] })
+    @cache_set.add_named_cache(:howza, { :expiration_types => [:publication] })
+    CacheAdvance::ActiveRecordSweeper.expects(:initialize_observed).with([:publication, :article])
+    @cache_set.create_sweepers
+  end
+end

data/test/key_test.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class KeyTest < Test::Unit::TestCase
+
+  def setup
+    @cache = CacheAdvance::CacheMock.new
+    @cache_set = CacheAdvance::CacheSet.new(@cache)
+  end
+
+  def test_should_symbolize_the_cache_name
+    @cache_set.add_named_cache('booya', {})
+    assert_nothing_raised do
+      @cache_set.apply(:booya, nil, :key => 'abc') do
+        '123'
+      end
+    end
+  end
+
+  def test_should_symbolize_the_cache_name_when_using_it 
+    @cache_set.add_named_cache(:booya, {})
+    assert_nothing_raised do
+      @cache_set.apply('booya', nil, :key => 'abc') do
+        '123'
+      end
+    end
+  end
+
+  def test_should_remove_whitespace_from_the_key
+    @cache_set.add_named_cache(:booya, {})
+    result = @cache_set.apply(:booya, nil, :key => 'abc def') do
+      '123'
+    end
+    assert_equal '123', @cache.get('booya/abcdef/[]')
+    assert_equal '123', result
+    @cache.set('booya/abcdef/[]', '234')
+    result = @cache_set.apply(:booya, nil, :key => 'abc def') do
+      '123'
+    end
+    assert_equal '234', result
+  end
+end

data/test/mapper_test.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class Hack
+end
+
+class MapperTest < Test::Unit::TestCase
+  
+  def setup
+    @cache = CacheAdvance::CacheMock.new
+    @cache_set = CacheAdvance::CacheSet.new(@cache)
+    @mapper = CacheAdvance::Mapper.new(@cache_set)
+  end
+  
+  def test_qualifier
+    @mapper.qualifier(:thirty_four) do
+      34
+    end
+    assert_equal 1, @cache_set.qualifiers.size
+    assert_equal 34, @cache_set.qualifiers[:thirty_four].call
+  end
+  
+  def test_plugin_from_symbol
+    @mapper.plugin(:hack)
+    assert_equal 1, @cache_set.plugins.size
+    assert_equal Hack, @cache_set.plugins.first.class
+  end
+  
+  def test_plugin_from_class
+    @mapper.plugin(Hack)
+    assert_equal 1, @cache_set.plugins.size
+    assert_equal Hack, @cache_set.plugins.first.class
+  end
+  
+  def test_plugin_from_object
+    hack = Hack.new
+    @mapper.plugin(hack)
+    assert_equal 1, @cache_set.plugins.size
+    assert_equal hack, @cache_set.plugins.first
+  end
+  
+  def test_adding_caches_through_method_missing
+    @mapper.say_what :option => 2
+    assert_equal 1, @cache_set.named_caches.size
+    assert_equal CacheAdvance::NamedCache, @cache_set.named_caches[:say_what].class
+  end
+end

data/test/named_cache_test.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class NamedCacheTest < Test::Unit::TestCase
+  
+  def setup
+    @request = mock
+  end
+  
+  def test_key_for_in_basic_case
+    create_named_cache
+    assert_equal 'test_cache//[]', @named_cache.send(:key_for, @request)
+    assert_equal 'test_cache/suf/[]', @named_cache.send(:key_for, @request, 'suf')
+  end
+  
+  def test_key_with_qualifiers
+    
+  end
+  
+  protected
+  
+  def create_named_cache(options={})
+    @name = options[:name] || 'test_cache'
+    @params = {}
+    @cache = CacheAdvance::CacheMock.new
+    @cache_set = CacheAdvance::CacheSet.new(@cache)
+    @named_cache = CacheAdvance::NamedCache.new(@name, @params, @cache_set, @cache)
+  end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+$: << File.join(File.dirname(__FILE__))
+
+require 'test/unit'
+require 'rubygems'
+require 'ruby-debug'
+
+require 'cache_advance'
+require 'mocha'
+require 'cache_mock'

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: cache_advance
+version: !ruby/object:Gem::Version 
+  version: 1.1.4
+platform: ruby
+authors: 
+- Aubrey Holland
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-21 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: hmm
+email: aubreyholland@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- .gitignore
+- CHANGELOG
+- README.textile
+- Rakefile
+- TODO.textile
+- VERSION
+- cache_advance.gemspec
+- lib/cache_advance.rb
+- lib/cache_advance/active_record_sweeper.rb
+- lib/cache_advance/cache_set.rb
+- lib/cache_advance/cached_key_list.rb
+- lib/cache_advance/lock.rb
+- lib/cache_advance/mapper.rb
+- lib/cache_advance/named_cache.rb
+- lib/cache_advance/named_cache_configuration.rb
+- rails/init.rb
+- script/console
+- test/active_record_sweeper_test.rb
+- test/cache_mock.rb
+- test/cache_set_test.rb
+- test/key_test.rb
+- test/mapper_test.rb
+- test/named_cache_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/aub/cache_advance/tree/master
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A declarative system for caching with ActiveRecord
+test_files: 
+- test/active_record_sweeper_test.rb
+- test/cache_mock.rb
+- test/cache_set_test.rb
+- test/key_test.rb
+- test/mapper_test.rb
+- test/named_cache_test.rb
+- test/test_helper.rb