cache_method 0.1.6 → 0.2.0

data/.gitignore

@@ -1,7 +1,6 @@
 *.gem
-.bundle
 Gemfile.lock
-pkg/*
-rdoc/*
-secret.sh
 .DS_Store
+.yardoc/
+doc/
+.bundle/

data/CHANGELOG

@@ -0,0 +1,24 @@
+0.2.0 / 2012-02-29
+
+* API changes:
+
+  * #clear_method_cache -> #cache_method_clear
+  * #method_cache_hash -> #as_cache_key (see README)
+  * doesn't rely on #hash at all any more (http://numbers.brighterplanet.com/2012/02/29/beware-of-string-hash-being-used-for-cache-keys/)
+  * doesn't try to mitigate differences between Ruby 1.8 and 1.9 splats (http://www.ruby-forum.com/topic/98106)
+
+* Enhancements
+
+  * clearer method naming, I think
+  * safer determination of cache keys - previously, in effect, args.map(&:to_s) was being used
+  * no more autoload
+  * remove direct dependency on activesupport
+  * tests now run with dalli, green on MRI 1.8, MRI 1.9, and jruby 1.6.7
+
+0.1.7 / yanked!
+
+* Bug: used args.map(&:hash) instead of args.map(&:to_s)... which was actually worse because #hash is different across processes.
+
+0.1.6 / November 17, 2011
+
+* Last release before CHANGELOG in place

data/Gemfile

@@ -1,4 +1,9 @@
-source "http://rubygems.org"
+source :rubygems
 
 # Specify your gem's dependencies in cache_method.gemspec
 gemspec
+
+# development dependencies
+gem 'rake'
+gem 'dalli'
+gem 'yard'

data/{README.rdoc → README.markdown}

@@ -1,14 +1,14 @@
-= cache_method
+# cache_method
 
-It's like <tt>alias_method</tt>, but it's <tt>cache_method</tt>!
+It's like `alias_method`, but it's `cache_method`!
 
 Lets you cache the results of calling methods given their arguments. Like memoization, but stored in Memcached, Redis, etc. so that the cached results can be shared between processes and hosts.
 
-== Real-world usage
+## Real-world usage
 
-In production use at {impact.brighterplanet.com}[http://impact.brighterplanet.com] and {data.brighterplanet.com}[http://data.brighterplanet.com].
+In production use at [impact.brighterplanet.com](http://impact.brighterplanet.com) and [data.brighterplanet.com](http://data.brighterplanet.com).
 
-== Example
+## Example
 
     require 'cache_method'
     class Blog
@@ -25,12 +25,11 @@ In production use at {impact.brighterplanet.com}[http://impact.brighterplanet.co
       end
       cache_method :get_latest_entries
 
-      # cache_method defaults to using the #hash method
-      # It's a "hash code" (integer! always integer!) representing the internal state of an instance.
-      # If you need to customize it, you can define #method_cache_hash.
-      # In that case, it's recommended that you construct a String or a Hash and then call #hash on it (because you should return an integer)
-      def method_cache_hash
-        { :name => name, :url => url }.hash
+      # By default, cache_method derives the cache key for an instance by getting the SHA1 hash of the Marshal.dump
+      # If you need to customize how an instance is recognized, you can define #as_cache_key.
+      # Marshal.load will be called on the result.
+      def as_cache_key
+        { :name => name, :url => url }
       end
     end
 
@@ -41,11 +40,11 @@ Then you can do
 
 And clear them too
 
-    my_blog.clear_method_cache :get_latest_entries
+    my_blog.cache_method_clear :get_latest_entries
 
 (which doesn't delete the rest of your cache)
 
-== Configuration (and supported cache clients)
+## Configuration (and supported cache clients)
 
 You need to set where the cache will be stored:
 
@@ -59,9 +58,9 @@ or this might even work...
 
     CacheMethod.config.storage = Rails.cache
 
-See <tt>Config</tt> for the full list of supported caches.
+See `Config` for the full list of supported caches.
 
-== Defining a #hash method (not the same as #to_hash)
+== Defining a #as_cache_key method
 
 Since we're not pure functional programmers, sometimes cache hits depend on object state in addition to method arguments. To illustrate:
 
@@ -71,25 +70,17 @@ get_latest_entries doesn't take any arguments, so it must depend on my_blog.url
 
     class Blog
       # [...]
-      def method_cache_hash
-        { :name => name, :url => url }.hash
+      def as_cache_key
+        { :name => name, :url => url }
       end
       # [...]
     end
 
-You should follow Ruby convention and have <tt>#hash</tt> return a <tt>Fixnum</tt>.
+If you don't define `#as_cache_key`, then `cache_method` will `Marshal.dump` an instance.
 
-Ideally, you should try to make a <tt>String</tt> or a <tt>Hash</tt> and call the standard <tt>#hash</tt> on that.
+## Module methods
 
-Note: this is NOT the same thing as <tt>#to_hash</tt>! That returns a <b><tt>Hash</tt></b>. What we want is an integer "hash code."
-
-== Using #method_cache_hash instead of #hash
-
-If you don't want to modify #hash, use #method_cache_hash instead.
-
-== Module methods
-
-You can put <tt>#cache_method</tt> right into your module declarations:
+You can put `#cache_method` right into your module declarations:
 
     module MyModule
       def my_module_method(args)
@@ -106,7 +97,7 @@ You can put <tt>#cache_method</tt> right into your module declarations:
       extend MyModule
     end
     
-Rest assured that <tt>Tiger.my_module_method</tt> and <tt>Lion.my_module_method</tt> will be cached correctly and separately. This, on the other hand, won't work:
+Rest assured that `Tiger.my_module_method` and `Lion.my_module_method` will be cached correctly and separately. This, on the other hand, won't work:
 
     class Tiger
       extend MyModule
@@ -114,13 +105,13 @@ Rest assured that <tt>Tiger.my_module_method</tt> and <tt>Lion.my_module_method<
       # cache_method :my_module_method
     end
 
-== Rationale
+## Rationale
 
-* It should be easy to cache a method using memcached, dalli (if you're on heroku), redis, etc. (that's why I made the {cache gem}[https://rubygems.org/gems/cache])
+* It should be easy to cache a method using memcached, dalli (if you're on heroku), redis, etc. (that's why I made the [cache gem](https://rubygems.org/gems/cache))
 * It should be easy to uncache a method without clearing the whole cache
 * It should be easy to cache instance methods
-* It should be easy to cache methods that depend on object state
+* It should be easy to cache methods that depend on object state (hence `#as_cache_key`)
 
-== Copyright
+## Copyright
 
-Copyright 2011 Seamus Abshere
+Copyright 2012 Seamus Abshere

data/Rakefile

@@ -1,5 +1,5 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
 
 require 'rake'
 require 'rake/testtask'
@@ -11,12 +11,5 @@ end
 
 task :default => :test
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "cache_method #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+require 'yard'
+YARD::Rake::YardocTask.new

data/cache_method.gemspec

@@ -5,7 +5,6 @@ require "cache_method/version"
 Gem::Specification.new do |s|
   s.name        = "cache_method"
   s.version     = CacheMethod::VERSION
-  s.platform    = Gem::Platform::RUBY
   s.authors     = ["Seamus Abshere"]
   s.email       = ["seamus@abshere.net"]
   s.homepage    = "https://github.com/seamusabshere/cache_method"
@@ -19,11 +18,4 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   
   s.add_dependency 'cache', '>=0.2.1'
-  s.add_development_dependency 'memcached'
-  s.add_development_dependency 'rake'
-  # if RUBY_VERSION >= '1.9'
-  #   s.add_development_dependency 'ruby-debug19'
-  # else
-  #   s.add_development_dependency 'ruby-debug'
-  # end
 end

data/lib/cache_method/cached_result.rb

@@ -1,6 +1,8 @@
-require 'digest/md5'
+require 'digest/sha1'
 module CacheMethod
   class CachedResult #:nodoc: all
+    CACHE_KEY_JOINER = ','
+
     def initialize(obj, method_id, original_method_id, ttl, args)
       @obj = obj
       @method_id = method_id
@@ -17,7 +19,7 @@ module CacheMethod
     # Store things wrapped in an Array so that nil is accepted
     def fetch
       if v = Config.instance.storage.get(cache_key) and v.is_a?(::Array)
-        v[0]
+        v.first
       else
         v = obj.send original_method_id, *args
         Config.instance.storage.set cache_key, [v], ttl
@@ -31,9 +33,9 @@ module CacheMethod
     
     def cache_key
       if obj.is_a?(::Class) or obj.is_a?(::Module)
-        [ 'CacheMethod', 'CachedResult', method_signature, current_generation, args_digest ].compact.join ','
+        [ 'CacheMethod', 'CachedResult', method_signature, current_generation, args_digest ].compact.join CACHE_KEY_JOINER
       else
-        [ 'CacheMethod', 'CachedResult', method_signature, obj_hash, current_generation, args_digest ].compact.join ','
+        [ 'CacheMethod', 'CachedResult', method_signature, obj_digest, current_generation, args_digest ].compact.join CACHE_KEY_JOINER
       end
     end
     
@@ -41,12 +43,12 @@ module CacheMethod
       @method_signature ||= ::CacheMethod.method_signature(obj, method_id)
     end
             
-    def obj_hash
-      @obj_hash ||= obj.respond_to?(:method_cache_hash) ? obj.method_cache_hash : obj.hash
+    def obj_digest
+      @obj_digest ||= ::Digest::SHA1.hexdigest(::Marshal.dump(obj.respond_to?(:as_cache_key) ? obj.as_cache_key : obj))
     end
   
     def args_digest
-      @args_digest ||= args.empty? ? 'empty' : ::Digest::MD5.hexdigest(args.join)
+      @args_digest ||= args.empty? ? 'empty' : ::Digest::SHA1.hexdigest(::Marshal.dump(args))
     end
         
     def current_generation
@@ -54,5 +56,9 @@ module CacheMethod
         @current_generation ||= Generation.new(obj, method_id).current
       end
     end
+
+    def arity
+      @arity ||= obj.method(original_method_id).arity
+    end
   end
 end

data/lib/cache_method/generation.rb

@@ -1,3 +1,4 @@
+require 'digest/sha1'
 module CacheMethod
   class Generation #:nodoc: all
     class << self
@@ -18,15 +19,15 @@ module CacheMethod
       @method_signature ||= ::CacheMethod.method_signature(obj, method_id)
     end
     
-    def obj_hash
-      @obj_hash ||= obj.respond_to?(:method_cache_hash) ? obj.method_cache_hash : obj.hash
+    def obj_digest
+      @obj_digest ||= ::Digest::SHA1.hexdigest(::Marshal.dump(obj.respond_to?(:as_cache_key) ? obj.as_cache_key : obj))
     end
     
     def cache_key
-      if obj.is_a? ::Class or obj.is_a? ::Module
+      if obj.is_a?(::Class) or obj.is_a?(::Module)
         [ 'CacheMethod', 'Generation', method_signature ].join ','
       else
-        [ 'CacheMethod', 'Generation', method_signature, obj_hash ].join ','
+        [ 'CacheMethod', 'Generation', method_signature, obj_digest ].join ','
       end
     end
     

data/lib/cache_method/version.rb

@@ -1,3 +1,3 @@
 module CacheMethod
-  VERSION = "0.1.6"
+  VERSION = "0.2.0"
 end

data/lib/cache_method.rb

@@ -1,10 +1,9 @@
-require 'cache_method/version'
+require 'cache_method/config'
+require 'cache_method/cached_result'
+require 'cache_method/generation'
+
 # See the README.rdoc for more info!
 module CacheMethod
-  autoload :Config, 'cache_method/config'
-  autoload :CachedResult, 'cache_method/cached_result'
-  autoload :Generation, 'cache_method/generation'
-
   def self.config #:nodoc:
     Config.instance
   end
@@ -21,19 +20,19 @@ module CacheMethod
     [ klass_name(obj), method_id ].join method_delimiter(obj)
   end
     
-  # All Objects, including instances and Classes, get the <tt>#clear_method_cache</tt> method.
+  # All Objects, including instances and Classes, get the <tt>#cache_method_clear</tt> method.
   module InstanceMethods
     # Clear the cache for a particular method.
     #
-    # Note: Remember to define <tt>#hash</tt> on any object whose instance methods might get cached.
+    # Note: Remember to define <tt>#as_cache_key</tt> on any object whose instance methods might get cached.
     #
     # Example:
-    #     my_blog.clear_method_cache :get_latest_entries
-    def clear_method_cache(method_id)
+    #     my_blog.cache_method_clear :get_latest_entries
+    def cache_method_clear(method_id)
       if ::CacheMethod.config.generational?
         ::CacheMethod::Generation.new(self, method_id).mark_passing
       else
-        raise ::RuntimeError, "[cache_method] clear_method_cache called, but you have disabled generational caching. Check your setting for CacheMethod.config.generational"
+        raise ::RuntimeError, "[cache_method] cache_method_clear called, but you have disabled generational caching. Check your setting for CacheMethod.config.generational"
       end
     end
   end
@@ -42,7 +41,7 @@ module CacheMethod
   module ClassMethods
     # Cache a method. TTL in seconds, defaults to whatever's in CacheMethod.config.default_ttl
     #
-    # Note: Remember to define <tt>#hash</tt> on any object whose instance methods might get cached.
+    # Note: Remember to define <tt>#as_cache_key</tt> on any object whose instance methods might get cached.
     #
     # Note 2: Check out CacheMethod.config.default_ttl... the default is 24 hours.
     #

data/test/helper.rb

@@ -25,30 +25,20 @@ class CopyCat1
   #        representation."
   def echo(*args)
     self.echo_count += 1
-    if RUBY_VERSION >= '1.9'
-      if args.empty?
-        return nil
-      elsif args.length == 1
-        return args[0]
-      else
-        return args
-      end
-    else
-      return *args
-    end
+    return *args
   end
-  def hash
-    raise "Used hash"
+  def marshal_dump
+    raise "Used marshal_dump"
   end
-  def method_cache_hash
-    name.hash
+  def as_cache_key
+    name
   end
   cache_method :echo
 end
 
 class CopyCat1a < CopyCat1
-  def method_cache_hash
-    raise "Used method_cache_hash"
+  def as_cache_key
+    raise "Used as_cache_key"
   end
 end
 
@@ -113,8 +103,8 @@ class Blog1
     ["voo vaa #{name}"]
   end
   cache_method :get_latest_entries2, 1 # second
-  def hash
-    { :name => name, :url => url }.hash
+  def as_cache_key
+    { :name => name, :url => url }
   end
 end
 def new_instance_of_my_blog
@@ -158,3 +148,9 @@ CopyCat1.extend Say
 CopyCat2.extend Say
 
 CopyCat1.send :include, Say
+
+class DontStringifyMe < Struct.new(:message)
+  def to_s
+    "Don't stringify me, read my message!"
+  end
+end

data/test/test_cache_method.rb

@@ -1,6 +1,6 @@
 require 'helper'
 
-require 'memcached'
+require 'dalli'
 
 class TestCacheMethod < Test::Unit::TestCase
   def setup
@@ -8,114 +8,178 @@ class TestCacheMethod < Test::Unit::TestCase
     CopyCat2.echo_count = 0
     CopyCat1.say_count = 0
     CopyCat2.say_count = 0
-    my_cache = Memcached.new '127.0.0.1:11211', :binary => true
+    my_cache = Dalli::Client.new '127.0.0.1:11211'
     my_cache.flush
     CacheMethod.config.storage = my_cache
     CacheMethod.config.generational = true
   end
-  
+
   def test_cache_instance_method_with_args
     a = CopyCat1.new 'mimo'
-    
-    assert_equal 'hi', a.echo('hi')
-    assert_equal 1, a.echo_count
-    
-    assert_equal 'hi', a.echo('hi')
-    assert_equal 1, a.echo_count
+
+    if RUBY_VERSION >= '1.9'
+      assert_equal ['hi'], a.echo('hi')
+      assert_equal 1, a.echo_count
+
+      assert_equal ['hi'], a.echo('hi')
+      assert_equal 1, a.echo_count
+    else
+      assert_equal 'hi', a.echo('hi')
+      assert_equal 1, a.echo_count
+
+      assert_equal 'hi', a.echo('hi')
+      assert_equal 1, a.echo_count
+    end
   end
-  
+
   def test_cache_instance_method_with_nil_args
     a = CopyCat1.new 'mimo'
-    assert_equal nil, a.echo
-    assert_equal 1, a.echo_count
-    
-    assert_equal nil, a.echo
-    assert_equal 1, a.echo_count
-    
-    assert_equal nil, a.echo(nil)
-    assert_equal 2, a.echo_count
-  
-    assert_equal nil, a.echo(nil)
-    assert_equal 2, a.echo_count    
+
+    if RUBY_VERSION >= '1.9'
+      assert_equal [], a.echo
+      assert_equal 1, a.echo_count
+
+      assert_equal [], a.echo
+      assert_equal 1, a.echo_count
+
+      assert_equal [nil], a.echo(nil)
+      assert_equal 2, a.echo_count
+
+      assert_equal [nil], a.echo(nil)
+      assert_equal 2, a.echo_count
+    else
+      assert_equal nil, a.echo
+      assert_equal 1, a.echo_count
+
+      assert_equal nil, a.echo
+      assert_equal 1, a.echo_count
+
+      assert_equal nil, a.echo(nil)
+      assert_equal 2, a.echo_count
+
+      assert_equal nil, a.echo(nil)
+      assert_equal 2, a.echo_count
+    end
   end
-  
+
   def test_cache_instance_method_with_array_args
     a = CopyCat1.new 'mimo'
-    
-    assert_equal ['hi'], a.echo(['hi'])
-    assert_equal 1, a.echo_count
-    
-    assert_equal ['hi'], a.echo(['hi'])
-    assert_equal 1, a.echo_count
-    
-    assert_equal ['bye'], a.echo(['bye'])
-    assert_equal 2, a.echo_count
-    
-    assert_equal ['bye'], a.echo(['bye'])
-    assert_equal 2, a.echo_count
-    
-    assert_equal ['hi', 'there'], a.echo(['hi', 'there'])
-    assert_equal 3, a.echo_count
-    
-    # same as previous
-    assert_equal ['hi', 'there'], a.echo('hi', 'there')
-    assert_equal 3, a.echo_count
-    
-    assert_equal [], a.echo([])
-    assert_equal 4, a.echo_count
-    
-    assert_equal [], a.echo([])
-    assert_equal 4, a.echo_count
+
+    if RUBY_VERSION >= '1.9'
+      assert_equal [['hi']], a.echo(['hi'])
+      assert_equal 1, a.echo_count
+
+      assert_equal [['hi']], a.echo(['hi'])
+      assert_equal 1, a.echo_count
+
+      assert_equal [['bye']], a.echo(['bye'])
+      assert_equal 2, a.echo_count
+
+      assert_equal [['bye']], a.echo(['bye'])
+      assert_equal 2, a.echo_count
+
+      assert_equal [[]], a.echo([])
+      assert_equal 3, a.echo_count
+
+      assert_equal [[]], a.echo([])
+      assert_equal 3, a.echo_count
+    else
+      assert_equal ['hi'], a.echo(['hi'])
+      assert_equal 1, a.echo_count
+
+      assert_equal ['hi'], a.echo(['hi'])
+      assert_equal 1, a.echo_count
+
+      assert_equal ['bye'], a.echo(['bye'])
+      assert_equal 2, a.echo_count
+
+      assert_equal ['bye'], a.echo(['bye'])
+      assert_equal 2, a.echo_count
+
+      assert_equal [], a.echo([])
+      assert_equal 3, a.echo_count
+
+      assert_equal [], a.echo([])
+      assert_equal 3, a.echo_count
+    end
   end
-  
+
+  def test_cache_instance_method_with_array_args_splat
+    a = CopyCat1.new 'mimo'
+
+    if RUBY_VERSION >= '1.9'
+      assert_equal [['hi', 'there']], a.echo(['hi', 'there'])
+      assert_equal 1, a.echo_count
+
+      assert_equal ['hi', 'there'], a.echo('hi', 'there')
+      assert_equal 2, a.echo_count
+    else
+      assert_equal ['hi', 'there'], a.echo(['hi', 'there'])
+      assert_equal 1, a.echo_count
+
+      assert_equal ['hi', 'there'], a.echo('hi', 'there')
+      assert_equal 2, a.echo_count
+    end
+  end
+
   def test_cache_class_method_with_args
     assert_equal 'hi', CopyCat2.echo('hi')
     assert_equal 1, CopyCat2.echo_count
-    
+
     assert_equal 'hi', CopyCat2.echo('hi')
     assert_equal 1, CopyCat2.echo_count
   end
-  
+
   def test_cache_class_method_with_nil_args
     assert_equal nil, CopyCat2.echo
     assert_equal 1, CopyCat2.echo_count
-    
+
     assert_equal nil, CopyCat2.echo
     assert_equal 1, CopyCat2.echo_count
-    
+
     assert_equal nil, CopyCat2.echo(nil)
     assert_equal 2, CopyCat2.echo_count
-  
+
     assert_equal nil, CopyCat2.echo(nil)
-    assert_equal 2, CopyCat2.echo_count    
+    assert_equal 2, CopyCat2.echo_count
   end
-  
+
   def test_cache_class_method_with_array_args
     assert_equal ['hi'], CopyCat2.echo(['hi'])
     assert_equal 1, CopyCat2.echo_count
-    
+
     assert_equal ['hi'], CopyCat2.echo(['hi'])
     assert_equal 1, CopyCat2.echo_count
-    
+
     assert_equal ['bye'], CopyCat2.echo(['bye'])
     assert_equal 2, CopyCat2.echo_count
-    
+
     assert_equal ['bye'], CopyCat2.echo(['bye'])
     assert_equal 2, CopyCat2.echo_count
-    
-    assert_equal ['hi', 'there'], CopyCat2.echo(['hi', 'there'])
-    assert_equal 3, CopyCat2.echo_count
-    
-    assert_equal ['hi', 'there'], CopyCat2.echo('hi', 'there')
-    assert_equal 3, CopyCat2.echo_count
-    
+
     assert_equal [], CopyCat2.echo([])
-    assert_equal 4, CopyCat2.echo_count
-    
+    assert_equal 3, CopyCat2.echo_count
+
     assert_equal [], CopyCat2.echo([])
-    assert_equal 4, CopyCat2.echo_count
+    assert_equal 3, CopyCat2.echo_count
+  end
+
+  def test_cache_class_method_with_array_args_splat
+    if RUBY_VERSION >= '1.9'
+      assert_equal ['hi', 'there'], CopyCat2.echo(['hi', 'there'])
+      assert_equal 1, CopyCat2.echo_count
+
+      assert_equal ['hi', 'there'], CopyCat2.echo('hi', 'there')
+      assert_equal 2, CopyCat2.echo_count
+    else
+      assert_equal ['hi', 'there'], CopyCat2.echo(['hi', 'there'])
+      assert_equal 1, CopyCat2.echo_count
+
+      assert_equal ['hi', 'there'], CopyCat2.echo('hi', 'there')
+      assert_equal 2, CopyCat2.echo_count
+    end
   end
-    
+
   def test_cache_instance_method
     a = new_instance_of_my_blog
     assert_equal ["hello from #{a.name}"], a.get_latest_entries
@@ -127,25 +191,25 @@ class TestCacheMethod < Test::Unit::TestCase
     assert_equal ["hello from #{xxx.name}"], xxx.get_latest_entries
     assert_equal 1, xxx.request_count
   end
-  
+
   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
-    a.clear_method_cache :get_latest_entries
+    a.cache_method_clear :get_latest_entries
     assert_equal ["hello from #{a.name}"], a.get_latest_entries
     assert_equal 2, a.request_count
   end
-  
+
   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
-    a.clear_method_cache :foobar
+    a.cache_method_clear :foobar
     assert_equal ["hello from #{a.name}"], a.get_latest_entries
     assert_equal 1, a.request_count
   end
-    
+
   def test_clear_instance_method_from_correct_instance
     a = new_instance_of_my_blog
     assert_equal ["hello from #{a.name}"], a.get_latest_entries
@@ -153,13 +217,13 @@ class TestCacheMethod < Test::Unit::TestCase
     xxx = new_instance_of_another_blog
     assert_equal ["hello from #{xxx.name}"], xxx.get_latest_entries
     assert_equal 1, xxx.request_count
-    xxx.clear_method_cache :get_latest_entries
+    xxx.cache_method_clear :get_latest_entries
     assert_equal ["hello from #{a.name}"], a.get_latest_entries
     assert_equal 1, a.request_count
     assert_equal ["hello from #{xxx.name}"], xxx.get_latest_entries
     assert_equal 2, xxx.request_count
   end
-  
+
   def test_cache_instance_method_ttl
     a = new_instance_of_my_blog
     assert_equal ["voo vaa #{a.name}"], a.get_latest_entries2
@@ -168,7 +232,7 @@ class TestCacheMethod < Test::Unit::TestCase
     assert_equal ["voo vaa #{a.name}"], a.get_latest_entries2
     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
@@ -176,52 +240,68 @@ class TestCacheMethod < Test::Unit::TestCase
     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
+    Blog2.cache_method_clear :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
+
+    Blog2.cache_method_clear :foobar
     assert_equal 'danke schoen', Blog2.get_latest_entries
     assert_equal 1, Blog2.request_count
-    
-    Blog2.clear_method_cache :get_latest_entries
+
+    Blog2.cache_method_clear :get_latest_entries
     assert_equal 'danke schoen', Blog2.get_latest_entries
     assert_equal 2, Blog2.request_count
   end
-  
+
   def test_never_set_storage
     CacheMethod.config.instance_variable_set :@storage, nil
     a = CopyCat1.new 'mimo'
-    
-    assert_equal 'hi', a.echo('hi')
-    assert_equal 1, a.echo_count
-    
-    assert_equal 'hi', a.echo('hi')
-    assert_equal 1, a.echo_count
+
+    if RUBY_VERSION >= '1.9'
+      assert_equal ['hi'], a.echo('hi')
+      assert_equal 1, a.echo_count
+
+      assert_equal ['hi'], a.echo('hi')
+      assert_equal 1, a.echo_count
+    else
+      assert_equal 'hi', a.echo('hi')
+      assert_equal 1, a.echo_count
+
+      assert_equal 'hi', a.echo('hi')
+      assert_equal 1, a.echo_count
+    end
   end
-  
+
   def test_set_storage_to_nil
     CacheMethod.config.storage = nil
     a = CopyCat1.new 'mimo'
-    
-    assert_equal 'hi', a.echo('hi')
-    assert_equal 1, a.echo_count
-    
-    assert_equal 'hi', a.echo('hi')
-    assert_equal 1, a.echo_count
+
+    if RUBY_VERSION >= '1.9'
+      assert_equal ['hi'], a.echo('hi')
+      assert_equal 1, a.echo_count
+
+      assert_equal ['hi'], a.echo('hi')
+      assert_equal 1, a.echo_count
+    else
+      assert_equal 'hi', a.echo('hi')
+      assert_equal 1, a.echo_count
+
+      assert_equal 'hi', a.echo('hi')
+      assert_equal 1, a.echo_count
+    end
   end
-  
+
   def test_cache_module_method
     assert_equal 0, BlogM.request_count
     assert_equal 'danke schoen', BlogM.get_latest_entries
@@ -229,14 +309,14 @@ class TestCacheMethod < Test::Unit::TestCase
     assert_equal 'danke schoen', BlogM.get_latest_entries
     assert_equal 1, BlogM.request_count
   end
-  
-  def test_method_cache_hash
-    assert_raises(RuntimeError, /Used method_cache_hash/) do
+
+  def test_as_cache_key
+    assert_raises(RuntimeError, /Used as_cache_key/) do
       a = CopyCat1a.new 'mimo'
       a.echo 'hi'
     end
   end
-  
+
   def test_method_added_by_extension
     assert_equal 'hi', CopyCat2.say('hi')
     assert_equal 1, CopyCat2.say_count
@@ -244,17 +324,17 @@ class TestCacheMethod < Test::Unit::TestCase
     assert_equal 'hi', CopyCat2.say('hi')
     assert_equal 1, CopyCat2.say_count
   end
-  
+
   def test_method_added_by_inclusion
     a = CopyCat1.new 'sayer'
 
     assert_equal 'hi', a.say('hi')
     assert_equal 1, a.say_count
-    
+
     assert_equal 'hi', a.say('hi')
     assert_equal 1, a.say_count
   end
-  
+
   def test_not_confused_by_module
     assert_equal 'hi', CopyCat2.say('hi')
     assert_equal 1, CopyCat2.say_count
@@ -268,31 +348,58 @@ class TestCacheMethod < Test::Unit::TestCase
     assert_equal 'hi', CopyCat1.say('hi')
     assert_equal 1, CopyCat1.say_count
   end
-  
+
   def test_disable_generational_caching
     CacheMethod.config.generational = false
-    
+
     a = CopyCat1.new 'mimo'
-    
-    assert_equal 'hi', a.echo('hi')
-    assert_equal 1, a.echo_count
-    
-    assert_equal 'hi', a.echo('hi')
-    assert_equal 1, a.echo_count
+
+    if RUBY_VERSION >= '1.9'
+      assert_equal ['hi'], a.echo('hi')
+      assert_equal 1, a.echo_count
+
+      assert_equal ['hi'], a.echo('hi')
+      assert_equal 1, a.echo_count
+    else
+      assert_equal 'hi', a.echo('hi')
+      assert_equal 1, a.echo_count
+
+      assert_equal 'hi', a.echo('hi')
+      assert_equal 1, a.echo_count
+    end
   end
-  
-  def test_cant_clear_method_cache_without_generational_caching
+
+  def test_cant_cache_method_clear_without_generational_caching
     CacheMethod.config.generational = false
 
     a = new_instance_of_my_blog
     assert_equal ["hello from #{a.name}"], a.get_latest_entries
     assert_equal 1, a.request_count
-    
+
     assert_raises(::RuntimeError) do
-      a.clear_method_cache :get_latest_entries
+      a.cache_method_clear :get_latest_entries
     end
-    
+
     assert_equal ["hello from #{a.name}"], a.get_latest_entries
     assert_equal 1, a.request_count
   end
+
+  def test_doesnt_rely_on_to_s_for_args_digest
+    hello = DontStringifyMe.new("hello")
+    world = DontStringifyMe.new("world")
+
+    a = CopyCat1.new 'mimo'
+
+    a.echo(hello)
+    assert_equal 1, a.echo_count
+
+    a.echo(hello)
+    assert_equal 1, a.echo_count
+
+    a.echo(world)
+    assert_equal 2, a.echo_count
+
+    a.echo(world)
+    assert_equal 2, a.echo_count
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cache_method
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-17 00:00:00.000000000Z
+date: 2012-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cache
-  requirement: &2155074680 !ruby/object:Gem::Requirement
+  requirement: &2156275580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,29 +21,7 @@ dependencies:
         version: 0.2.1
   type: :runtime
   prerelease: false
-  version_requirements: *2155074680
-- !ruby/object:Gem::Dependency
-  name: memcached
-  requirement: &2155073740 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *2155073740
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: &2155072900 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *2155072900
+  version_requirements: *2156275580
 description: Like alias_method, but it's cache_method!
 email:
 - seamus@abshere.net
@@ -52,8 +30,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- CHANGELOG
 - Gemfile
-- README.rdoc
+- README.markdown
 - Rakefile
 - cache_method.gemspec
 - lib/cache_method.rb
@@ -83,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: cache_method
-rubygems_version: 1.8.11
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Lets you cache methods (to memcached, redis, etc.) sort of like you can memoize
@@ -91,3 +70,4 @@ summary: Lets you cache methods (to memcached, redis, etc.) sort of like you can
 test_files:
 - test/helper.rb
 - test/test_cache_method.rb
+has_rdoc: