cache 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+secret.sh
+rdoc/*

data/Gemfile

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

data/README.rdoc

@@ -0,0 +1,56 @@
+= cache
+
+A unified cache handling interface, inspired (but simpler than) Perl's Cache::Cache[http://cpan.uwinnipeg.ca/module/Cache::Cache] and CHI[http://cpan.uwinnipeg.ca/module/CHI].
+
+== Methods
+
+* get
+* set
+* delete
+* flush
+
+== Supported clients
+
+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]
+
+== Configuration
+
+You set your preferred cache client:
+
+    Cache.config.client = Memcached.new '127.0.0.1:11211'
+
+or
+
+    Cache.config.client = Redis.new
+
+or this might even work...
+
+    Cache.config.client = Rails.cache
+
+== TTL
+
+0 means don't expire.
+
+== Rationale
+
+* I am so tired of rescuing from Memcached::NotFound
+* I am so tired of forgetting whether it's :expires_in or :ttl
+* I don't know why we ever started using read/write instead of get/set.
+
+== Currently unsupported
+
+* cas
+* fetch
+* incr
+
+== 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 #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/cache.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cache/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cache"
+  s.version     = Cache::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Seamus Abshere"]
+  s.email       = ["seamus@abshere.net"]
+  s.homepage    = "https://github.com/seamusabshere/cache"
+  s.summary     = %q{Wraps memcached, redis, memcache-client, dalli and handles their weirdnesses, including forking}
+  s.description = %q{A unified cache handling interface for Ruby, inspired by (but simpler than) Perl's Cache::Cache}
+
+  s.rubyforge_project = "cache"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_development_dependency 'test-unit'
+  s.add_development_dependency 'redis'
+  s.add_development_dependency 'dalli'
+  s.add_development_dependency 'activesupport', '>=2.3.4' # for DalliStore
+  s.add_development_dependency 'i18n' # activesupport
+  s.add_development_dependency 'memcached'
+  s.add_development_dependency 'memcache-client'
+end

data/lib/cache.rb

@@ -0,0 +1,42 @@
+require 'cache/version'
+module Cache
+  autoload :Config, 'cache/config'
+  autoload :Storage, 'cache/storage'
+  
+  def self.config #:nodoc:
+    Config.instance
+  end
+
+  # Get a value.
+  #
+  # Example:
+  #     Cache.get 'hello'
+  def self.get(k)
+    Storage.instance.get k
+  end
+  
+  # Store a value. Note that this will Marshal it.
+  #
+  # Example:
+  #     Cache.set 'hello', 'world'
+  #     Cache.set 'hello', 'world', 80 # seconds til it expires
+  def self.set(k, v, ttl = nil)
+    Storage.instance.set k, v, ttl
+  end
+  
+  # Delete a value.
+  #
+  # Example:
+  #     Cache.delete 'hello'
+  def self.delete(k)
+    Storage.instance.delete k
+  end
+  
+  # Flush the cache.
+  #
+  # Example:
+  #     Cache.flush
+  def self.flush
+    Storage.instance.flush
+  end
+end

data/lib/cache/config.rb

@@ -0,0 +1,45 @@
+require 'singleton'
+module Cache
+  # Here's where you set config options.
+  #
+  # Example:
+  #     Cache.config.client = Memcached.new '127.0.0.1:11211'
+  #     Cache.config.default_ttl = 120 # seconds
+  #
+  # You'd probably put this in your Rails config/initializers, for example.
+  class Config
+    include ::Singleton
+    
+    # The cache client to use.
+    #
+    # 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]
+    #
+    # Example:
+    #     Cache.config.storage = Memcached.new '127.0.0.1:11211'
+    def client=(client)
+      @client = client
+    end
+
+    def client #:nodoc:
+      @client 
+    end
+    
+    # TTL for method caches. Defaults to 60 seconds.
+    #
+    # Example:
+    #     Cache.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/storage.rb

@@ -0,0 +1,90 @@
+require 'singleton'
+module Cache
+  class Storage #:nodoc: all
+    include ::Singleton
+        
+    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) and cached_v.is_a?(::String)
+          ::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} because it doesn't define get"
+      end
+    end
+        
+    def set(k, v, ttl)
+      ttl ||= Config.instance.default_ttl
+      if defined?(::Redis) and bare_client.is_a?(::Redis)
+        if ttl == 0
+          bare_client.set k, ::Marshal.dump(v)
+        else
+          bare_client.setex k, ttl, ::Marshal.dump(v)
+        end
+      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} because it doesn't define set"
+      end
+    end
+    
+    def delete(k)
+      if defined?(::Memcached) and bare_client.is_a?(::Memcached)
+        begin; bare_client.delete(k); rescue ::Memcached::NotFound; nil; end
+      elsif defined?(::Redis) and bare_client.is_a?(::Redis)
+        bare_client.del k
+      elsif bare_client.respond_to?(:delete)
+        bare_client.delete k
+      else
+        raise "Don't know how to work with #{bare_client.inspect} because it doesn't define delete"
+      end
+    end
+    
+    def flush
+      bare_client.send %w{ flush flushdb flush_all clear }.detect { |flush_cmd| bare_client.respond_to? flush_cmd }
+    end
+    
+    def bare_client
+      if @pid == ::Process.pid
+        fork_detected = false
+      else
+        fork_detected = true
+        ::Thread.current[:cache_storage_bare_client] = nil
+        @pid = ::Process.pid
+      end
+      ::Thread.current[:cache_storage_bare_client] ||= fresh_bare_client(fork_detected)
+    end
+    
+    def fresh_bare_client(fork_detected)
+      if defined?(::Dalli) and Config.instance.client.is_a?(::Dalli::Client)
+        Config.instance.client.close if fork_detected
+        Config.instance.client
+      elsif defined?(::ActiveSupport::Cache::DalliStore) and Config.instance.client.is_a?(::ActiveSupport::Cache::DalliStore)
+        Config.instance.client.reset if fork_detected
+        Config.instance.client
+      elsif defined?(::Memcached) and (Config.instance.client.is_a?(::Memcached) or Config.instance.client.is_a?(::Memcached::Rails))
+        Config.instance.client.clone
+      elsif defined?(::Redis) and Config.instance.client.is_a?(::Redis)
+        Config.instance.client.client.connect if fork_detected
+        Config.instance.client
+      elsif defined?(::MemCache) and Config.instance.client.is_a?(::MemCache)
+        Config.instance.client.reset if fork_detected
+        Config.instance.client
+      else
+        raise "Don't know how to thread/fork #{Config.instance.client.inspect}"
+      end
+    end
+  end
+end

data/lib/cache/version.rb

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

data/test/helper.rb

@@ -0,0 +1,13 @@
+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'
+
+require 'shared_tests'
+
+class Test::Unit::TestCase
+end

data/test/shared_tests.rb

@@ -0,0 +1,41 @@
+module SharedTests
+  def test_get
+    assert_equal nil, Cache.get('hello')
+    Cache.set 'hello', 'world'
+    assert_equal 'world', Cache.get('hello')
+  end
+  
+  def test_set
+    assert_nothing_raised do
+      Cache.set 'hello', 'world'
+    end
+  end
+  
+  def test_set_with_ttl
+    Cache.set 'hello', 'world', 1
+    assert_equal 'world', Cache.get('hello')
+    sleep 2
+    assert_equal nil, Cache.get('hello')
+  end
+  
+  def test_set_with_zero_ttl_meaning_eternal
+    Cache.set 'hello', 'world', 0
+    assert_equal 'world', Cache.get('hello')
+    sleep 1
+    assert_equal 'world', Cache.get('hello')
+  end
+  
+  def test_delete
+    Cache.set 'hello', 'world'
+    assert_equal 'world', Cache.get('hello')
+    Cache.delete 'hello'
+    assert_equal nil, Cache.get('hello')
+  end
+  
+  def test_flush
+    Cache.set 'hello', 'world'
+    assert_equal 'world', Cache.get('hello')
+    Cache.flush
+    assert_equal nil, Cache.get('hello')
+  end
+end

data/test/test_dalli_storage.rb

@@ -0,0 +1,58 @@
+require 'helper'
+
+require 'dalli'
+
+class TestDalliStorage < Test::Unit::TestCase
+  def setup
+    super
+    client = Dalli::Client.new ['localhost:11211']
+    client.flush
+    Cache.config.client = client
+  end
+    
+  include SharedTests
+  
+  def get_ring_object_id
+    Cache.config.client.instance_variable_get(:@ring).object_id
+  end
+  
+  def test_treats_as_thread_safe
+    # make sure ring is initialized
+    Cache.get 'hi'
+    
+    # get the main thread's ring
+    main_thread_ring_id = get_ring_object_id
+    
+    # sanity check that it's not changing every time
+    Cache.get 'hi'
+    assert_equal main_thread_ring_id, get_ring_object_id
+    
+    # create a new thread and get its ring
+    new_thread_ring_id = Thread.new { Cache.get 'hi'; get_ring_object_id }.value
+    
+    # make sure the ring was reinitialized
+    assert_equal main_thread_ring_id, new_thread_ring_id
+  end
+  
+  def test_treats_as_not_fork_safe
+    # make sure ring is initialized
+    Cache.get 'hi'
+    
+    # get the main thread's ring
+    parent_process_ring_id = get_ring_object_id
+    
+    # sanity check that it's not changing every time
+    Cache.get 'hi'
+    assert_equal parent_process_ring_id, get_ring_object_id
+    
+    # fork a new process
+    pid = Kernel.fork do
+      Cache.get 'hi'
+      raise "Didn't split!" if parent_process_ring_id == get_ring_object_id
+    end
+    Process.wait pid
+    
+    # make sure it didn't raise
+    assert $?.success?
+  end
+end

data/test/test_dalli_store_storage.rb

@@ -0,0 +1,61 @@
+require 'helper'
+
+require 'dalli'
+require 'active_support/all'
+require 'active_support/cache/dalli_store'
+
+class TestDalliStoreStorage < Test::Unit::TestCase
+  def setup
+    super
+    client = ActiveSupport::Cache::DalliStore.new ['localhost:11211']
+    client.clear
+    Cache.config.client = client
+  end
+    
+  include SharedTests
+  
+  def get_ring_object_id
+    hidden_dalli_client = Cache.config.client.instance_variable_get :@data
+    hidden_dalli_client.instance_variable_get(:@ring).object_id
+  end
+  
+  def test_treats_as_thread_safe
+    # make sure ring is initialized
+    Cache.get 'hi'
+    
+    # get the main thread's ring
+    main_thread_ring_id = get_ring_object_id
+    
+    # sanity check that it's not changing every time
+    Cache.get 'hi'
+    assert_equal main_thread_ring_id, get_ring_object_id
+    
+    # create a new thread and get its ring
+    new_thread_ring_id = Thread.new { Cache.get 'hi'; get_ring_object_id }.value
+    
+    # make sure the ring was reinitialized
+    assert_equal main_thread_ring_id, new_thread_ring_id
+  end
+  
+  def test_treats_as_not_fork_safe
+    # make sure ring is initialized
+    Cache.get 'hi'
+    
+    # get the main thread's ring
+    parent_process_ring_id = get_ring_object_id
+    
+    # sanity check that it's not changing every time
+    Cache.get 'hi'
+    assert_equal parent_process_ring_id, get_ring_object_id
+    
+    # fork a new process
+    pid = Kernel.fork do
+      Cache.get 'hi'
+      raise "Didn't split!" if parent_process_ring_id == get_ring_object_id
+    end
+    Process.wait pid
+    
+    # make sure it didn't raise
+    assert $?.success?
+  end
+end

data/test/test_memcache_storage.rb

@@ -0,0 +1,59 @@
+require 'helper'
+
+# the famous memcache-client
+require 'memcache'
+
+class TestMemcacheStorage < Test::Unit::TestCase
+  def setup
+    super
+    client = MemCache.new ['localhost:11211']
+    client.flush_all
+    Cache.config.client = client
+  end
+    
+  include SharedTests
+  
+  def get_server_status_ids
+    Cache.config.client.instance_variable_get(:@servers).map { |s| s.status.object_id }
+  end
+  
+  def test_treats_as_thread_safe
+    # make sure servers are connected
+    Cache.get 'hi'
+    
+    # get the object ids
+    main_thread_server_status_ids = get_server_status_ids
+    
+    # sanity check that it's not changing every time
+    Cache.get 'hi'
+    assert_equal main_thread_server_status_ids, get_server_status_ids
+    
+    # create a new thread and get its server ids
+    new_thread_server_status_ids = Thread.new { Cache.get 'hi'; get_server_status_ids }.value
+    
+    # make sure the server ids was reinitialized
+    assert_equal main_thread_server_status_ids, new_thread_server_status_ids
+  end
+  
+  def test_treats_as_not_fork_safe
+    # make sure server ids is initialized
+    Cache.get 'hi'
+    
+    # get the main thread's server ids
+    parent_process_server_status_ids = get_server_status_ids
+    
+    # sanity check that it's not changing every time
+    Cache.get 'hi'
+    assert_equal parent_process_server_status_ids, get_server_status_ids
+    
+    # fork a new process
+    pid = Kernel.fork do
+      Cache.get 'hi'
+      raise "Didn't split!" if parent_process_server_status_ids == get_server_status_ids
+    end
+    Process.wait pid
+    
+    # make sure it didn't raise
+    assert $?.success?
+  end
+end

data/test/test_memcached_rails_storage.rb

@@ -0,0 +1,58 @@
+require 'helper'
+
+require 'memcached'
+
+class TestMemcachedRailsStorage < Test::Unit::TestCase
+  def setup
+    super
+    client = Memcached::Rails.new 'localhost:11211'
+    client.flush
+    Cache.config.client = client
+  end
+    
+  include SharedTests
+  
+  def get_bare_client_id
+    Cache::Storage.instance.bare_client.object_id
+  end
+  
+  def test_treats_as_not_thread_safe
+    # make sure bare client is initialized
+    Cache.get 'hi'
+    
+    # get the main thread's bare client
+    main_thread_bare_client_id = get_bare_client_id
+    
+    # sanity check that it's not changing every time
+    Cache.get 'hi'
+    assert_equal main_thread_bare_client_id, get_bare_client_id
+    
+    # create a new thread and get its bare client
+    new_thread_bare_client_id = Thread.new { Cache.get 'hi'; get_bare_client_id }.value
+    
+    # make sure the bare client was reinitialized
+    assert(main_thread_bare_client_id != new_thread_bare_client_id)
+  end
+  
+  def test_treats_as_not_fork_safe
+    # make sure bare client is initialized
+    Cache.get 'hi'
+    
+    # get the main process's bare client
+    parent_process_bare_client_id = get_bare_client_id
+    
+    # sanity check that it's not changing every time
+    Cache.get 'hi'
+    assert_equal parent_process_bare_client_id, get_bare_client_id
+    
+    # fork a new process
+    pid = Kernel.fork do
+      Cache.get 'hi'
+      raise "Didn't split!" if parent_process_bare_client_id == get_bare_client_id
+    end
+    Process.wait pid
+    
+    # make sure it didn't raise
+    assert $?.success?
+  end
+end

data/test/test_memcached_storage.rb

@@ -0,0 +1,58 @@
+require 'helper'
+
+require 'memcached'
+
+class TestMemcachedStorage < Test::Unit::TestCase
+  def setup
+    super
+    client = Memcached.new 'localhost:11211'
+    client.flush
+    Cache.config.client = client
+  end
+    
+  include SharedTests
+  
+  def get_bare_client_id
+    Cache::Storage.instance.bare_client.object_id
+  end
+  
+  def test_treats_as_not_thread_safe
+    # make sure bare client is initialized
+    Cache.get 'hi'
+    
+    # get the main thread's bare client
+    main_thread_bare_client_id = get_bare_client_id
+    
+    # sanity check that it's not changing every time
+    Cache.get 'hi'
+    assert_equal main_thread_bare_client_id, get_bare_client_id
+    
+    # create a new thread and get its bare client
+    new_thread_bare_client_id = Thread.new { Cache.get 'hi'; get_bare_client_id }.value
+    
+    # make sure the bare client was reinitialized
+    assert(main_thread_bare_client_id != new_thread_bare_client_id)
+  end
+  
+  def test_treats_as_not_fork_safe
+    # make sure bare client is initialized
+    Cache.get 'hi'
+    
+    # get the main process's bare client
+    parent_process_bare_client_id = get_bare_client_id
+    
+    # sanity check that it's not changing every time
+    Cache.get 'hi'
+    assert_equal parent_process_bare_client_id, get_bare_client_id
+    
+    # fork a new process
+    pid = Kernel.fork do
+      Cache.get 'hi'
+      raise "Didn't split!" if parent_process_bare_client_id == get_bare_client_id
+    end
+    Process.wait pid
+    
+    # make sure it didn't raise
+    assert $?.success?
+  end
+end

data/test/test_redis_storage.rb

@@ -0,0 +1,66 @@
+require 'helper'
+
+if ENV['REDIS_URL']
+  require 'redis'
+  require 'uri'
+
+  class TestRedisStorage < Test::Unit::TestCase
+    def setup
+      super
+      uri = URI.parse(ENV["REDIS_URL"])
+      client = Redis.new(:host => uri.host, :port => uri.port, :password => uri.password)
+      client.flushdb
+      Cache.config.client = client
+    end
+    
+    include SharedTests
+    
+    # client DOT client
+    def get_redis_client_connection_socket_id
+      connection = Cache.config.client.client.instance_variable_get :@connection
+      sock = connection.instance_variable_get(:@sock)
+      # $stderr.puts sock.inspect
+      sock.object_id
+    end
+    
+    def test_treats_as_thread_safe
+      # make sure ring is initialized
+      Cache.get 'hi'
+
+      # get the main thread's ring
+      main_thread_redis_client_connection_socket_id = get_redis_client_connection_socket_id
+
+      # sanity check that it's not changing every time
+      Cache.get 'hi'
+      assert_equal main_thread_redis_client_connection_socket_id, get_redis_client_connection_socket_id
+
+      # create a new thread and get its ring
+      new_thread_redis_client_connection_socket_id = Thread.new { Cache.get 'hi'; get_redis_client_connection_socket_id }.value
+
+      # make sure the ring was reinitialized
+      assert_equal main_thread_redis_client_connection_socket_id, new_thread_redis_client_connection_socket_id
+    end
+
+    def test_treats_as_not_fork_safe
+      # make sure ring is initialized
+      Cache.get 'hi'
+
+      # get the main thread's ring
+      parent_process_redis_client_connection_socket_id = get_redis_client_connection_socket_id
+
+      # sanity check that it's not changing every time
+      Cache.get 'hi'
+      assert_equal parent_process_redis_client_connection_socket_id, get_redis_client_connection_socket_id
+
+      # fork a new process
+      pid = Kernel.fork do
+        Cache.get 'hi'
+        raise "Didn't split!" if parent_process_redis_client_connection_socket_id == get_redis_client_connection_socket_id
+      end
+      Process.wait pid
+
+      # make sure it didn't raise
+      assert $?.success?
+    end
+  end
+end

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification 
+name: cache
+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-17 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  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: redis
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: dalli
+  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: activesupport
+  prerelease: false
+  requirement: &id004 !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: *id004
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  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: memcached
+  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: A unified cache handling interface for Ruby, inspired by (but simpler than) Perl's Cache::Cache
+email: 
+- seamus@abshere.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- cache.gemspec
+- lib/cache.rb
+- lib/cache/config.rb
+- lib/cache/storage.rb
+- lib/cache/version.rb
+- test/helper.rb
+- test/shared_tests.rb
+- test/test_dalli_storage.rb
+- test/test_dalli_store_storage.rb
+- test/test_memcache_storage.rb
+- test/test_memcached_rails_storage.rb
+- test/test_memcached_storage.rb
+- test/test_redis_storage.rb
+has_rdoc: true
+homepage: https://github.com/seamusabshere/cache
+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
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Wraps memcached, redis, memcache-client, dalli and handles their weirdnesses, including forking
+test_files: 
+- test/helper.rb
+- test/shared_tests.rb
+- test/test_dalli_storage.rb
+- test/test_dalli_store_storage.rb
+- test/test_memcache_storage.rb
+- test/test_memcached_rails_storage.rb
+- test/test_memcached_storage.rb
+- test/test_redis_storage.rb