cache_method 0.0.1 → 0.0.2

data/.gitignore

@@ -3,3 +3,5 @@
 Gemfile.lock
 pkg/*
 rdoc/*
+secret.sh
+.DS_Store

data/README.rdoc

@@ -42,17 +42,17 @@ And clear them too
 
 == Configuration (and supported cache clients)
 
-You need to set a client that will be used to access the cache:
+You need to set where the cache will be stored:
 
-    CacheMethod.config.client = Memcached.new '127.0.0.1:11211'
+    CacheMethod.config.storage = Memcached.new '127.0.0.1:11211'
 
 or
 
-    CacheMethod.config.client = Redis.new
+    CacheMethod.config.storage = Redis.new
 
 or this might even work...
 
-    CacheMethod.config.client = Rails.cache
+    CacheMethod.config.storage = Rails.cache
 
 See <tt>Config</tt> for the full list of supported caches.
 

data/cache_method.gemspec

@@ -8,9 +8,9 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Seamus Abshere"]
   s.email       = ["seamus@abshere.net"]
-  s.homepage    = ""
-  s.summary     = %q{Provides cache_method}
-  s.description = %q{Lets you cache methods (to memcached, redis, etc.) sort of like you can memoize them}
+  s.homepage    = "https://github.com/seamusabshere/cache_method"
+  s.summary     = %q{Lets you cache methods (to memcached, redis, etc.) sort of like you can memoize them}
+  s.description = %q{Like alias_method, but it's cache_method!}
 
   s.rubyforge_project = "cache_method"
 
@@ -18,13 +18,8 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.require_paths = ["lib"]
   
-  s.add_development_dependency 'redis'
-  s.add_development_dependency 'activesupport', '>=2.3.4'
-  s.add_development_dependency 'i18n' # activesupport
-  s.add_development_dependency 'test-unit'
+  s.add_dependency 'cache'
   s.add_development_dependency 'memcached'
-  s.add_development_dependency 'dalli'
-  s.add_development_dependency 'memcache-client'
   # if RUBY_VERSION >= '1.9'
   #   s.add_development_dependency 'ruby-debug19'
   # else

data/lib/cache_method/cached_result.rb

@@ -0,0 +1,56 @@
+require 'digest/md5'
+module CacheMethod
+  class CachedResult #:nodoc: all
+    class << self
+      def fetch(options = {})
+        cached_result = new options
+        cached_result.fetch
+      end
+    end
+    
+    def initialize(options = {})
+      options.each do |k, v|
+        instance_variable_set "@#{k}", v
+      end
+    end
+
+    attr_reader :obj
+    attr_reader :method_id
+    attr_reader :original_method_id
+    attr_reader :args
+    
+    def fetch
+      if v = Config.instance.storage.get(cache_key) and v.is_a?(::Array)
+        v[0]
+      else
+        v = obj.send original_method_id, *args
+        Config.instance.storage.set cache_key, [v], ttl
+        v
+      end
+    end
+    
+    def ttl
+      @ttl ||= Config.instance.default_ttl
+    end
+    
+    def cache_key
+      [ method_signature, current_epoch, obj_hash, args_digest ].join ','
+    end
+    
+    def method_signature
+      @method_signature ||= ::CacheMethod.method_signature(obj, method_id)
+    end
+            
+    def obj_hash
+      @obj_hash ||= obj.hash
+    end
+  
+    def args_digest
+      @args_digest ||= ::Digest::MD5.hexdigest(args.flatten.join)
+    end
+        
+    def current_epoch
+      @current_epoch ||= Epoch.current(:obj => obj, :method_id => method_id)
+    end
+  end
+end

data/lib/cache_method/config.rb

@@ -1,16 +1,17 @@
+require 'cache'
 require 'singleton'
 module CacheMethod
   # Here's where you set config options.
   #
   # Example:
-  #     CacheMethod.config.client = Memcached.new '127.0.0.1:11211'
+  #     CacheMethod.config.storage = Memcached.new '127.0.0.1:11211'
   #     CacheMethod.config.default_ttl = 120 # seconds
   #
   # You'd probably put this in your Rails config/initializers, for example.
   class Config
     include ::Singleton
     
-    # Client for accessing the cache.
+    # Storage for the cache.
     #
     # Supported memcached clients:
     # * memcached[https://github.com/fauna/memcached] (either a Memcached or a Memcached::Rails)
@@ -18,16 +19,18 @@ module CacheMethod
     # * memcache-client[https://github.com/mperham/memcache-client] (MemCache, the one commonly used by Rails)
     #
     # Supported Redis clients:
-    # * redis[https://github.com/ezmobius/redis-rb] (NOTE: AUTOMATIC CACHE EXPIRATION NOT SUPPORTED)
+    # * redis[https://github.com/ezmobius/redis-rb]
+    #
+    # Uses the cache[https://github.com/seamusabshere/cache] gem to wrap these, so support depends on that gem
     #
     # Example:
-    #     CacheMethod.config.client = Memcached.new '127.0.0.1:11211'
-    def client=(client)
-      @client = client
+    #     CacheMethod.config.storage = Memcached.new '127.0.0.1:11211'
+    def storage=(raw_client)
+      @storage = ::Cache.new raw_client
     end
 
-    def client #:nodoc:
-      @client || raise("You need to set CacheMethod.config.client with a cache client of your choice")
+    def storage #:nodoc:
+      @storage || raise("You need to set CacheMethod.config.storage with a cache storage of your choice")
     end
     
     # TTL for method caches. Defaults to 60 seconds.

data/lib/cache_method/epoch.rb

@@ -0,0 +1,44 @@
+module CacheMethod
+  class Epoch #:nodoc: all
+    class << self
+      def current(options = {})
+        epoch = new options
+        epoch.current
+      end
+      
+      def mark_passing(options = {})
+        epoch = new options
+        epoch.mark_passing
+      end
+    end
+
+    def initialize(options = {})
+      options.each do |k, v|
+        instance_variable_set "@#{k}", v
+      end
+    end
+    
+    attr_reader :obj
+    attr_reader :method_id
+    
+    def method_signature
+      @method_signature ||= ::CacheMethod.method_signature(obj, method_id)
+    end
+    
+    def obj_hash
+      @obj_hash ||= obj.hash
+    end
+    
+    def cache_key
+      [ 'CacheMethod', method_signature, obj_hash ].join ','
+    end
+    
+    def current
+      Config.instance.storage.get(cache_key).to_i
+    end
+    
+    def mark_passing
+      Config.instance.storage.set cache_key, (current+1), 0
+    end
+  end
+end

data/lib/cache_method/version.rb

@@ -1,3 +1,3 @@
 module CacheMethod
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/cache_method.rb

@@ -1,14 +1,24 @@
+require 'cache_method/version'
 # See the README.rdoc for more info!
 module CacheMethod
   autoload :Config, 'cache_method/config'
-  autoload :Cache, 'cache_method/cache'
+  autoload :CachedResult, 'cache_method/cached_result'
+  autoload :Epoch, 'cache_method/epoch'
 
   def self.config #:nodoc:
     Config.instance
   end
   
-  def self.cache #:nodoc:
-    Cache.instance
+  def self.klass_name(obj) #:nodoc:
+    obj.is_a?(::Class) ? obj.to_s : obj.class.to_s
+  end
+  
+  def self.method_delimiter(obj) #:nodoc:
+    obj.is_a?(::Class) ? '.' : '#'
+  end
+  
+  def self.method_signature(obj, method_id) #:nodoc:
+    [ klass_name(obj), method_id ].join method_delimiter(obj)
   end
   
   # All Objects, including instances and Classes, get the <tt>#clear_method_cache</tt> method.
@@ -20,7 +30,7 @@ module CacheMethod
     # Example:
     #     my_blog.clear_method_cache :get_latest_entries
     def clear_method_cache(method_id)
-      ::CacheMethod.cache.delete self, method_id
+      ::CacheMethod::Epoch.mark_passing :obj => self, :method_id => method_id
     end
   end
 
@@ -47,9 +57,7 @@ module CacheMethod
       original_method_id = "_uncached_#{method_id}"
       alias_method original_method_id, method_id
       define_method method_id do |*args|
-        ::CacheMethod.cache.fetch self, method_id, ttl, *args do
-          send original_method_id, *args
-        end
+        ::CacheMethod::CachedResult.fetch :obj => self, :method_id => method_id, :original_method_id => original_method_id, :args => args, :ttl => ttl
       end
     end
   end

data/test/helper.rb

@@ -8,44 +8,50 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'cache_method'
 
 class Test::Unit::TestCase
-  def setup
-    CacheMethod.cache.flush
-  end
 end
 
-require 'memcached'
-require 'memcache'
-require 'redis'
-require 'dalli'
-require 'active_support/all'
-require 'active_support/cache/dalli_store'
-def random_cache
-  c = if ENV['C']
-    ENV['C'].to_i
-  else
-    rand 6
+class Blog1
+  attr_reader :name
+  attr_reader :url
+  def initialize(name, url)
+    @name = name
+    @url = url
+  end
+  attr_writer :request_count
+  def request_count
+    @request_count ||= 0
+  end
+  def get_latest_entries
+    self.request_count += 1
+    ["hello from #{name}"]
+  end
+  cache_method :get_latest_entries
+  def get_latest_entries2
+    self.request_count += 1
+    ["voo vaa #{name}"]
   end
-  case c
-  when 0
-    $stderr.puts 'using memcached'
-    Memcached.new 'localhost:11211'
-  when 1
-    $stderr.puts 'using memcache-client'
-    MemCache.new ['localhost:11211']
-  when 2
-    $stderr.puts 'using dalli'
-    Dalli::Client.new ['localhost:11211']
-  when 3
-    $stderr.puts 'using dalli_store'
-    ActiveSupport::Cache::DalliStore.new ['localhost:11211']
-  when 4
-    $stderr.puts 'using memcached-rails'
-    Memcached::Rails.new 'localhost:11211'
-  when 5
-    $stderr.puts 'using Redis'
-    Redis.new
+  cache_method :get_latest_entries2, 1 # second
+  def hash
+    { :name => name, :url => url }.hash
   end
 end
+def new_instance_of_my_blog
+  Blog1.new 'my_blog', 'http://my_blog.example.com'
+end
+def new_instance_of_another_blog
+  Blog1.new 'another_blog', 'http://another_blog.example.com'
+end
 
-$my_cache = random_cache
-CacheMethod.config.client = $my_cache
+class Blog2
+  class << self
+    attr_writer :request_count
+    def request_count
+      @request_count ||= 0
+    end
+    def get_latest_entries
+      self.request_count += 1
+      'danke schoen'
+    end
+    cache_method :get_latest_entries
+  end
+end

data/test/{test_cache_instance_methods.rb → test_cache_method.rb}

@@ -1,40 +1,16 @@
 require 'helper'
 
-class Blog1
-  attr_reader :name
-  attr_reader :url
-  def initialize(name, url)
-    @name = name
-    @url = url
-  end
-  attr_writer :request_count
-  def request_count
-    @request_count ||= 0
-  end
-  def get_latest_entries
-    self.request_count += 1
-    ["hello from #{name}"]
-  end
-  cache_method :get_latest_entries
-  def get_latest_entries2
-    self.request_count += 1
-    ["voo vaa #{name}"]
-  end
-  cache_method :get_latest_entries2, 1 # second
-  def hash
-    { :name => name, :url => url }.hash
-  end
-end
+require 'memcached'
 
-class TestCacheInstanceMethods < Test::Unit::TestCase
-  def new_instance_of_my_blog
-    Blog1.new 'my_blog', 'http://my_blog.example.com'
-  end
-  def new_instance_of_another_blog
-    Blog1.new 'another_blog', 'http://another_blog.example.com'
+class TestCacheMethod < Test::Unit::TestCase
+  def setup
+    Blog2.request_count = 0
+    my_cache = Memcached.new '127.0.0.1:11211'
+    CacheMethod.config.storage = my_cache
+    my_cache.flush
   end
   
-  def test_cache_method
+  def test_cache_instance_method
     a = new_instance_of_my_blog
     assert_equal ["hello from #{a.name}"], a.get_latest_entries
     assert_equal 1, a.request_count
@@ -46,7 +22,7 @@ class TestCacheInstanceMethods < Test::Unit::TestCase
     assert_equal 1, xxx.request_count
   end
   
-  def test_clear_method
+  def test_clear_instance_method
     a = new_instance_of_my_blog
     assert_equal ["hello from #{a.name}"], a.get_latest_entries
     assert_equal 1, a.request_count
@@ -55,7 +31,7 @@ class TestCacheInstanceMethods < Test::Unit::TestCase
     assert_equal 2, a.request_count
   end
   
-  def test_clear_a_different_method
+  def test_clear_correct_instance_method
     a = new_instance_of_my_blog
     assert_equal ["hello from #{a.name}"], a.get_latest_entries
     assert_equal 1, a.request_count
@@ -64,7 +40,7 @@ class TestCacheInstanceMethods < Test::Unit::TestCase
     assert_equal 1, a.request_count
   end
     
-  def test_clear_from_somebody_else
+  def test_clear_instance_method_from_correct_instance
     a = new_instance_of_my_blog
     assert_equal ["hello from #{a.name}"], a.get_latest_entries
     assert_equal 1, a.request_count
@@ -78,13 +54,43 @@ class TestCacheInstanceMethods < Test::Unit::TestCase
     assert_equal 2, xxx.request_count
   end
   
-  def test_ttl
+  def test_cache_instance_method_ttl
     a = new_instance_of_my_blog
     assert_equal ["voo vaa #{a.name}"], a.get_latest_entries2
     assert_equal 1, a.request_count
-    a = new_instance_of_my_blog
     sleep 2
     assert_equal ["voo vaa #{a.name}"], a.get_latest_entries2
-    assert_equal 1, a.request_count
+    assert_equal 2, a.request_count
+  end
+  
+  def test_cache_class_method
+    assert_equal 0, Blog2.request_count
+    assert_equal 'danke schoen', Blog2.get_latest_entries
+    assert_equal 1, Blog2.request_count
+    assert_equal 'danke schoen', Blog2.get_latest_entries
+    assert_equal 1, Blog2.request_count
+  end
+  
+  def test_clear_class_method
+    assert_equal 0, Blog2.request_count
+    assert_equal 'danke schoen', Blog2.get_latest_entries
+    assert_equal 1, Blog2.request_count
+    Blog2.clear_method_cache :get_latest_entries
+    assert_equal 'danke schoen', Blog2.get_latest_entries
+    assert_equal 2, Blog2.request_count
+  end
+    
+  def test_clear_correct_class_method
+    assert_equal 0, Blog2.request_count
+    assert_equal 'danke schoen', Blog2.get_latest_entries
+    assert_equal 1, Blog2.request_count
+    
+    Blog2.clear_method_cache :foobar
+    assert_equal 'danke schoen', Blog2.get_latest_entries
+    assert_equal 1, Blog2.request_count
+    
+    Blog2.clear_method_cache :get_latest_entries
+    assert_equal 'danke schoen', Blog2.get_latest_entries
+    assert_equal 2, Blog2.request_count
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cache_method
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Seamus Abshere
@@ -15,11 +15,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-15 00:00:00 -06:00
+date: 2011-02-17 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: redis
+  name: cache
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
@@ -30,84 +30,12 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :development
+  type: :runtime
   version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: activesupport
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 11
-        segments: 
-        - 2
-        - 3
-        - 4
-        version: 2.3.4
-  type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: i18n
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: test-unit
-  prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: memcached
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: dalli
-  prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id006
-- !ruby/object:Gem::Dependency 
-  name: memcache-client
-  prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -117,8 +45,8 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id007
-description: Lets you cache methods (to memcached, redis, etc.) sort of like you can memoize them
+  version_requirements: *id002
+description: Like alias_method, but it's cache_method!
 email: 
 - seamus@abshere.net
 executables: []
@@ -129,22 +57,19 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
-- DEVELOPER_NOTES.rdoc
 - Gemfile
 - README.rdoc
 - Rakefile
 - cache_method.gemspec
 - lib/cache_method.rb
-- lib/cache_method/cache.rb
-- lib/cache_method/cache/epoch.rb
-- lib/cache_method/cache/key.rb
+- lib/cache_method/cached_result.rb
 - lib/cache_method/config.rb
+- lib/cache_method/epoch.rb
 - lib/cache_method/version.rb
 - test/helper.rb
-- test/test_cache_class_methods.rb
-- test/test_cache_instance_methods.rb
+- test/test_cache_method.rb
 has_rdoc: true
-homepage: ""
+homepage: https://github.com/seamusabshere/cache_method
 licenses: []
 
 post_install_message: 
@@ -176,8 +101,7 @@ rubyforge_project: cache_method
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Provides cache_method
+summary: Lets you cache methods (to memcached, redis, etc.) sort of like you can memoize them
 test_files: 
 - test/helper.rb
-- test/test_cache_class_methods.rb
-- test/test_cache_instance_methods.rb
+- test/test_cache_method.rb

data/DEVELOPER_NOTES.rdoc

@@ -1,45 +0,0 @@
-= Developer notes
-
-== Lots of cache method signatures...
-
-    def get(k)
-      if defined?(::Memcached) and raw_client.is_a?(::Memcached)
-        # def get(keys, marshal=true)
-        begin; raw_client.get(k.to_s); rescue ::Memcached::NotFound; nil; end
-      elsif defined?(::Memcached::Rails) and raw_client.is_a?(::Memcached::Rails)
-        # def get(key, raw=false)
-        raw_client.get k.to_s
-      elsif defined?(::Dalli::Client) and raw_client.is_a?(::Dalli::Client)
-        # def get(key, options=nil)
-        raw_client.get k.to_s
-      elsif defined?(::MemCache) and raw_client.is_a?(::MemCache)
-        # def get(key, raw = false)
-        raw_client.get k.to_s
-      elsif defined?(::ActiveSupport::Cache::Store) and raw_client.is_a?(::ActiveSupport::Cache::Store)
-        # def read(name, options = nil)
-        raw_client.read k.to_s
-      else
-        raise "Unknown client: #{raw_client.inspect}"
-      end
-    end
-    
-    def set(k, v)
-      if defined?(::Memcached) and raw_client.is_a?(::Memcached)
-        # def set(key, value, ttl=@default_ttl, marshal=true, flags=FLAGS)
-        raw_client.set k.to_s, v, ttl
-      elsif defined?(::Memcached::Rails) and raw_client.is_a?(::Memcached::Rails)
-        # def set(key, value, ttl=@default_ttl, raw=false)
-        raw_client.set k.to_s, v, ttl
-      elsif defined?(::Dalli::Client) and raw_client.is_a?(::Dalli::Client)
-        # def set(key, value, ttl=nil, options=nil)
-        raw_client.set k.to_s, v, ttl
-      elsif defined?(::MemCache) and raw_client.is_a?(::MemCache)
-        # def set(key, value, expiry = 0, raw = false)
-        raw_client.set k.to_s, v, ttl
-      elsif defined?(::ActiveSupport::Cache::Store) and raw_client.is_a?(::ActiveSupport::Cache::Store)
-        # def write(name, value, options = nil)
-        raw_client.write k.to_s, v, :expires_in => ttl
-      else
-        raise "Unknown client: #{raw_client.inspect}"
-      end
-    end

data/lib/cache_method/cache/epoch.rb

@@ -1,45 +0,0 @@
-module CacheMethod
-  class Cache
-    class Epoch
-      class << self
-        def mark_passing(options = {})
-          e = new options
-          e.mark_passing
-        end
-        def current(options = {})
-          e = new options
-          e.current
-        end
-      end
-      
-      def initialize(options = {})
-        options.each do |k, v|
-          instance_variable_set "@#{k}", v
-        end
-      end
-      
-      attr_reader :obj
-      attr_reader :method_id
-      
-      def method_signature
-        @method_signature ||= Key.method_signature(obj, method_id)
-      end
-      
-      def obj_hash
-        @obj_hash ||= obj.hash
-      end
-      
-      def cache_key
-        [ 'CacheMethod', method_signature, obj_hash ].join ','
-      end
-      
-      def current
-        Cache.instance.get(cache_key).to_i
-      end
-      
-      def mark_passing
-        Cache.instance.set cache_key, (current+1), 0
-      end
-    end
-  end
-end

data/lib/cache_method/cache/key.rb

@@ -1,56 +0,0 @@
-require 'digest/md5'
-module CacheMethod
-  class Cache
-    class Key
-      class << self
-        def digest(*ary)
-          ::Digest::MD5.hexdigest ary.flatten.map { |i| i.to_s }.join
-        end
-        def parse(str)
-          method_signature, epoch, obj_hash, args_digest = str.split ','
-          new :method_signature => method_signature, :epoch => epoch, :obj_hash => obj_hash, :args_digest => args_digest
-        end
-        def klass_name(obj)
-          obj.is_a?(::Class) ? obj.to_s : obj.class.to_s
-        end
-        def method_delimiter(obj)
-          obj.is_a?(::Class) ? '.' : '#'
-        end
-        def method_signature(obj, method_id)
-          [ klass_name(obj), method_id ].join method_delimiter(obj)
-        end
-      end
-  
-      def initialize(options = {})
-        options.each do |k, v|
-          instance_variable_set "@#{k}", v
-        end
-      end
-  
-      attr_reader :obj
-      attr_reader :method_id
-      attr_reader :args
-
-      def obj_hash
-        @obj_hash ||= obj.hash
-      end
-    
-      def args_digest
-        @args_digest ||= Key.digest(args)
-      end
-      
-      def method_signature
-        @method_signature ||= Key.method_signature(obj, method_id)
-      end
-      
-      def epoch
-        @epoch ||= Epoch.current(:obj => obj, :method_id => method_id)
-      end
-    
-      def to_str
-         [ method_signature, epoch, obj_hash, args_digest ].join ','
-      end
-      alias :to_s :to_str
-    end
-  end
-end

data/lib/cache_method/cache.rb

@@ -1,65 +0,0 @@
-require 'singleton'
-module CacheMethod
-  # All cache requests go through a clearinghouse, allowing uncaching.
-  class Cache #:nodoc: all
-    autoload :Key, 'cache_method/cache/key'
-    autoload :Epoch, 'cache_method/cache/epoch'
-    
-    include ::Singleton
-    
-    def flush
-      bare_client.send %w{ flush flush_all clear flushdb }.detect { |c| bare_client.respond_to? c }
-    end
-    
-    def fetch(obj, method_id, ttl, *args)
-      k = Key.new :obj => obj, :method_id => method_id, :args => args
-      if cached_v = get(k.to_s)
-        return cached_v
-      end
-      v = yield
-      set k.to_s, v, ttl
-      v
-    end
-    
-    def delete(obj, method_id)
-      Epoch.mark_passing :obj => obj, :method_id => method_id
-    end
-
-    def get(k)
-      if defined?(::Memcached) and bare_client.is_a?(::Memcached)
-        begin; bare_client.get(k); rescue ::Memcached::NotFound; nil; end
-      elsif defined?(::Redis) and bare_client.is_a?(::Redis)
-        if cached_v = bare_client.get(k)
-          ::Marshal.load cached_v
-        end
-      elsif bare_client.respond_to?(:get)
-        bare_client.get k
-      elsif bare_client.respond_to?(:read)
-        bare_client.read k
-      else
-        raise "Don't know how to work with #{bare_client.inspect}"
-      end
-    end
-        
-    def set(k, v, ttl)
-      ttl ||= ::CacheMethod.config.default_ttl
-      if defined?(::Redis) and bare_client.is_a?(::Redis)
-        bare_client.set k, ::Marshal.dump(v)
-      elsif bare_client.respond_to?(:set)
-        bare_client.set k, v, ttl
-      elsif bare_client.respond_to?(:write)
-        if ttl == 0
-          bare_client.write k, v # never expire
-        else
-          bare_client.write k, v, :expires_in => ttl
-        end
-      else
-        raise "Don't know how to work with #{bare_client.inspect}"
-      end
-    end
-    
-    def bare_client
-      ::CacheMethod.config.client
-    end
-  end
-end

data/test/test_cache_class_methods.rb

@@ -1,53 +0,0 @@
-require 'helper'
-
-class Blog2
-  class << self
-    attr_writer :request_count
-    def request_count
-      @request_count ||= 0
-    end
-    def get_latest_entries
-      self.request_count += 1
-      'danke schoen'
-    end
-    cache_method :get_latest_entries
-  end
-end
-
-class TestCacheClassMethods < Test::Unit::TestCase
-  def setup
-    super
-    Blog2.request_count = 0
-  end
-  
-  def test_cache_method
-    assert_equal 0, Blog2.request_count
-    assert_equal 'danke schoen', Blog2.get_latest_entries
-    assert_equal 1, Blog2.request_count
-    assert_equal 'danke schoen', Blog2.get_latest_entries
-    assert_equal 1, Blog2.request_count
-  end
-  
-  def test_clear_method
-    assert_equal 0, Blog2.request_count
-    assert_equal 'danke schoen', Blog2.get_latest_entries
-    assert_equal 1, Blog2.request_count
-    Blog2.clear_method_cache :get_latest_entries
-    assert_equal 'danke schoen', Blog2.get_latest_entries
-    assert_equal 2, Blog2.request_count
-  end
-    
-  def test_clear_method_doesnt_overstep
-    assert_equal 0, Blog2.request_count
-    assert_equal 'danke schoen', Blog2.get_latest_entries
-    assert_equal 1, Blog2.request_count
-    
-    Blog2.clear_method_cache :foobar
-    assert_equal 'danke schoen', Blog2.get_latest_entries
-    assert_equal 1, Blog2.request_count
-    
-    Blog2.clear_method_cache :get_latest_entries
-    assert_equal 'danke schoen', Blog2.get_latest_entries
-    assert_equal 2, Blog2.request_count
-  end
-end