cache_method 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+rdoc/*

data/DEVELOPER_NOTES.rdoc

@@ -0,0 +1,45 @@
+= 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/Gemfile

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

data/README.rdoc

@@ -0,0 +1,95 @@
+= cache_method
+
+It's like <tt>alias_method</tt>, but it's <tt>cache_method</tt>!
+
+== Example
+
+    require 'cache_method'
+    class Blog
+      attr_reader :name
+      attr_reader :url
+
+      def initialize(name, url)
+        @name = name
+        @url = url
+      end
+
+      # The method we're going to cache
+      def get_latest_entries
+        sleep 5
+      end
+      
+      # What you get with this gem
+      cache_method :get_latest_entries
+
+      # Per Ruby convention, a "hash code" representing the internal state of an instance.
+      # It's recommended that you construct a String or a Hash and then call #hash on it.
+      def hash
+        { :name => name, :url => url }.hash
+      end
+    end
+
+Then you can do
+
+    my_blog.get_latest_entries => first time won't be cached
+    my_blog.get_latest_entries => second time will come from cache
+
+And clear them too
+
+    my_blog.clear_method_cache :get_latest_entries
+
+(which doesn't delete the rest of your cache)
+
+== Configuration (and supported cache clients)
+
+You need to set a client that will be used to access the cache:
+
+    CacheMethod.config.client = Memcached.new '127.0.0.1:11211'
+
+or
+
+    CacheMethod.config.client = Redis.new
+
+or this might even work...
+
+    CacheMethod.config.client = Rails.cache
+
+See <tt>Config</tt> for the full list of supported caches.
+
+== Defining a #hash method (not the same as #to_hash)
+
+Since we're not pure functional programmers, sometimes cache hits depend on object state in addition to method arguments. To illustrate:
+
+    my_blog.get_latest_entries
+
+get_latest_entries doesn't take any arguments, so it must depend on my_blog.url or something. This works because we define:
+
+    class Blog
+      # [...]
+      def hash
+        { :name => name, :url => url }.hash
+      end
+      # [...]
+    end
+
+You should follow Ruby convention and have <tt>#hash</tt> return a <tt>Fixnum</tt>.
+
+Ideally, you should try to make a <tt>String</tt> or a <tt>Hash</tt> and call the standard <tt>#hash</tt> on that.
+
+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."
+
+== Rationale
+
+* It should be easy to cache a method using memcached.
+* The main clients should be supported
+  * memcache-client (for people who use the Rails default)
+  * dalli (for people on heroku)
+  * memcached (for people using Evan Weaver's ultra-fast gem)
+  * redis (for people who like that sort of thing, but you won't get expiration)
+* 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
+
+== Copyright
+
+Copyright 2011 Seamus Abshere

data/Rakefile

@@ -0,0 +1,22 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+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

data/cache_method.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+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    = ""
+  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.rubyforge_project = "cache_method"
+
+  s.files         = `git ls-files`.split("\n")
+  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_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
+  #   s.add_development_dependency 'ruby-debug'
+  # end
+end

data/lib/cache_method/cache/epoch.rb

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,65 @@
+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/lib/cache_method/config.rb

@@ -0,0 +1,45 @@
+require 'singleton'
+module CacheMethod
+  # Here's where you set config options.
+  #
+  # Example:
+  #     CacheMethod.config.client = 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.
+    #
+    # Supported memcached clients:
+    # * memcached[https://github.com/fauna/memcached] (either a Memcached or a Memcached::Rails)
+    # * dalli[https://github.com/mperham/dalli] (either a Dalli::Client or an ActiveSupport::Cache::DalliStore)
+    # * 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)
+    #
+    # Example:
+    #     CacheMethod.config.client = Memcached.new '127.0.0.1:11211'
+    def client=(client)
+      @client = client
+    end
+
+    def client #:nodoc:
+      @client || raise("You need to set CacheMethod.config.client with a cache client of your choice")
+    end
+    
+    # TTL for method caches. Defaults to 60 seconds.
+    #
+    # Example:
+    #     CacheMethod.config.default_ttl = 120 # seconds
+    def default_ttl=(seconds)
+      @default_ttl = seconds
+    end
+    
+    def default_ttl #:nodoc:
+      @default_ttl || 60
+    end
+  end
+end

data/lib/cache_method/version.rb

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

data/lib/cache_method.rb

@@ -0,0 +1,61 @@
+# See the README.rdoc for more info!
+module CacheMethod
+  autoload :Config, 'cache_method/config'
+  autoload :Cache, 'cache_method/cache'
+
+  def self.config #:nodoc:
+    Config.instance
+  end
+  
+  def self.cache #:nodoc:
+    Cache.instance
+  end
+  
+  # All Objects, including instances and Classes, get the <tt>#clear_method_cache</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.
+    #
+    # Example:
+    #     my_blog.clear_method_cache :get_latest_entries
+    def clear_method_cache(method_id)
+      ::CacheMethod.cache.delete self, method_id
+    end
+  end
+
+  # All Classes (but not instances), get the <tt>.cache_method</tt> method.
+  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 2: Check out CacheMethod.config.default_ttl... the default is only 60 seconds.
+    #
+    # Example:
+    #     class Blog
+    #       # [...]
+    #       def get_latest_entries
+    #         sleep 5
+    #       end
+    #       # [...]
+    #       cache_method :get_latest_entries
+    #       # if you wanted a different ttl...
+    #       # cache_method :get_latest_entries, 800 #seconds
+    #     end
+    def cache_method(method_id, ttl = nil)
+      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
+      end
+    end
+  end
+end
+
+unless ::Object.method_defined? :cache_method
+  ::Object.send :include, ::CacheMethod::InstanceMethods
+  ::Object.extend ::CacheMethod::ClassMethods
+end

data/test/helper.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+require 'test/unit'
+# require 'ruby-debug'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$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
+  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
+  end
+end
+
+$my_cache = random_cache
+CacheMethod.config.client = $my_cache

data/test/test_cache_class_methods.rb

@@ -0,0 +1,53 @@
+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

data/test/test_cache_instance_methods.rb

@@ -0,0 +1,90 @@
+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
+
+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'
+  end
+  
+  def test_cache_method
+    a = new_instance_of_my_blog
+    assert_equal ["hello from #{a.name}"], a.get_latest_entries
+    assert_equal 1, a.request_count
+    a = new_instance_of_my_blog
+    assert_equal ["hello from #{a.name}"], a.get_latest_entries
+    assert_equal 0, a.request_count
+    xxx = new_instance_of_another_blog
+    assert_equal ["hello from #{xxx.name}"], xxx.get_latest_entries
+    assert_equal 1, xxx.request_count
+  end
+  
+  def test_clear_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
+    assert_equal ["hello from #{a.name}"], a.get_latest_entries
+    assert_equal 2, a.request_count
+  end
+  
+  def test_clear_a_different_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
+    assert_equal ["hello from #{a.name}"], a.get_latest_entries
+    assert_equal 1, a.request_count
+  end
+    
+  def test_clear_from_somebody_else
+    a = new_instance_of_my_blog
+    assert_equal ["hello from #{a.name}"], a.get_latest_entries
+    assert_equal 1, a.request_count
+    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
+    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_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
+  end
+end

metadata

@@ -0,0 +1,183 @@
+--- !ruby/object:Gem::Specification 
+name: cache_method
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Seamus Abshere
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-15 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  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 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+description: Lets you cache methods (to memcached, redis, etc.) sort of like you can memoize them
+email: 
+- seamus@abshere.net
+executables: []
+
+extensions: []
+
+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/config.rb
+- lib/cache_method/version.rb
+- test/helper.rb
+- test/test_cache_class_methods.rb
+- test/test_cache_instance_methods.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: cache_method
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Provides cache_method
+test_files: 
+- test/helper.rb
+- test/test_cache_class_methods.rb
+- test/test_cache_instance_methods.rb