redis-rack-cache 0.0.0 → 1.1.rc

data/.gitignore

@@ -2,3 +2,4 @@
 .bundle
 Gemfile.lock
 pkg/*
+tmp/*

data/Gemfile

@@ -1,2 +1,4 @@
 source "http://rubygems.org"
 gemspec
+
+gem 'redis-store', '1.1.0.rc', :path => File.expand_path('../../redis-store', __FILE__)

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 - 2011 Luca Guidi
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,54 @@
+# Redis stores for Rack::Cache
+
+__`redis-rack-cache`__ provides a Redis backed store for __Rack::Cache__. It natively supports object marshalling, timeouts, single or multiple nodes and namespaces.
+
+## Redis Installation
+
+### Option 1: Homebrew
+
+MacOS X users should use [Homebrew](https://github.com/mxcl/homebrew) to install Redis:
+
+    brew install redis
+
+### Option 2: From Source
+
+Download and install Redis from [http://redis.io](http://redis.io/)
+
+	wget http://redis.googlecode.com/files/redis-2.4.5.tar.gz
+    tar -zxf redis-2.4.5.tar.gz
+    mv redis-2.4.5 redis
+    cd redis
+    make
+
+## Usage
+
+    # Gemfile
+	gem 'redis-rack-cache'
+
+### HTTP Cache Store:
+
+    # config.ru
+	require 'rack'
+	require 'rack/cache'
+	require 'redis-rack-cache'
+
+	use Rack::Cache,
+	  :metastore   => 'redis://localhost:6379/0/metastore',
+	  :entitystore => 'redis://localhost:6380/0/entitystore'
+
+#### Configuration
+
+For advanced configuration options, please check the [Redis Store Wiki](https://github.com/jodosha/redis-store/wiki).
+
+## Running tests
+
+    git clone git://github.com/jodosha/redis-store.git
+	cd redis-store/redis-rack-cache
+	gem install bundler --pre # required version: 1.1.rc
+	bundle exec rake
+
+If you are on **Snow Leopard** you have to run `env ARCHFLAGS="-arch x86_64" bundle exec rake`
+
+## Copyright
+
+(c) 2009 - 2011 Luca Guidi - [http://lucaguidi.com](http://lucaguidi.com), released under the MIT license

data/Rakefile

@@ -1 +1,13 @@
-require "bundler/gem_tasks"
+require 'bundler'
+Bundler.setup
+require 'rake'
+require 'bundler/gem_tasks'
+
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rake/rdoctask'
+end
+
+load 'tasks/redis.tasks.rb'
+task :default => 'redis:test:suite'

data/lib/rack/cache/redis_entitystore.rb

@@ -0,0 +1,55 @@
+require 'rack/cache/entitystore'
+
+module Rack
+  module Cache
+    class EntityStore
+      class RedisBase < self
+        # The underlying ::Redis instance used to communicate with the Redis daemon.
+        attr_reader :cache
+
+        extend Rack::Utils
+
+        def open(key)
+          data = read(key)
+          data && [data]
+        end
+
+        def self.resolve(uri)
+          new ::Redis::Factory.resolve(uri.to_s)
+        end
+      end
+
+      class Redis < RedisBase
+        def initialize(server, options = {})
+          @cache = ::Redis.new server
+        end
+
+        def exist?(key)
+          cache.exists key
+        end
+
+        def read(key)
+          cache.get key
+        end
+
+        def write(body, ttl=0)
+          buf = StringIO.new
+          key, size = slurp(body){|part| buf.write(part) }
+
+          if ttl.zero?
+            [key, size] if cache.set(key, buf.string)
+          else
+            [key, size] if cache.setex(key, ttl, buf.string)
+          end
+        end
+
+        def purge(key)
+          cache.del key
+          nil
+        end
+      end
+
+      REDIS = Redis
+    end
+  end
+end

data/lib/rack/cache/redis_metastore.rb

@@ -0,0 +1,45 @@
+require 'digest/sha1'
+require 'rack/utils'
+require 'rack/cache/key'
+require 'rack/cache/metastore'
+
+module Rack
+  module Cache
+    class MetaStore
+      class RedisBase < self
+        extend Rack::Utils
+
+        # The Redis::Store object used to communicate with the Redis daemon.
+        attr_reader :cache
+
+        def self.resolve(uri)
+          new ::Redis::Factory.resolve(uri.to_s)
+        end
+      end
+
+      class Redis < RedisBase
+        # The Redis instance used to communicated with the Redis daemon.
+        attr_reader :cache
+
+        def initialize(server, options = {})
+          @cache = ::Redis::Factory.create(server)
+        end
+
+        def read(key)
+          cache.get(hexdigest(key)) || []
+        end
+
+        def write(key, entries)
+          cache.set(hexdigest(key), entries)
+        end
+
+        def purge(key)
+          cache.del(hexdigest(key))
+          nil
+        end
+      end
+
+      REDIS = Redis
+    end
+  end
+end

data/lib/redis-rack-cache/version.rb

@@ -1,7 +1,7 @@
-module Redis
+class Redis
   module Rack
     module Cache
-      VERSION = "0.0.0"
+      VERSION = '1.1.rc'
     end
   end
 end

data/lib/redis-rack-cache.rb

@@ -1,9 +1,5 @@
-require "redis-rack-cache/version"
-
-module Redis
-  module Rack
-    module Cache
-      # Your code goes here...
-    end
-  end
-end
+require 'redis-store'
+require 'rack/cache'
+require 'rack/cache/redis_entitystore'
+require 'rack/cache/redis_metastore'
+require 'redis-rack-cache/version'

data/redis-rack-cache.gemspec

@@ -18,7 +18,12 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
-  # s.add_runtime_dependency "rest-client"
+  s.add_dependency 'redis-store', '1.1.0.rc'
+  s.add_dependency 'rack-cache',  '1.1'
+
+  s.add_development_dependency 'rake',      '~> 0.9.2.2'
+  s.add_development_dependency 'bundler',   '~> 1.1.rc'
+  s.add_development_dependency 'mocha',     '~> 0.10.0'
+  s.add_development_dependency 'minitest',  '~> 2.8.0'
+  s.add_development_dependency 'purdytest', '~> 1.0.0'
 end

data/test/rack/cache/entitystore/redis_test.rb

@@ -0,0 +1,121 @@
+require 'test_helper'
+
+class Object
+  def sha_like?
+    length == 40 && self =~ /^[0-9a-z]+$/
+  end
+end
+
+describe Rack::Cache::EntityStore::Redis do
+  before do
+    @store = ::Rack::Cache::EntityStore::Redis.new :host => 'localhost'
+  end
+
+  it 'has the class referenced by homonym constant' do
+    ::Rack::Cache::EntityStore::REDIS.must_equal(::Rack::Cache::EntityStore::Redis)
+  end
+
+  it 'resolves the connection uri' do
+    cache = ::Rack::Cache::EntityStore::Redis.resolve(uri("redis://127.0.0.1")).cache
+    cache.must_be_kind_of(::Redis)
+    cache.id.must_equal("redis://127.0.0.1:6379/0")
+
+    cache = ::Rack::Cache::EntityStore::Redis.resolve(uri("redis://127.0.0.1:6380")).cache
+    cache.id.must_equal("redis://127.0.0.1:6380/0")
+
+    cache = ::Rack::Cache::EntityStore::Redis.resolve(uri("redis://127.0.0.1/13")).cache
+    cache.id.must_equal("redis://127.0.0.1:6379/13")
+
+    cache = ::Rack::Cache::EntityStore::Redis.resolve(uri("redis://:secret@127.0.0.1")).cache
+    cache.id.must_equal("redis://127.0.0.1:6379/0")
+    cache.client.password.must_equal('secret')
+  end
+
+  it 'responds to all required messages' do
+    %w[read open write exist?].each do |message|
+      @store.must_respond_to message
+    end
+  end
+
+  it 'stores bodies with #write' do
+    key, size = @store.write(['My wild love went riding,'])
+    key.wont_be_nil
+    key.must_be :sha_like?
+
+    data = @store.read(key)
+    data.must_equal('My wild love went riding,')
+  end
+
+  it 'takes a ttl parameter for #write' do
+    key, size = @store.write(['My wild love went riding,'], 0)
+    key.wont_be_nil
+    key.must_be :sha_like?
+
+    data = @store.read(key)
+    data.must_equal('My wild love went riding,')
+  end
+
+  it 'correctly determines whether cached body exists for key with #exist?' do
+    key, size = @store.write(['She rode to the devil,'])
+    assert @store.exist?(key)
+    assert ! @store.exist?('938jasddj83jasdh4438021ksdfjsdfjsdsf')
+  end
+
+  it 'can read data written with #write' do
+    key, size = @store.write(['And asked him to pay.'])
+    data = @store.read(key)
+    data.must_equal('And asked him to pay.')
+  end
+
+  it 'gives a 40 character SHA1 hex digest from #write' do
+    key, size = @store.write(['she rode to the sea;'])
+    key.wont_be_nil
+    key.length.must_equal(40)
+    key.must_match(/^[0-9a-z]+$/)
+    key.must_equal('90a4c84d51a277f3dafc34693ca264531b9f51b6')
+  end
+
+  it 'returns the entire body as a String from #read' do
+    key, size = @store.write(['She gathered together'])
+    @store.read(key).must_equal('She gathered together')
+  end
+
+  it 'returns nil from #read when key does not exist' do
+    @store.read('87fe0a1ae82a518592f6b12b0183e950b4541c62').must_be_nil
+  end
+
+  it 'returns a Rack compatible body from #open' do
+    key, size = @store.write(['Some shells for her hair.'])
+    body = @store.open(key)
+    body.must_respond_to :each
+    buf = ''
+    body.each { |part| buf << part }
+    buf.must_equal('Some shells for her hair.')
+  end
+
+  it 'returns nil from #open when key does not exist' do
+    @store.open('87fe0a1ae82a518592f6b12b0183e950b4541c62').must_be_nil
+  end
+
+  if RUBY_VERSION < '1.9'
+    it 'can store largish bodies with binary data' do
+      pony = File.open(File.dirname(__FILE__) + '/pony.jpg', 'rb') { |f| f.read }
+      key, size = @store.write([pony])
+      key.must_equal('d0f30d8659b4d268c5c64385d9790024c2d78deb')
+      data = @store.read(key)
+      data.length.must_equal(pony.length)
+      data.hash.must_equal(pony.hash)
+    end
+  end
+
+  it 'deletes stored entries with #purge' do
+    key, size = @store.write(['My wild love went riding,'])
+    @store.purge(key).must_be_nil
+    @store.read(key).must_be_nil
+  end
+
+  private
+    define_method :uri do |uri|
+      URI.parse uri
+    end
+end

data/test/rack/cache/metastore/redis_test.rb

@@ -0,0 +1,266 @@
+require 'test_helper'
+
+describe Rack::Cache::MetaStore::Redis do
+  before do
+    @store        = ::Rack::Cache::MetaStore::Redis.resolve   uri('redis://127.0.0.1')
+    @entity_store = ::Rack::Cache::EntityStore::Redis.resolve uri('redis://127.0.0.1:6380')
+    @request  = mock_request('/', {})
+    @response = mock_response(200, {}, ['hello world'])
+  end
+
+  after do
+    @store.cache.flushall
+    @entity_store.cache.flushall
+  end
+
+  it "has the class referenced by homonym constant" do
+    ::Rack::Cache::MetaStore::REDIS.must_equal(::Rack::Cache::MetaStore::Redis)
+  end
+
+  it "instantiates the store" do
+    @store.must_be_kind_of(::Rack::Cache::MetaStore::Redis)
+  end
+
+  it "resolves the connection uri" do
+    cache = Rack::Cache::MetaStore::Redis.resolve(uri("redis://127.0.0.1")).cache
+    cache.must_be_kind_of(::Redis::Store)
+    cache.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0")
+
+    cache = Rack::Cache::MetaStore::Redis.resolve(uri("redis://127.0.0.1:6380")).cache
+    cache.to_s.must_equal("Redis Client connected to 127.0.0.1:6380 against DB 0")
+
+    cache = Rack::Cache::MetaStore::Redis.resolve(uri("redis://127.0.0.1/13")).cache
+    cache.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 13")
+
+    cache = Rack::Cache::MetaStore::Redis.resolve(uri("redis://:secret@127.0.0.1")).cache
+    cache.id.must_equal("redis://127.0.0.1:6379/0")
+    cache.client.password.must_equal('secret')
+  end
+
+  # Low-level implementation methods ===========================================
+
+  it 'writes a list of negotation tuples with #write' do
+    # lambda {
+      @store.write('/test', [[{}, {}]])
+    # }.wont_raise Exception
+  end
+
+  it 'reads a list of negotation tuples with #read' do
+    @store.write('/test', [[{},{}],[{},{}]])
+    tuples = @store.read('/test')
+    tuples.must_equal([ [{},{}], [{},{}] ])
+  end
+
+  it 'reads an empty list with #read when nothing cached at key' do
+    @store.read('/nothing').must_be_empty
+  end
+
+  it 'removes entries for key with #purge' do
+    @store.write('/test', [[{},{}]])
+    @store.read('/test').wont_be_empty
+
+    @store.purge('/test')
+    @store.read('/test').must_be_empty
+  end
+
+  it 'succeeds when purging non-existing entries' do
+    @store.read('/test').must_be_empty
+    @store.purge('/test')
+  end
+
+  it 'returns nil from #purge' do
+    @store.write('/test', [[{},{}]])
+    @store.purge('/test').must_be_nil
+    @store.read('/test').must_equal([])
+  end
+
+  %w[/test http://example.com:8080/ /test?x=y /test?x=y&p=q].each do |key|
+    it "can read and write key: '#{key}'" do
+      # lambda {
+        @store.write(key, [[{},{}]])
+      # }.wont_raise Exception
+      @store.read(key).must_equal([[{},{}]])
+    end
+  end
+
+  it "can read and write fairly large keys" do
+    key = "b" * 4096
+    # lambda {
+      @store.write(key, [[{},{}]])
+    # }.wont_raise Exception
+    @store.read(key).must_equal([[{},{}]])
+  end
+
+  it "allows custom cache keys from block" do
+    request = mock_request('/test', {})
+    request.env['rack-cache.cache_key'] =
+      lambda { |request| request.path_info.reverse }
+    @store.cache_key(request).must_equal('tset/')
+  end
+
+  it "allows custom cache keys from class" do
+    request = mock_request('/test', {})
+    request.env['rack-cache.cache_key'] = Class.new do
+      def self.call(request); request.path_info.reverse end
+    end
+    @store.cache_key(request).must_equal('tset/')
+  end
+
+  it 'does not blow up when given a non-marhsalable object with an ALL_CAPS key' do
+    store_simple_entry('/bad', { 'SOME_THING' => Proc.new {} })
+  end
+
+  # Abstract methods ===========================================================
+
+  it 'stores a cache entry' do
+    cache_key = store_simple_entry
+    @store.read(cache_key).wont_be_empty
+  end
+
+  it 'sets the X-Content-Digest response header before storing' do
+    cache_key = store_simple_entry
+    req, res = @store.read(cache_key).first
+    res['X-Content-Digest'].must_equal('a94a8fe5ccb19ba61c4c0873d391e987982fbbd3')
+  end
+
+  it 'finds a stored entry with #lookup' do
+    store_simple_entry
+    response = @store.lookup(@request, @entity_store)
+    response.wont_be_nil
+    response.must_be_kind_of(Rack::Cache::Response)
+  end
+
+  it 'does not find an entry with #lookup when none exists' do
+    req = mock_request('/test', {'HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'})
+    @store.lookup(req, @entity_store).must_be_nil
+  end
+
+  it "canonizes urls for cache keys" do
+    store_simple_entry(path='/test?x=y&p=q')
+
+    hits_req = mock_request(path, {})
+    miss_req = mock_request('/test?p=x', {})
+
+    @store.lookup(hits_req, @entity_store).wont_be_nil
+    @store.lookup(miss_req, @entity_store).must_be_nil
+  end
+
+  it 'does not find an entry with #lookup when the body does not exist' do
+    store_simple_entry
+    @response.headers['X-Content-Digest'].wont_be_nil
+    @entity_store.purge(@response.headers['X-Content-Digest'])
+    @store.lookup(@request, @entity_store).must_be_nil
+  end
+
+  it 'restores response headers properly with #lookup' do
+    store_simple_entry
+    response = @store.lookup(@request, @entity_store)
+    response.headers.
+      must_equal(@response.headers.merge('Content-Length' => '4'))
+  end
+
+  it 'restores response body from entity store with #lookup' do
+    store_simple_entry
+    response = @store.lookup(@request, @entity_store)
+    body = '' ; response.body.each {|p| body << p}
+    body.must_equal('test')
+  end
+
+  it 'invalidates meta and entity store entries with #invalidate' do
+    store_simple_entry
+    @store.invalidate(@request, @entity_store)
+    response = @store.lookup(@request, @entity_store)
+    response.must_be_kind_of(Rack::Cache::Response)
+    response.wont_be :fresh?
+  end
+
+  it 'succeeds quietly when #invalidate called with no matching entries' do
+    req = mock_request('/test', {})
+    @store.invalidate(req, @entity_store)
+    @store.lookup(@request, @entity_store).must_be_nil
+  end
+
+  # Vary =======================================================================
+
+  it 'does not return entries that Vary with #lookup' do
+    req1 = mock_request('/test', {'HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'})
+    req2 = mock_request('/test', {'HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'})
+    res = mock_response(200, {'Vary' => 'Foo Bar'}, ['test'])
+    @store.store(req1, res, @entity_store)
+
+    @store.lookup(req2, @entity_store).must_be_nil
+  end
+
+  it 'stores multiple responses for each Vary combination' do
+    req1 = mock_request('/test', {'HTTP_FOO' => 'Foo',   'HTTP_BAR' => 'Bar'})
+    res1 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 1'])
+    key = @store.store(req1, res1, @entity_store)
+
+    req2 = mock_request('/test', {'HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'})
+    res2 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 2'])
+    @store.store(req2, res2, @entity_store)
+
+    req3 = mock_request('/test', {'HTTP_FOO' => 'Baz',   'HTTP_BAR' => 'Boom'})
+    res3 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 3'])
+    @store.store(req3, res3, @entity_store)
+
+    slurp(@store.lookup(req3, @entity_store).body).must_equal('test 3')
+    slurp(@store.lookup(req1, @entity_store).body).must_equal('test 1')
+    slurp(@store.lookup(req2, @entity_store).body).must_equal('test 2')
+
+    @store.read(key).length.must_equal(3)
+  end
+
+  it 'overwrites non-varying responses with #store' do
+    req1 = mock_request('/test', {'HTTP_FOO' => 'Foo',   'HTTP_BAR' => 'Bar'})
+    res1 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 1'])
+    key = @store.store(req1, res1, @entity_store)
+    slurp(@store.lookup(req1, @entity_store).body).must_equal('test 1')
+
+    req2 = mock_request('/test', {'HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'})
+    res2 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 2'])
+    @store.store(req2, res2, @entity_store)
+    slurp(@store.lookup(req2, @entity_store).body).must_equal('test 2')
+
+    req3 = mock_request('/test', {'HTTP_FOO' => 'Foo',   'HTTP_BAR' => 'Bar'})
+    res3 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 3'])
+    @store.store(req3, res3, @entity_store)
+    slurp(@store.lookup(req1, @entity_store).body).must_equal('test 3')
+
+    @store.read(key).length.must_equal(2)
+  end
+
+  private
+    define_method :mock_request do |uri, opts|
+      env = Rack::MockRequest.env_for(uri, opts || {})
+      Rack::Cache::Request.new(env)
+    end
+
+    define_method :mock_response do |status, headers, body|
+      headers ||= {}
+      body = Array(body).compact
+      Rack::Cache::Response.new(status, headers, body)
+    end
+
+    define_method :slurp do |body|
+      buf = ''
+      body.each { |part| buf << part }
+      buf
+    end
+
+    # Stores an entry for the given request args, returns a url encoded cache key
+    # for the request.
+    define_method :store_simple_entry do |*request_args|
+      path, headers = request_args
+      @request = mock_request(path || '/test', headers || {})
+      @response = mock_response(200, {'Cache-Control' => 'max-age=420'}, ['test'])
+      body = @response.body
+      cache_key = @store.store(@request, @response, @entity_store)
+      @response.body.must_equal(body)
+      cache_key
+    end
+
+    define_method :uri do |uri|
+      URI.parse uri
+    end
+end

data/test/redis-rack-cache/version_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+describe Redis::Rack::Cache::VERSION do
+  it "must be equal to 1.1.rc" do
+    Redis::Rack::Cache::VERSION.must_equal '1.1.rc'
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+Bundler.setup
+gem 'minitest'
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'mocha'
+require 'redis-rack-cache'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: redis-rack-cache
 version: !ruby/object:Gem::Version 
-  hash: 31
-  prerelease: 
+  hash: 7712070
+  prerelease: 4
   segments: 
-  - 0
-  - 0
-  - 0
-  version: 0.0.0
+  - 1
+  - 1
+  - rc
+  version: 1.1.rc
 platform: ruby
 authors: 
 - Luca Guidi
@@ -15,9 +15,121 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-08 00:00:00 Z
-dependencies: []
-
+date: 2011-12-30 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis-store
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 7712002
+        segments: 
+        - 1
+        - 1
+        - 0
+        - rc
+        version: 1.1.0.rc
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rack-cache
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 1
+        version: "1.1"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 0
+        - 9
+        - 2
+        - 2
+        version: 0.9.2.2
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7712070
+        segments: 
+        - 1
+        - 1
+        - rc
+        version: 1.1.rc
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 55
+        segments: 
+        - 0
+        - 10
+        - 0
+        version: 0.10.0
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 47
+        segments: 
+        - 2
+        - 8
+        - 0
+        version: 2.8.0
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: purdytest
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id007
 description: Redis for Rack::Cache
 email: 
 - guidi.luca@gmail.com
@@ -30,10 +142,21 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
+- MIT-LICENSE
+- README.md
 - Rakefile
+- lib/rack/cache/redis_entitystore.rb
+- lib/rack/cache/redis_metastore.rb
 - lib/redis-rack-cache.rb
 - lib/redis-rack-cache/version.rb
 - redis-rack-cache.gemspec
+- test/rack/.DS_Store
+- test/rack/cache/.DS_Store
+- test/rack/cache/entitystore/pony.jpg
+- test/rack/cache/entitystore/redis_test.rb
+- test/rack/cache/metastore/redis_test.rb
+- test/redis-rack-cache/version_test.rb
+- test/test_helper.rb
 homepage: http://jodosha.github.com/redis-store
 licenses: []
 
@@ -54,12 +177,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: redis-rack-cache
@@ -67,5 +192,12 @@ rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Redis for Rack::Cache
-test_files: []
-
+test_files: 
+- test/rack/.DS_Store
+- test/rack/cache/.DS_Store
+- test/rack/cache/entitystore/pony.jpg
+- test/rack/cache/entitystore/redis_test.rb
+- test/rack/cache/metastore/redis_test.rb
+- test/redis-rack-cache/version_test.rb
+- test/test_helper.rb
+has_rdoc: