bin 0.6.3 → 0.7.0

data/.gitignore

@@ -0,0 +1,2 @@
+log
+*.gem

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+gem 'bson_ext', :require => false
+
+gemspec
+
+gem 'i18n'
+gem 'rake'
+gem 'rspec'
+gem 'log_buddy'
+gem 'SystemTimer'

data/Gemfile.lock

@@ -0,0 +1,42 @@
+PATH
+  remote: .
+  specs:
+    bin (0.6.3)
+      activesupport (~> 3.1.0)
+      mongo (~> 1.3.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    SystemTimer (1.2.1)
+    activesupport (3.1.0)
+      multi_json (~> 1.0)
+    bson (1.3.1)
+    bson_ext (1.3.1)
+    diff-lcs (1.1.3)
+    i18n (0.6.0)
+    log_buddy (0.6.0)
+    mongo (1.3.1)
+      bson (>= 1.3.1)
+    multi_json (1.0.3)
+    rake (0.9.2)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  SystemTimer
+  bin!
+  bson_ext
+  i18n
+  log_buddy
+  rake
+  rspec

data/README.rdoc

@@ -4,8 +4,29 @@ ActiveSupport MongoDB Cache store.
 
 == Supports
 
-* Ruby 1.8.7 and Ruby 1.9.1.
-* ActiveSupport 2 and 3
+* Ruby 1.8.7 and 1.9.2+
+* ActiveSupport 3+
+
+== Installation and Usage
+
+    gem install bin
+
+    require 'bin'
+
+    collection = Mongo::Connection.new.db('testing')['testing']
+    collection.remove
+
+    bin = Bin::Store.new(collection)
+    bin.write('abc', 123)
+    pp bin.read('abc')
+
+    pp bin.read('def')
+    pp bin.fetch('def') { 456 }
+    pp bin.read('def')
+
+Using bin with rails is as easy as:
+
+    config.cache_store = :bin, Mongo::Connection.new.db('myapp')['cache']
 
 == Note on Patches/Pull Requests
 

data/Rakefile

@@ -1,45 +1,7 @@
-require 'rubygems'
-require 'rake'
-require 'spec/rake/spectask'
-require File.expand_path('../lib/bin/version', __FILE__)
+require 'bundler'
+Bundler::GemHelper.install_tasks
 
-namespace :spec do
-  Spec::Rake::SpecTask.new(:all) do |t|
-    t.ruby_opts << '-rubygems'
-    t.verbose = true
-  end
-
-  task :as2 do
-    sh 'ACTIVE_SUPPORT_VERSION="<= 2.3.8" rake spec:all'
-  end
-
-  task :as3 do
-    sh 'ACTIVE_SUPPORT_VERSION=">= 3.0.0.beta3" rake spec:all'
-  end
-end
-
-desc 'Runs all specs against Active Support 2 and 3'
-task :spec do
-  Rake::Task['spec:as2'].invoke
-  Rake::Task['spec:as3'].invoke
-end
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
 
 task :default => :spec
-
-desc 'Builds the gem'
-task :build do
-  sh "gem build bin.gemspec"
-end
-
-desc 'Builds and installs the gem'
-task :install => :build do
-  sh "gem install bin-#{Bin::Version}"
-end
-
-desc 'Tags version, pushes to remote, and pushes gem'
-task :release => :build do
-  sh "git tag v#{Bin::Version}"
-  sh "git push origin master"
-  sh "git push origin v#{Bin::Version}"
-  sh "gem push bin-#{Bin::Version}.gem"
-end

data/bin.gemspec

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+require File.expand_path('../lib/bin/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name         = 'bin'
+  s.version      = Bin::Version
+  s.platform     = Gem::Platform::RUBY
+  s.authors      = ['John Nunemaker']
+  s.email        = ['nunemaker@gmail.com']
+  s.homepage     = 'http://github.com/jnunemaker/bin'
+  s.summary      = 'ActiveSupport MongoDB Cache store.'
+  s.description  = 'ActiveSupport MongoDB Cache store.'
+
+  s.add_dependency 'mongo',         '~> 1.3.0'
+  s.add_dependency 'activesupport', '~> 3.1.0'
+
+  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"]
+end

data/examples/read_write_delete.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'active_support/all'
+require 'bin'
+require 'pp'
+
+collection = Mongo::Connection.new.db('testing')['testing']
+collection.remove
+
+bin = Bin::Store.new(collection)
+bin.write('abc', 123)
+pp bin.read('abc')
+
+pp bin.read('def')
+pp bin.fetch('def') { 456 }
+pp bin.read('def')
+
+bin.delete('abc')
+bin.delete('def')

data/lib/active_support/cache/bin.rb

@@ -0,0 +1,82 @@
+require 'mongo'
+
+module ActiveSupport
+  module Cache
+    class Bin < Store
+      attr_reader :collection, :options
+
+      def initialize(collection, options={})
+        @collection, @options = collection, options
+      end
+
+      def expires_in
+        @expires_in ||= options[:expires_in] || 1.year
+      end
+
+      def delete_matched(matcher, options=nil)
+        collection.remove(:_id => matcher)
+      end
+
+      def increment(key, amount=1, options=nil)
+        counter_key_upsert(:increment, key, amount, options)
+      end
+
+      def decrement(key, amount=1, options=nil)
+        counter_key_upsert(:decrement, key, -amount.abs, options)
+      end
+
+      def clear
+        collection.remove
+      end
+
+      def stats
+        collection.stats
+      end
+
+    private
+      def counter_key_upsert(action, key, amount, options)
+        options = merged_options(options)
+        instrument(action, key, :amount => amount) do
+          key = namespaced_key(key, options)
+          collection.update(
+            {:_id => key}, {
+              '$inc' => {:value => amount},
+              '$set' => {
+                :expires_at => Time.now.utc + 1.year,
+                :raw        => true
+              },
+            }, :upsert => true)
+        end
+      end
+
+      def deserialize_doc(doc)
+        return nil if doc.nil?
+
+        entry = doc['raw'] ? doc['value'] : Marshal.load(doc['value'].to_s)
+        entry.is_a?(Entry) ? entry : Entry.new(entry)
+      end
+
+      def read_entry(key, options)
+        query = {:_id => key, :expires_at => {'$gt' => Time.now.utc}}
+        deserialize_doc(collection.find_one(query))
+      end
+
+      def write_entry(key, entry, options)
+        expires = Time.now.utc + options.fetch(:expires_in, expires_in)
+        value   = options[:raw] ? entry.value : BSON::Binary.new(Marshal.dump(entry.value))
+        query   = {:_id => key}
+        updates = {'$set' => {
+          :value      => value,
+          :expires_at => expires,
+          :raw        => options[:raw],
+        }}
+
+        collection.update(query, updates, :upsert => true)
+      end
+
+      def delete_entry(key, options)
+        collection.remove(:_id => key)
+      end
+    end
+  end
+end

data/lib/bin.rb

@@ -1,10 +1,5 @@
-# encoding: UTF-8
-require 'active_support/all'
-require 'active_support/version'
-require 'mongo'
+require 'active_support/cache/bin'
 
 module Bin
-  autoload :Compatibility, 'bin/compatibility'
-  autoload :Store,         'bin/store'
-  autoload :Version,       'bin/version'
+  Store = ActiveSupport::Cache::Bin
 end

data/lib/bin/version.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 module Bin
-  Version = '0.6.3'
+  Version = '0.7.0'
 end

data/spec/bin_spec.rb

@@ -1,15 +1,207 @@
 require 'helper'
 
-describe Bin do
-  it "autoloads Store" do
-    lambda { Bin::Store }.should_not raise_error(NameError)
+describe ActiveSupport::Cache::Bin do
+  let(:collection)  { DB['bin_cache'] }
+  let(:store)       { ActiveSupport::Cache::Bin.new(collection) }
+
+  it "has a collection" do
+    store.collection.should == collection
+  end
+  
+  it "should also work with Bin::Store for backwards compat" do
+    Bin::Store.should == ActiveSupport::Cache::Bin
+  end
+
+  it "defaults expires_in to 1.year" do
+    store.expires_in.should == 1.year
+  end
+
+  it "can set default expires_in" do
+    ActiveSupport::Cache::Bin.new(collection, :expires_in => 5.minutes).expires_in.should == 5.minutes
+  end
+
+  describe "#write" do
+    before(:each) do
+      store.write('foo', 'bar')
+    end
+    let(:document) { collection.find_one(:_id => 'foo') }
+
+    it "sets _id to key" do
+      document['_id'].should == 'foo'
+    end
+
+    it "sets value key to value" do
+      store.read('foo').should == 'bar'
+    end
+
+    it "should marshal value by default" do
+      document['value'].to_s.should == BSON::Binary.new(Marshal.dump('bar')).to_s
+      document['raw'].should be_false
+    end
+
+    it "should be able to store in raw format" do
+      store.write('foo', 'bar', :raw => true)
+      document['value'].should == 'bar'
+      document['raw'].should be_true
+    end
+
+    it "sets expires in to default if not provided" do
+      document['expires_at'].to_i.should == (Time.now.utc + 1.year).to_i
+    end
+
+    it "sets expires_at if expires_in provided" do
+      store.write('foo', 'bar', :expires_in => 5.seconds)
+      document['expires_at'].to_i.should == (Time.now.utc + 5.seconds).to_i
+    end
+
+    it "always sets key as string" do
+      store.write(:baz, 'wick')
+      doc = collection.find_one(:_id => 'baz')
+      doc.should_not be_nil
+      doc['_id'].should be_instance_of(String)
+    end
   end
 
-  it "autoloads Compatibility" do
-    lambda { Bin::Compatibility }.should_not raise_error(NameError)
+  describe "#read" do
+    before(:each) do
+      store.write('foo', 'bar')
+    end
+    let(:document) { collection.find_one(:_id => 'foo') }
+
+    it "returns nil for key not found" do
+      store.read('non:existent:key').should be_nil
+    end
+
+    it "returns unmarshalled value key value for key found" do
+      store.read('foo').should == 'bar'
+    end
+
+    it "returns raw value if document raw key is true" do
+      store.write('foo', 'bar', :raw => true)
+      store.read('foo').should == 'bar'
+    end
+
+    it "returns nil for existing but expired key" do
+      collection.save(:_id => 'foo', :value => 'bar', :expires_at => 5.seconds.ago)
+      store.read('foo').should be_nil
+    end
+
+    it "return value for existing and not expired key" do
+      store.write('foo', 'bar', :expires_in => 20.seconds)
+      store.read('foo').should == 'bar'
+    end
+
+    it "works with symbol" do
+      store.read(:foo).should == 'bar'
+    end
+  end
+
+  describe "#delete" do
+    before(:each) do
+      store.write('foo', 'bar')
+    end
+
+    it "delete key from cache" do
+      store.read('foo').should_not be_nil
+      store.delete('foo')
+      store.read('foo').should be_nil
+    end
+
+    it "works with symbol" do
+      store.read(:foo).should_not be_nil
+      store.delete(:foo)
+      store.read(:foo).should be_nil
+    end
+  end
+
+  describe "#delete_matched" do
+    before(:each) do
+      store.write('foo1', 'bar')
+      store.write('foo2', 'bar')
+      store.write('baz', 'wick')
+    end
+
+    it "deletes matching keys" do
+      store.read('foo1').should_not be_nil
+      store.read('foo2').should_not be_nil
+      store.delete_matched(/foo/)
+      store.read('foo1').should be_nil
+      store.read('foo2').should be_nil
+    end
+
+    it "does not delete unmatching keys" do
+      store.delete_matched('foo')
+      store.read('baz').should_not be_nil
+    end
+  end
+
+  describe "#exist?" do
+    before(:each) do
+      store.write('foo', 'bar')
+    end
+
+    it "returns true if key found" do
+      store.exist?('foo').should be_true
+    end
+
+    it "returns false if key not found" do
+      store.exist?('not:found:key').should be_false
+    end
+
+    it "works with symbol" do
+      store.exist?(:foo).should be_true
+      store.exist?(:notfoundkey).should be_false
+    end
+  end
+
+  describe "#clear" do
+    before(:each) do
+      store.write('foo', 'bar')
+      store.write('baz', 'wick')
+    end
+
+    it "clear all keys" do
+      collection.count.should == 2
+      store.clear
+      collection.count.should == 0
+    end
+  end
+
+  describe "#increment" do
+    it "increment key by amount" do
+      store.increment('views', 1)
+      store.read('views').should == 1
+      store.increment('views', 2)
+      store.read('views').should == 3
+    end
+
+    it "works with symbol" do
+      store.increment(:views, 2)
+      store.read(:views).should == 2
+    end
+  end
+
+  describe "#decrement" do
+    it "decrement key by amount" do
+      store.increment('views', 5)
+      store.decrement('views', 2)
+      store.read('views').should == 3
+      store.decrement('views', 2)
+      store.read('views').should == 1
+    end
+
+    it "works with symbol" do
+      store.increment(:views, 2)
+      store.decrement(:views, 1)
+      store.read(:views).should == 1
+    end
   end
 
-  it "autoloads Version" do
-    lambda { Bin::Version }.should_not raise_error(NameError)
+  describe "#stats" do
+    it "returns stats" do
+      %w[ns count size].each do |key|
+        store.stats.should have_key(key)
+      end
+    end
   end
 end

data/spec/helper.rb

@@ -1,11 +1,21 @@
-gem 'activesupport', ENV['ACTIVE_SUPPORT_VERSION']
-
 $:.unshift(File.expand_path('../../lib', __FILE__))
 
+require 'rubygems'
+require 'bundler'
+require 'active_support/all'
+
+Bundler.require(:default)
+
 require 'bin'
-require 'spec'
 
 connection = Mongo::Connection.new
-DB = connection.db('bin-store-test')
+DB = connection.db('test')
 
-puts "\n--- Active Support Version: #{ActiveSupport::VERSION::STRING} ---\n"
+RSpec.configure do |c|
+  c.before(:each) do
+    DB.collections.each do |collection|
+      collection.remove
+      collection.drop_indexes
+    end
+  end
+end

data/spec/spec.opts

@@ -1,4 +1,3 @@
 --colour
 --timeout
-20
---diff
+20

data/specs.watchr

@@ -0,0 +1,46 @@
+def growl(title, msg, img)
+  %x{growlnotify -m #{ msg.inspect} -t #{title.inspect} --image ~/.watchr/#{img}.png}
+end
+
+def form_growl_message(str)
+  msg = str.split("\n").last
+  if msg =~ /(\d)\sfailure/
+    img = $1.to_i > 0 ? 'fail' : 'pass'
+  end
+  growl 'Results', msg, img
+end
+
+def run(cmd)
+  puts cmd
+  output = ""
+  IO.popen(cmd) do |com|
+    com.each_char do |c|
+      print c
+      output << c
+      $stdout.flush
+    end
+  end
+  form_growl_message output
+end
+
+def run_spec(path)
+  path.gsub!('lib/', 'spec/')
+  path.gsub!('_spec', '')
+  file_name = File.basename(path, '.rb')
+  path.gsub!(file_name, file_name + "_spec")
+  run %Q(spec #{path})
+end
+
+watch('spec/helper\.rb')  { system('clear'); run('rake') }
+watch('lib/.*\.rb')       { |m| system('clear'); run_spec(m[0]) }
+watch('spec/.*_spec\.rb') { |m| system('clear'); run_spec(m[0]) }
+
+# Ctrl-\
+Signal.trap('QUIT') do
+  puts " --- Running all tests ---\n\n"
+  run('rake')
+end
+
+# Ctrl-C
+Signal.trap('INT') { abort("\n") }
+

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: bin
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  hash: 3
+  prerelease: 
   segments: 
   - 0
-  - 6
-  - 3
-  version: 0.6.3
+  - 7
+  - 0
+  version: 0.7.0
 platform: ruby
 authors: 
 - John Nunemaker
@@ -14,51 +15,41 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-15 00:00:00 -04:00
-default_executable: 
+date: 2011-09-17 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: mongo
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 27
         segments: 
         - 1
+        - 3
         - 0
-        - 1
-        version: 1.0.1
+        version: 1.3.0
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: activesupport
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 3
-        version: "2.3"
-  type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rspec
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
-        - 1
         - 3
+        - 1
         - 0
-        version: 1.3.0
-  type: :development
-  version_requirements: *id003
-description: 
+        version: 3.1.0
+  type: :runtime
+  version_requirements: *id002
+description: ActiveSupport MongoDB Cache store.
 email: 
 - nunemaker@gmail.com
 executables: []
@@ -68,18 +59,21 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/bin/compatibility.rb
-- lib/bin/store.rb
-- lib/bin/version.rb
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.rdoc
+- Rakefile
+- bin.gemspec
+- examples/read_write_delete.rb
+- lib/active_support/cache/bin.rb
 - lib/bin.rb
-- spec/bin/store_spec.rb
+- lib/bin/version.rb
 - spec/bin_spec.rb
 - spec/helper.rb
 - spec/spec.opts
-- LICENSE
-- Rakefile
-- README.rdoc
-has_rdoc: true
+- specs.watchr
 homepage: http://github.com/jnunemaker/bin
 licenses: []
 
@@ -89,25 +83,31 @@ 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: 
-rubygems_version: 1.3.6
+rubygems_version: 1.8.9
 signing_key: 
 specification_version: 3
 summary: ActiveSupport MongoDB Cache store.
-test_files: []
-
+test_files: 
+- spec/bin_spec.rb
+- spec/helper.rb
+- spec/spec.opts

data/lib/bin/compatibility.rb

@@ -1,41 +0,0 @@
-# encoding: UTF-8
-module Bin
-  class Compatibility < ActiveSupport::Cache::Store
-    def increment(key, amount=1)
-      yield
-    end
-
-    def decrement(key, amount=1)
-      yield
-    end
-  end
-
-  if ActiveSupport::VERSION::STRING < '3'
-    class Compatibility
-      def write(key, value, options=nil, &block)
-        super(key, value, options)
-        yield
-      end
-
-      def read(key, options=nil, &block)
-        super
-        yield
-      end
-
-      def delete(key, options=nil, &block)
-        super
-        yield
-      end
-
-      def delete_matched(matcher, options=nil, &block)
-        super
-        yield
-      end
-
-      def exist?(key, options=nil, &block)
-        super
-        yield
-      end
-    end
-  end
-end

data/lib/bin/store.rb

@@ -1,84 +0,0 @@
-# encoding: UTF-8
-module Bin
-  class Store < Compatibility
-    attr_reader :collection, :options
-
-    def initialize(collection, options={})
-      @collection, @options = collection, options
-    end
-
-    def expires_in
-      @expires_in ||= options[:expires_in] || 1.year
-    end
-
-    def write(key, value, options={})
-      key = key.to_s
-      super do
-        expires = Time.now.utc + ((options && options[:expires_in]) || expires_in)
-        raw     = !!options[:raw]
-        value   = raw ? value : BSON::Binary.new(Marshal.dump(value))
-        doc     = {:_id => key, :value => value, :expires_at => expires, :raw => raw}
-        collection.save(doc)
-      end
-    end
-
-    def read(key, options=nil)
-      super do
-        if doc = collection.find_one(:_id => key.to_s, :expires_at => {'$gt' => Time.now.utc})
-          doc['raw'] ? doc['value'] : Marshal.load(doc['value'].to_s)
-        end
-      end
-    end
-
-    def delete(key, options=nil)
-      super do
-        collection.remove(:_id => key.to_s)
-      end
-    end
-
-    def delete_matched(matcher, options=nil)
-      super do
-        collection.remove(:_id => matcher)
-      end
-    end
-
-    def exist?(key, options=nil)
-      super do
-        !read(key, options).nil?
-      end
-    end
-
-    def increment(key, amount=1)
-      super do
-        counter_key_upsert(key, amount)
-      end
-    end
-
-    def decrement(key, amount=1)
-      super do
-        counter_key_upsert(key, -amount.abs)
-      end
-    end
-
-    def clear
-      collection.remove
-    end
-
-    def stats
-      collection.stats
-    end
-
-    private
-      def counter_key_upsert(key, amount)
-        key = key.to_s
-        collection.update(
-          {:_id => key}, {
-            '$inc' => {:value => amount},
-            '$set' => {
-              :expires_at => Time.now.utc + 1.year,
-              :raw        => true
-            },
-          }, :upsert => true)
-      end
-  end
-end

data/spec/bin/store_spec.rb

@@ -1,210 +0,0 @@
-require 'helper'
-
-describe Bin::Store do
-  before(:each) do
-    DB.collections.each do |collection|
-      collection.remove
-      collection.drop_indexes
-    end
-  end
-
-  let(:collection)  { DB['bin_cache'] }
-  let(:store)       { Bin::Store.new(collection) }
-
-  it "has a collection" do
-    store.collection.should == collection
-  end
-
-  it "defaults expires_in to 1.year" do
-    store.expires_in.should == 1.year
-  end
-
-  it "can set default expires_in" do
-    Bin::Store.new(collection, :expires_in => 5.minutes).expires_in.should == 5.minutes
-  end
-
-  describe "#write" do
-    before(:each) do
-      store.write('foo', 'bar')
-    end
-    let(:document) { collection.find_one(:_id => 'foo') }
-
-    it "sets _id to key" do
-      document['_id'].should == 'foo'
-    end
-
-    it "sets value key to value" do
-      store.read('foo').should == 'bar'
-    end
-
-    it "should marshal value by default" do
-      document['value'].to_s.should == BSON::Binary.new(Marshal.dump('bar')).to_s
-      document['raw'].should be_false
-    end
-
-    it "should be able to store in raw format" do
-      store.write('foo', 'bar', :raw => true)
-      document['value'].should == 'bar'
-      document['raw'].should be_true
-    end
-
-    it "sets expires in to default if not provided" do
-      document['expires_at'].to_i.should == (Time.now.utc + 1.year).to_i
-    end
-
-    it "sets expires_at if expires_in provided" do
-      store.write('foo', 'bar', :expires_in => 5.seconds)
-      document['expires_at'].to_i.should == (Time.now.utc + 5.seconds).to_i
-    end
-
-    it "always sets key as string" do
-      store.write(:baz, 'wick')
-      doc = collection.find_one(:_id => 'baz')
-      doc.should_not be_nil
-      doc['_id'].should be_instance_of(String)
-    end
-  end
-
-  describe "#read" do
-    before(:each) do
-      store.write('foo', 'bar')
-    end
-    let(:document) { collection.find_one(:_id => 'foo') }
-
-    it "returns nil for key not found" do
-      store.read('non:existent:key').should be_nil
-    end
-
-    it "returns unmarshalled value key value for key found" do
-      store.read('foo').should == 'bar'
-    end
-
-    it "returns raw value if document raw key is true" do
-      store.write('foo', 'bar', :raw => true)
-      store.read('foo').should == 'bar'
-    end
-
-    it "returns nil for existing but expired key" do
-      collection.save(:_id => 'foo', :value => 'bar', :expires_at => 5.seconds.ago)
-      store.read('foo').should be_nil
-    end
-
-    it "return value for existing and not expired key" do
-      store.write('foo', 'bar', :expires_in => 20.seconds)
-      store.read('foo').should == 'bar'
-    end
-
-    it "works with symbol" do
-      store.read(:foo).should == 'bar'
-    end
-  end
-
-  describe "#delete" do
-    before(:each) do
-      store.write('foo', 'bar')
-    end
-
-    it "delete key from cache" do
-      store.read('foo').should_not be_nil
-      store.delete('foo')
-      store.read('foo').should be_nil
-    end
-
-    it "works with symbol" do
-      store.read(:foo).should_not be_nil
-      store.delete(:foo)
-      store.read(:foo).should be_nil
-    end
-  end
-
-  describe "#delete_matched" do
-    before(:each) do
-      store.write('foo1', 'bar')
-      store.write('foo2', 'bar')
-      store.write('baz', 'wick')
-    end
-
-    it "deletes matching keys" do
-      store.read('foo1').should_not be_nil
-      store.read('foo2').should_not be_nil
-      store.delete_matched(/foo/)
-      store.read('foo1').should be_nil
-      store.read('foo2').should be_nil
-    end
-
-    it "does not delete unmatching keys" do
-      store.delete_matched('foo')
-      store.read('baz').should_not be_nil
-    end
-  end
-
-  describe "#exist?" do
-    before(:each) do
-      store.write('foo', 'bar')
-    end
-
-    it "returns true if key found" do
-      store.exist?('foo').should be_true
-    end
-
-    it "returns false if key not found" do
-      store.exist?('not:found:key').should be_false
-    end
-
-    it "works with symbol" do
-      store.exist?(:foo).should be_true
-      store.exist?(:notfoundkey).should be_false
-    end
-  end
-
-  describe "#clear" do
-    before(:each) do
-      store.write('foo', 'bar')
-      store.write('baz', 'wick')
-    end
-
-    it "clear all keys" do
-      collection.count.should == 2
-      store.clear
-      collection.count.should == 0
-    end
-  end
-
-  describe "#increment" do
-    it "increment key by amount" do
-      store.increment('views', 1)
-      store.read('views').should == 1
-      store.increment('views', 2)
-      store.read('views').should == 3
-    end
-
-    it "works with symbol" do
-      store.increment(:views, 2)
-      store.read(:views).should == 2
-    end
-  end
-
-  describe "#decrement" do
-    it "decrement key by amount" do
-      store.increment('views', 5)
-      store.decrement('views', 2)
-      store.read('views').should == 3
-      store.decrement('views', 2)
-      store.read('views').should == 1
-    end
-
-    it "works with symbol" do
-      store.increment(:views, 2)
-      store.decrement(:views, 1)
-      store.read(:views).should == 1
-    end
-  end
-
-  describe "#stats" do
-    it "returns stats" do
-      %w[ns count size].each do |key|
-        store.stats.should have_key(key)
-      end
-    end
-  end
-end