aub-cache_advance 0.2.0

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,62 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'date'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the system.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the system.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Cache Advance'
+  rdoc.options << '--line-numbers' << '--inline-source' << "--main" << "README.textile"
+  rdoc.rdoc_files.include('README.textile')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+spec = Gem::Specification.new do |s|
+  s.name        = %q{cache_advance}
+  s.version     = "1.0.0"
+  s.summary     = %q{A system for spiffy declarative caching}
+  s.description = %q{A system for spiffy declarative caching}
+  s.homepage    = 'http://github.com/aub/cache_advance'
+
+  s.files        = FileList['[A-Z]*', 'lib/**/*.rb', 'rails/**/*.rb', 'test/**/*.rb']
+  s.require_path = 'lib'
+  s.test_files   = Dir[*['test/**/*_test.rb']]
+
+  s.has_rdoc         = true
+  s.extra_rdoc_files = ["README.textile"]
+  s.rdoc_options = ['--line-numbers', '--inline-source', "--main", "README.textile"]
+
+  s.authors = ["Aubrey Holland"]
+  s.email   = %q{aubrey@patch.com}
+
+  s.platform = Gem::Platform::RUBY
+  s.add_dependency(%q<activesupport>, [">= 1.0"])
+end
+
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+  pkg.need_zip = true
+end
+
+desc "Clean files generated by rake tasks"
+task :clobber => [:clobber_rdoc, :clobber_package]
+
+desc "Generate a gemspec file"
+task :gemspec do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+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/cache_advance.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |s|
+  s.version = '0.2.0'
+  s.date = %q{2009-01-08}
+ 
+  s.name = %q{cache_advance}
+  s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
+  s.authors = ['Aubrey Holland']
+  s.description = %q{A system for spiffy declarative caching}
+  s.email = %q{aubrey@patch.com}
+  s.files = %w(README.textile Rakefile TODO.textile cache_advance-1.0.9.gem 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 test/active_record_sweeper_test.rb test/cache_mock.rb test/cache_set_test.rb test/mapper_test.rb test/named_cache_test.rb test/spec/db/schema.rb test/spec/mapper_spec.rb test/spec/mocks/memcache.rb test/spec/spec_helper.rb test/test_helper.rb)
+  s.homepage = %q{http://github.com/aub/cache_advance}
+  s.require_paths = ['lib']
+  s.rubygems_version = %q{1.2.0}
+  s.summary = %q{A system for spiffy declarative caching}
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README.textile']
+  s.rdoc_options = ['--line-numbers', '--inline-source', '--main', 'README.textile']
+  s.test_files = %w(test/active_record_sweeper_test.rb test/cache_set_test.rb test/mapper_test.rb test/named_cache_test.rb)
+  
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+  end
+end

data/lib/cache_advance/active_record_sweeper.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+gem 'activerecord'
+require 'active_record'
+
+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,51 @@
+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)
+      named_cache = @named_caches[cache_name]
+      raise UnknownNamedCacheException if named_cache.nil?
+      named_cache.value_for(request, options, &block)
+    end
+    
+    def add_qualifier(name, proc)
+      @qualifiers[name] = proc
+    end
+    
+    def add_plugin(plugin)
+      @plugins << plugin
+    end
+    
+    def add_named_cache(name, options)
+      @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)
+      @runtime += Benchmark::measure { sleep((2**count) / 10.0) }
+    end
+  end
+end

data/lib/cache_advance/mapper.rb

@@ -0,0 +1,26 @@
+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,120 @@
+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, request, value) if p.respond_to?('after_read') }
+        return value
+      end
+      
+      each_plugin { |p| p.send('before_render', @name, key, request) if p.respond_to?('before_render') }
+      result = block.call
+      each_plugin { |p| p.send('after_render', @name, key, request, result) if p.respond_to?('after_render') }
+      each_plugin { |p| p.send('before_write', @name, key, request, result) if p.respond_to?('before_write') }
+      write_to_store(key, result)
+      each_plugin { |p| p.send('after_write', @name, key, request, result) 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
+      write_to_store(enabled_key, @enabled, false)
+    end
+    
+    def enabled?
+      if @enabled.nil? || Time.now >= @enabled_check_time
+        @enabled = [nil, true].include?(read_from_store(enabled_key))
+        @enabled_check_time = Time.now + ENABLED_CHECK_INTERVAL
+      end
+      @enabled
+    end
+    
+    protected
+        
+    def read_from_store(key)
+      @store.get(key)
+    end
+    
+    def write_to_store(key, value, add_to_key_list=true)
+      expiration_time ? @store.set(key, value, expiration_time) : @store.set(key, value)
+      if add_to_key_list
+        @cached_key_list.add_key(key)
+      end
+    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}]"
+    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,19 @@
+require 'cache_advance/cache_set'
+require 'cache_advance/cached_key_list'
+require 'cache_advance/mapper'
+require 'cache_advance/named_cache'
+require 'cache_advance/named_cache_configuration'
+
+module CacheAdvance
+  class UnknownNamedCacheException < Exception; end
+
+  class << self
+    attr_reader :cache_set
+  end
+
+  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,47 @@
+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
+
+# 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.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/test/active_record_sweeper_test.rb

@@ -0,0 +1,32 @@
+require 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::Caches.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,15 @@
+module CacheAdvance
+  class CacheMock
+    def read(key)
+      'abc'
+    end
+    
+    def write(key, value)
+      
+    end
+    
+    def delete(key)
+      
+    end
+  end
+end

data/test/cache_set_test.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class Plugin; end
+
+require 'cache_advance/active_record_sweeper'
+
+class CacheSetTest < Test::Unit::TestCase
+  def setup
+    @cache_set = CacheAdvance::CacheSet.new
+  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/mapper_test.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class Hack
+end
+
+class MapperTest < Test::Unit::TestCase
+  
+  def setup
+    @cache_set = CacheAdvance::CacheSet.new
+    @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,126 @@
+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.key_for(@request)
+    assert_equal 'test_cachesuf', @named_cache.key_for(@request, 'suf')
+  end
+  
+  def test_key_with_qualifiers
+    
+  end
+  
+  protected
+  
+  def create_named_cache(options={})
+    @name = options[:name] || 'test_cache'
+    @params = {}
+    @cache_set = CacheAdvance::CacheSet.new
+    @cache = CacheAdvance::CacheMock.new
+    @named_cache = CacheAdvance::NamedCache.new(@name, @params, @cache_set, @cache)
+  end
+end
+
+
+# module CacheAdvance  
+#   class NamedCache
+#     STORED_KEY = 'STORED_CACHES'
+#     
+#     def initialize(name, params, configuration, cache)
+#       @name = name.to_s
+#       @params = params
+#       @configuration = configuration
+#       @cache = cache
+#     end
+#     
+#     def key_for(request, suffix='')
+#       key = @name.dup
+#       key << suffix.to_s
+#               
+#       qualifiers.each do |q|
+#         if (qualifier = @configuration.qualifiers[q])
+#           this_one = qualifier.call(request)
+#           key << this_one.to_s unless this_one.nil?
+#         end
+#       end if qualifiers
+#       key
+#     end
+#     
+#     def value_for(request, options, &block)
+#       key = key_for(request, options[:key])
+# 
+#       if (cache = @cache.read(key))
+#         call_plugins('after_read', key, request)
+#         return cache
+#       end
+#       
+#       call_plugins('before_write', key, request)
+#       result = block.call
+#       @cache.write(key, result, rails_options)      
+#       call_plugins('after_write', key, request)
+#       
+#       add_to_cached_keys_list(key)
+#       
+#       result
+#     end
+#     
+#     def rails_options
+#       options = {}
+#       options[:expires_in] = expiration_time if expiration_time
+#       options
+#     end
+#     
+#     def expire_for(type)
+#       if expiration_types.include?(type)
+#         expire_all
+#       end
+#     end
+#     
+#     def expire_all
+#       if (data = @cache.read(@name + STORED_KEY))
+#         data = Array(Marshal.load(data))
+#         data.each { |key| @cache.delete(key) }
+#       else
+#         @cache.delete(@name)
+#       end
+#     end
+#     
+#     def expiration_types
+#       Array(@params[:expiration_types])
+#     end
+#     
+#     def expiration_time
+#       @params[:expiration_time]
+#     end
+#     
+#     def qualifiers
+#       Array(@params[:qualifiers])
+#     end
+#     
+#     protected
+#         
+#     def call_plugins(method, key, request)
+#       @configuration.plugins.each { |p| p.send(method, @name, key, request) if p.respond_to?(method) }
+#     end
+#     
+#     def add_to_cached_keys_list(key)
+#       unless expiration_types.blank? || key == @name
+#         if (data = @cache.read(@name + STORED_KEY))
+#           data = Array(Marshal.load(data))
+#         else
+#           data = []
+#         end
+#         unless data.include?(key)
+#           @cache.write(@name + STORED_KEY, Marshal.dump(data << key))
+#         end
+#       end
+#     end
+#   end
+# end
+

data/test/spec/db/schema.rb

@@ -0,0 +1,18 @@
+ActiveRecord::Schema.define(:version => 1) do
+  create_table "publications", :force => true do |t|
+    t.string "name", "subdomain"
+  end
+
+  create_table "articles", :force => true do |t|
+    t.references 'publication'
+    t.string 'title'
+  end
+end
+
+class Publication < ActiveRecord::Base
+  has_many :articles
+end
+
+class Article < ActiveRecord::Base
+  belongs_to :publication
+end

data/test/spec/mapper_spec.rb

@@ -0,0 +1,16 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+module CacheAdvance
+  before :each do
+    @cache_set = CacheSet.new
+    @mapper = Mapper.new(@cache_set)
+  end
+  
+  describe 'Mapper' do
+    it 'should pass qualifiers directly to the cache set' do
+      proc = Proc.new { 2 }
+      @cache_set.should_receive(:add_qualifier).with(proc)
+      @mapper.qualifier(:testy, proc)
+    end
+  end
+end

data/test/spec/mocks/memcache.rb

@@ -0,0 +1,41 @@
+class MemCache
+  attr_reader :data
+  
+  def initialize
+    @data = {}
+  end
+  
+  def decr(key, amount = 1)
+  end
+
+  def get(key, raw = false)
+    return @data[key]
+  end
+
+  def get_multi(*keys)
+  end
+
+  def incr(key, amount = 1)
+  end
+
+  def set(key, value, expiry = 0, raw = false)
+    @data[key] = value
+  end
+
+  def add(key, value, expiry = 0, raw = false)
+  end
+
+  def delete(key, expiry = 0)
+    @data.delete(key)
+  end
+
+  def flush_all
+  end
+
+  def reset
+    @data = {}
+  end
+
+  def stats
+  end
+end

data/test/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+$: << File.join(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'ruby-debug'
+
+gem 'sqlite3-ruby'
+require 'spec'
+require 'cache_advance'
+
+require 'activerecord'
+
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3',
+  :dbfile => ':memory:'
+)
+
+require File.join(File.dirname(__FILE__), 'db', 'schema')
+require File.join(File.dirname(__FILE__), 'mocks', 'memcache')
+
+Spec::Runner.configure do |config|
+  # config.mock_with :rr
+  config.before :each do
+    @memcache = MemCache.new
+
+    CacheAdvance.define_caches(@memcache) do |cache_config|
+      cache_config.publication
+    end
+  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,82 @@
+--- !ruby/object:Gem::Specification 
+name: aub-cache_advance
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Aubrey Holland
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-08 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: A system for spiffy declarative caching
+email: aubrey@patch.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- README.textile
+- Rakefile
+- TODO.textile
+- cache_advance-1.0.9.gem
+- 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
+- test/active_record_sweeper_test.rb
+- test/cache_mock.rb
+- test/cache_set_test.rb
+- test/mapper_test.rb
+- test/named_cache_test.rb
+- test/spec/db/schema.rb
+- test/spec/mapper_spec.rb
+- test/spec/mocks/memcache.rb
+- test/spec/spec_helper.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/aub/cache_advance
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README.textile
+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.2.0
+signing_key: 
+specification_version: 2
+summary: A system for spiffy declarative caching
+test_files: 
+- test/active_record_sweeper_test.rb
+- test/cache_set_test.rb
+- test/mapper_test.rb
+- test/named_cache_test.rb