mongo_store 0.1.0 → 0.2.0

data/README.markdown

@@ -0,0 +1,86 @@
+# MongoStore
+
+It's **ActiveSupport::Cache::MongoStore** -- a [MongoDB](http://mongodb.org)-based provider for the standard Rails cache mechanism.  With an emphasis on fast writes and a memory-mapped architecture, Mongo is well-suited to caching. This gem aims to give you what the ubiquitous **MemCacheStore** does, but with Mongo's persistence.  (And without having to put a second RAM devourer in an environment already running Mongo.)
+
+## Getting Started
+
+The only prerequisites are [ActiveSupport](http://rubygems.org/gems/activesupport) and the [mongo](http://rubygems.org/gems/mongo) gem.  If your app uses [MongoMapper](htp://rubygems.org/gems/mongo_mapper) we can detect it and use the same database connection, but we don't require it.
+
+    $ gem install mongo_store   # or 'sudo' as required
+    
+In your Rails application, just configure your **config/environments/production.rb** (and/or **staging.rb** and any other environment you want to cache) like so:
+
+    config.cache_store = :mongo_store
+    
+This default behavior creates a collection called **rails\_cache** in either the Mongo database referenced by `MongoMapper.database` (if you're using MM) or a database also called **rails\_cache**.  You can override these:
+
+    config.cache_store = :mongo_store, "foo"  # Collection name is "foo"
+    config.cache_store = :mongo_store, "foo", :db => "bar"  # DB name is "bar"
+    
+    # You can pass a DB object instead of a database name...
+    deebee = Mongo::DB.new("bar", Mongo::Connection.new)
+    config.cache_store = :mongo_store, "foo", :db => deebee
+    
+    # Or just pass in a Collection object and you're covered...
+    collie = Mongo::Collection.new(deebee, "foo")
+    config.cache_store = :mongo_store, collie
+    
+We don't have a separate option for connecting to a different server.  If you don't intend to use localhost, make a new Mongo::Collection or Mongo::DB object from a different connection.
+    
+## Options
+
+The following hash options are recognized on initialization:
+
+* `:db` - A Mongo::DB object or the name of one to create. Defaults to **rails_cache**.
+* `:create_index` - By default, we create an index on the _key_ and _expires_ fields. Set to **false** to override.
+* `:expires_in` - The global length of time a cache key remains valid. Defaults to 1 year. Can also be set on individual cache writes.
+
+## Other Goodness
+
+MongoStore is a drop-in caching store and doesn't require any special treatment. The only extra behavior on top of what you get from ActiveSupport::Cache::Store is as follows:
+
+### :expires_in option on the #write method
+This is the same behavior as the option in the MemCacheStore. Specify a number of seconds or an ActiveSupport helper equivalent, e.g.: `:expires_in => 5.minutes`.  Keys past their expiration date are not returned on reads.
+
+_**NOTE:** This behavior is fairly dumb and uses `Time.now` on the application side.  If you have a number of app servers hitting one database and their times aren't in sync, expect unwarranted cache misses._
+
+### #clean_expired method
+If the collection size starts to explode from old cached values that are never being written again, you can set up a delayed job or Rake task to run `Rails.cache.clean_expired` every few weeks or such.  Cached values that _are_ reused are updated in place, so running this too frequently may actually impair performance.
+
+### #clear method
+Empties the cache. The moral equivalent of `Rails.cache.delete_matched(/.*/)` but faster.
+
+## Limitations
+
+* Keys and values must be valid Mongo types. In practice, caching seems mostly to be used on strings, so this probably doesn't hurt you. Just be aware that no attempt is made to serialize complex Ruby objects. That's what ORMs are for. (See my [Candy](http://rubygems.org/gems/candy) gem for some work I've been doing in this direction, however.)
+
+* Upserts and atomic operators are used for performance and simplicity. Writing to an existing key will change the value and expiration date. This is fast, but expired keys that are never written again _will_ keep hanging around until you delete them explicitly or run `#clean_expired`. This may or may not matter depending on how numerous and reusable your keys are. For typical Rails app use cases, you're probably fine. If you really care about every byte of disk space, you probably ought to reconsider using MongoDB anyway.
+
+* Mongo documents have a size limit of 4 MB. No attempt is made to work around this. If you're trying to trying to stuff anything larger than that into Rails caching, you're on your own.
+
+* Do not use a capped collection. Doing so will prevent deletes from deleting, some updates from updating, and the trees and flowers from growing in the Spring.
+
+* This code and specs were written for Ruby 1.9.1.  I tried to make sure it works fine for you anachronists (Ruby 1.8), but didn't confirm it. Please register an issue if I forgot your quaint historical syntax. I also didn't test it in JRuby, Rubinius, IronRuby, or your roommate's HP-48 calculator. 
+
+* Likewise, this was written for Rails 2.3.5. I have not tried to run it in Rails 3 yet, which is still in beta at the time of this writing. I don't even know if Rails 3 uses the same caching approach. It probably caches using pure energy or something, and removes carbon from the atmosphere at the same time. 
+
+* I am optimistic about performance but have not benchmarked it, apart from  "It's faster than not using a cache."
+
+## Support
+
+You can find the docs here: 
+http://rdoc.info/projects/SFEley/mongo_store/
+
+Other than that, there is no email list, forum, wiki, Google Wave, or international convention for this gem. Come on. It's a hundred lines of code.
+
+## Contributing
+
+Please leave an issue. Or fork, fix, and pull-request. Or send me an email (sfeley@gmail.com). Or buy me a whisky at the hotel bar. (Single malt only, please.)
+
+You can also [check out my podcast](http://escapepod.org) if you like science fiction stories.
+
+And Have Fun.
+
+## Copyright
+
+Copyright (c) 2010 Stephen Eley. See LICENSE for details.

data/Rakefile

@@ -5,8 +5,8 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "mongo_store"
-    gem.summary = %Q{ActiveSupport::Cache implementation for MongoDB}
-    gem.description = %Q{10gen keeps bragging that MongoDB, with its fast writes and memory-mapped architecture, is ideal for caching. This gem puts it to use in Rails.}
+    gem.summary = %Q{Rails caching for MongoDB}
+    gem.description = %Q{It's ActiveSupport::Cache::MongoStore -- a MongoDB-based provider for the standard Rails cache mechanism.  With an emphasis on fast writes and a memory-mapped architecture, Mongo is well-suited to caching. This gem aims to give you what the ubiquitous MemCacheStore does, but with Mongo's persistence.  (And without having to put a second RAM devourer in an environment already running Mongo.)}
     gem.email = "sfeley@gmail.com"
     gem.homepage = "http://github.com/SFEley/mongo_store"
     gem.authors = ["Stephen Eley"]

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/active_support/cache/mongo_store.rb

@@ -0,0 +1,115 @@
+require 'active_support'
+require 'mongo'
+
+module ActiveSupport
+  module Cache
+    class MongoStore < Store
+      attr_reader :options
+      attr_accessor :expires_in
+      
+      # Returns a MongoDB cache store.  Can take either a Mongo::Collection object or a collection name.
+      # If neither is provided, a collection named "rails_cache" is created.
+      #
+      # An options hash may also be provided with the following options:
+      # 
+      # * :expires_in - The default expiration period for cached objects. If not provided, defaults to 1 year.
+      # * :db - Either a Mongo::DB object or a database name. Not used if a Mongo::Collection object is passed. Otherwise defaults to MongoMapper.database (if MongoMapper is used in the app) or else creates a DB named "rails_cache".
+      # * :create_index - Whether to index the key and expiration date on the collection. Defaults to true. Not used if a Mongo::Collection object is passed.
+      def initialize(collection = nil, options = nil)
+        @options = {
+          :collection_name => 'rails_cache',
+          :db_name => 'rails_cache',
+          :expires_in => 1.year,
+          :create_index => true
+        }
+        # @options.merge!(options) if options
+        case collection
+        when Mongo::Collection
+          @collection = collection
+        when String
+          @options[:collection_name] = collection
+        when Hash
+          @options.merge!(collection)
+        when nil
+          # No op
+        else
+          raise TypeError, "MongoStore parameters must be a Mongo::Collection, a collection name, and/or an options hash."
+        end
+        
+        @options.merge!(options) if options.is_a?(Hash)
+        
+        # Set the expiration time
+        self.expires_in = @options[:expires_in]
+        super()
+      end
+      
+      # Returns the MongoDB collection described in the options to .new (or else the default 'rails_cache' one.)
+      # Lazily creates the object on first access so that we can look for a MongoMapper database _after_ 
+      # MongoMapper initializes.
+      def collection
+        @collection ||= make_collection
+      end
+            
+      # Removes old cached values that have expired.  Set this up to run occasionally in delayed_job, etc., if you
+      # start worrying about space.  (In practice, because we favor updating over inserting, space is only wasted
+      # if the key itself never gets cached again.  It also means you can _reduce_ efficiency by running this
+      # too often.)
+      def clean_expired
+        collection.remove({'expires' => {'$lt' => Time.now}})
+      end
+      
+      # Wipes the whole cache.
+      def clear
+        collection.remove
+      end
+      
+      # Inserts the value into the cache collection or updates the existing value.  The value must be a valid
+      # MongoDB type.  An *:expires_in* option may be provided, as with MemCacheStore.  If one is _not_ 
+      # provided, a default expiration of 1 year is used.
+      def write(key, value, options=nil)
+        super
+        expires = Time.now + ((options && options[:expires_in]) || expires_in)
+        collection.update({'key' => key}, {'$set' => {'value' => value, 'expires' => expires}}, :upsert => true)
+      end
+      
+      # Reads the value from the cache collection.
+      def read(key, options=nil)
+        super
+        if doc = collection.find_one('key' => key, 'expires' => {'$gt' => Time.now})
+          doc['value']
+        end
+      end
+        
+      # Takes the specified value out of the collection.
+      def delete(key, options=nil)
+        super
+        collection.remove({'key' => key})
+      end
+      
+      # With MongoDB, there's no difference between querying on an exact value or a regex.  Beautiful, huh?
+      alias_method :delete_matched, :delete
+      
+      private
+      def mongomapper?
+        Kernel.const_defined?(:MongoMapper) && MongoMapper.respond_to?(:database) && MongoMapper.database
+      end
+      
+      def make_collection
+        db = case options[:db]
+        when Mongo::DB then options[:db]
+        when String then Mongo::DB.new(options[:db], Mongo::Connection.new)
+        else
+          if mongomapper?
+            MongoMapper.database
+          else
+            Mongo::DB.new(options[:db_name], Mongo::Connection.new)
+          end
+        end
+        coll = db.create_collection(options[:collection_name])
+        coll.create_index('key' => Mongo::ASCENDING, 'expires' => Mongo::DESCENDING) if options[:create_index]
+        coll
+      end
+        
+    end
+  end
+end

data/lib/mongo_store.rb

@@ -1,77 +1,7 @@
 require 'active_support'
-require 'mongo'
 
 module ActiveSupport
   module Cache
-    class MongoStore < Store
-      attr_reader :collection
-      
-      # Returns a MongoDB cache store.  Takes several possible combinations of parameters.  In order of
-      # escalating guesswork:
-      #
-      # 1. *a Mongo::Collection object* - No guessing. The collection is used as the cache store.
-      # 2. *a collection name and a database name* - Mongo objects are created for both.  The default 'localhost:27017' connection is used.
-      # 3. *a collection name* - Uses either MongoMapper.database (if MongoMapper is defined in the app) or a DB with the same name.
-      # 4. *no parameters* - A collection named 'rails_cache' is created, using either MongoMapper.database (if MongoMapper is defined in the app) or a DB also named 'rails_cache'.
-      #
-      # Unless option 1 is used, indexes are created on the key and expiration fields. If you supply your own collection,
-      # you are also responsible for making your own indexes.
-      def initialize(collection = nil, db_name = nil)
-        @collection = case collection
-        when Mongo::Collection then collection
-        when String
-          make_collection(collection, db_name)
-        when nil
-          make_collection('rails_cache')
-        else
-          raise TypeError, "MongoStore parameters must be nil, a Mongo::Collection, or a collection name."
-        end
-      end
-      
-      # Inserts the value into the cache collection or updates the existing value.  The value must be a valid
-      # MongoDB type.  An *:expires_in* option may be provided, as with MemCacheStore.  If one is _not_ 
-      # provided, a default expiration of 1 year is used.
-      def write(key, value, options={})
-        super
-        expires = Time.now + (options[:expires_in] || 1.year)
-        collection.update({'key' => key}, {'$set' => {'value' => value, 'expires' => expires}}, :upsert => true)
-      end
-      
-      # Reads the value from the cache collection.
-      def read(key, options={})
-        super
-        if doc = collection.find_one('key' => key, 'expires' => {'$gt' => Time.now})
-          doc['value']
-        end
-      end
-        
-      # Takes the specified value out of the collection.
-      def delete(key, options={})
-        super
-        collection.remove({'key' => key})
-      end
-      
-      # With MongoDB, there's no difference between querying on an exact value or a regex.  Beautiful, huh?
-      alias_method :delete_matched, :delete
-      
-      private
-      def mongomapper?
-        Kernel.const_defined?(:MongoMapper) && MongoMapper.respond_to?(:database) && MongoMapper.database
-      end
-      
-      def make_collection(collection, db_name=nil)
-         if db_name
-           db = Mongo::DB.new(db_name, Mongo::Connection.new)
-         elsif mongomapper?
-           db = MongoMapper.database
-         else
-           db = Mongo::DB.new(collection, Mongo::Connection.new)
-         end
-        coll = db.create_collection(collection)
-        coll.create_index('key' => Mongo::ASCENDING, 'expires' => Mongo::DESCENDING)
-        coll
-      end
-        
-    end
+    autoload :MongoStore, 'active_support/cache/mongo_store'
   end
-end
+end

data/mongo_store.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mongo_store}
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Stephen Eley"]
+  s.date = %q{2010-03-06}
+  s.description = %q{It's ActiveSupport::Cache::MongoStore -- a MongoDB-based provider for the standard Rails cache mechanism.  With an emphasis on fast writes and a memory-mapped architecture, Mongo is well-suited to caching. This gem aims to give you what the ubiquitous MemCacheStore does, but with Mongo's persistence.  (And without having to put a second RAM devourer in an environment already running Mongo.)}
+  s.email = %q{sfeley@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "lib/active_support/cache/mongo_store.rb",
+     "lib/mongo_store.rb",
+     "mongo_store.gemspec",
+     "spec/active_support/cache/mongo_store_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/SFEley/mongo_store}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Rails caching for MongoDB}
+  s.test_files = [
+    "spec/active_support/cache/mongo_store_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<mongo>, [">= 0.18.3"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 2.2"])
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_development_dependency(%q<mocha>, [">= 0.9"])
+    else
+      s.add_dependency(%q<mongo>, [">= 0.18.3"])
+      s.add_dependency(%q<activesupport>, [">= 2.2"])
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_dependency(%q<mocha>, [">= 0.9"])
+    end
+  else
+    s.add_dependency(%q<mongo>, [">= 0.18.3"])
+    s.add_dependency(%q<activesupport>, [">= 2.2"])
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    s.add_dependency(%q<mocha>, [">= 0.9"])
+  end
+end
+

data/spec/active_support/cache/mongo_store_spec.rb

@@ -0,0 +1,187 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+# Stubbing MongoMapper out so that we don't have to have it installed for testing
+class MongoMapper
+end
+
+module ActiveSupport 
+  module Cache
+    describe MongoStore do
+      describe "initializing" do
+        it "can take a Mongo::Collection object" do
+          db = Mongo::DB.new('mongo_store_test', Mongo::Connection.new)
+          coll = Mongo::Collection.new(db, 'foostore')
+          store = ActiveSupport::Cache.lookup_store(:mongo_store, coll)
+          store.collection.should == coll
+        end
+    
+        it "can take a collection name" do
+          store = ActiveSupport::Cache.lookup_store(:mongo_store, 'foo')
+          store.collection.name.should == 'foo'
+        end
+        
+        it "defaults the collection name to 'rails_cache'" do
+          store = ActiveSupport::Cache.lookup_store(:mongo_store)
+          store.collection.name.should == 'rails_cache'
+        end
+        
+        it "can take a Mongo::DB object for a :db option" do
+          deebee = Mongo::DB.new('mongo_store_test_deebee', Mongo::Connection.new)
+          store = ActiveSupport::Cache.lookup_store(:mongo_store, :db => deebee)
+          store.collection.db.should == deebee
+        end
+        
+        it "can take a database name for a :db option" do
+          store = ActiveSupport::Cache.lookup_store(:mongo_store, :db => 'mongo_store_test_name')
+          store.collection.db.name.should == 'mongo_store_test_name'
+        end
+        
+        it "uses MongoMapper if no other DB is provided" do
+          mappy = Mongo::DB.new('mongo_store_test_mappy', Mongo::Connection.new)
+          MongoMapper.expects(:database).at_least_once.returns(mappy)
+          store = ActiveSupport::Cache.lookup_store(:mongo_store)
+          store.collection.db.should == mappy
+        end
+        
+        it "lazy loads so that MongoMapper can be initialized first" do
+          store = ActiveSupport::Cache.lookup_store(:mongo_store)
+          # Notice the order! It's what differentiates this test from the above.
+          lazy = Mongo::DB.new('mongo_store_test_lazy', Mongo::Connection.new)
+          MongoMapper.expects(:database).at_least_once.returns(lazy)
+          store.collection.db.should == lazy
+        end
+          
+        
+        it "defaults the database name to 'rails_cache'" do
+          store = ActiveSupport::Cache.lookup_store(:mongo_store)
+          store.collection.db.name.should == 'rails_cache'
+        end
+        
+        it "defaults to creating an index" do
+          Mongo::Collection.any_instance.expects(:create_index)
+          store = ActiveSupport::Cache.lookup_store(:mongo_store)
+          store.collection.should_not be_nil
+        end
+        
+        it "can turn off index creation" do
+          Mongo::Collection.any_instance.expects(:create_index).never
+          store = ActiveSupport::Cache.lookup_store(:mongo_store, :create_index => false)
+          store.collection.should_not be_nil
+        end
+          
+        it "defaults to an expiration of 1 year" do
+          store = ActiveSupport::Cache.lookup_store(:mongo_store)
+          store.expires_in.should == 1.year
+        end
+        
+        it "can override expiration time with the :expires_in option" do
+          store = ActiveSupport::Cache.lookup_store(:mongo_store, :expires_in => 1.week)
+          store.expires_in.should == 1.week
+        end
+        
+        it "can take options as the first parameter" do
+          store = ActiveSupport::Cache.lookup_store(:mongo_store, :expires_in => 1.minute)
+          store.expires_in.should == 1.minute
+        end
+        
+        it "can take options as the second parameter" do
+          store = ActiveSupport::Cache.lookup_store(:mongo_store, 'foo', :expires_in => 1.day)
+          store.expires_in.should == 1.day
+        end
+                
+
+        after(:all) do
+          c = Mongo::Connection.new
+          %w(rails_cache mongo_store_test_name mongo_store_test_deebee mongo_store_test_mappy mongo_store_test_lazy).each do |db|
+            c.drop_database(db)
+          end
+        end  
+      end
+  
+      describe "caching" do
+        before(:all) do
+          @store = ActiveSupport::Cache.lookup_store(:mongo_store, 'mongo_store_test', :db => 'mongo_store_test')
+        end
+    
+        it "can write values" do
+          @store.write('fnord', 'I am vaguely disturbed.')
+          @store.collection.find_one(:key => 'fnord')['value'].should == "I am vaguely disturbed."
+        end
+    
+        it "can read values" do
+          @store.collection.insert({:key => 'yoo', :value => 'yar', :expires => 1.year.from_now})
+          @store.read('yoo').should == 'yar'
+        end
+    
+        it "can delete keys" do
+          @store.write('foo', 'bar')
+          @store.read('foo').should == 'bar'
+          @store.delete('foo')
+          @store.read('foo').should be_nil
+        end
+    
+        it "can delete keys matching a regular expression" do
+          @store.write('foo', 'bar')
+          @store.write('fodder', 'bother')
+          @store.write('yoo', 'yar')
+          # Initial state
+          @store.read('foo').should == 'bar'
+          @store.read('fodder').should == 'bother'
+          @store.read('yoo').should == 'yar'
+          # The work
+          @store.delete_matched /oo/
+          # Post state
+          @store.read('foo').should be_nil
+          @store.read('fodder').should == 'bother'
+          @store.read('yoo').should be_nil
+        end
+    
+        it "can expire a value with the :expires_in option" do
+          @store.write('ray', 'dar', :expires_in => 2.seconds)
+          @store.read('ray').should == 'dar'
+          sleep(3)
+          @store.read('ray').should be_nil
+        end
+        
+        it "can expire a value from the global setting" do
+          old_expires = @store.expires_in
+          @store.expires_in = 2.seconds
+          @store.write('foo', 'bar')
+          @store.write('yoo', 'yar', :expires_in => 5.minutes)
+          @store.read('foo').should == 'bar'
+          @store.read('yoo').should == 'yar'
+          sleep(3)
+          @store.read('foo').should be_nil
+          @store.read('yoo').should == 'yar'
+          @store.expires_in = old_expires
+        end
+        
+        it "can clean up expired values" do
+          @store.write('foo', 'bar', :expires_in => 2.seconds)
+          @store.write('yoo', 'yar', :expires_in => 2.days)
+          sleep(3)
+          @store.collection.count.should == 2
+          @store.clean_expired
+          @store.collection.count.should == 1
+        end
+          
+        it "can clear the whole cache" do
+          @store.write('foo', 'bar')
+          @store.write('yoo', 'yar', :expires_in => 2.days)
+          @store.collection.count.should == 2
+          @store.clear
+          @store.collection.count.should == 0
+        end
+    
+        after(:each) do
+          @store.collection.remove   # Clear our records
+        end
+        
+        after(:all) do
+          c = Mongo::Connection.new
+          c.drop_database('mongo_store_test')
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'mongo'
 require 'mongo_store'
 require 'spec'
 require 'spec/autorun'

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Stephen Eley
@@ -71,7 +71,7 @@ dependencies:
         version: "0.9"
   type: :development
   version_requirements: *id004
-description: 10gen keeps bragging that MongoDB, with its fast writes and memory-mapped architecture, is ideal for caching. This gem puts it to use in Rails.
+description: It's ActiveSupport::Cache::MongoStore -- a MongoDB-based provider for the standard Rails cache mechanism.  With an emphasis on fast writes and a memory-mapped architecture, Mongo is well-suited to caching. This gem aims to give you what the ubiquitous MemCacheStore does, but with Mongo's persistence.  (And without having to put a second RAM devourer in an environment already running Mongo.)
 email: sfeley@gmail.com
 executables: []
 
@@ -79,16 +79,18 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README.rdoc
+- README.markdown
 files: 
 - .document
 - .gitignore
 - LICENSE
-- README.rdoc
+- README.markdown
 - Rakefile
 - VERSION
+- lib/active_support/cache/mongo_store.rb
 - lib/mongo_store.rb
-- spec/mongo_store_spec.rb
+- mongo_store.gemspec
+- spec/active_support/cache/mongo_store_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: true
@@ -120,7 +122,7 @@ rubyforge_project:
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: ActiveSupport::Cache implementation for MongoDB
+summary: Rails caching for MongoDB
 test_files: 
-- spec/mongo_store_spec.rb
+- spec/active_support/cache/mongo_store_spec.rb
 - spec/spec_helper.rb

data/README.rdoc

@@ -1,17 +0,0 @@
-= MongoStore
-
-It's **ActiveSupport::Cache::MongoStore** -- if you know your Rails caching, _'nuff said._  
-
-== Note on Patches/Pull Requests
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-
-== Copyright
-
-Copyright (c) 2010 Stephen Eley. See LICENSE for details.

data/spec/mongo_store_spec.rb

@@ -1,120 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-# Stubbing MongoMapper out so that we don't have to have it installed for testing
-class MongoMapper
-end
-    
-describe "MongoStore" do
-  describe "collection" do
-    it "can be specified as a Mongo::Collection object" do
-      db = Mongo::DB.new('mongo_store_test', Mongo::Connection.new)
-      coll = Mongo::Collection.new(db, 'foostore')
-      store = ActiveSupport::Cache.lookup_store(:mongo_store, coll)
-      store.collection.should == coll
-    end
-    
-    it "can take a collection name and a database name" do
-      store = ActiveSupport::Cache.lookup_store(:mongo_store, 'foo', 'bar')
-      store.collection.name.should == 'foo'
-      store.collection.db.name.should == 'bar'
-    end
-    
-    describe "with MongoMapper" do
-      before(:each) do
-        db = Mongo::DB.new('mappy', Mongo::Connection.new)
-        MongoMapper.expects(:database).twice.returns(db)
-      end
-      
-      it "can take a collection name" do
-        store = ActiveSupport::Cache.lookup_store(:mongo_store, 'happy')
-        store.collection.name.should == 'happy'
-        store.collection.db.name.should == 'mappy'
-      end
-        
-      it "defaults to a 'rails_cache' collection" do
-        store = ActiveSupport::Cache.lookup_store(:mongo_store)
-        store.collection.name.should == 'rails_cache'
-        store.collection.db.name.should == 'mappy'
-      end
-    end
-    
-    describe "without MongoMapper" do
-      it "can take a collection name" do
-        store = ActiveSupport::Cache.lookup_store(:mongo_store, 'yuna')
-        store.collection.name.should == 'yuna'
-        store.collection.db.name.should == 'yuna'
-      end
-        
-      it "defaults to a 'rails_cache' collection" do
-        store = ActiveSupport::Cache.lookup_store(:mongo_store)
-        store.collection.name.should == 'rails_cache'
-        store.collection.db.name.should == 'rails_cache'
-      end
-    end
-    
-    it "raises an exception if an unusable parameter is passed" do
-      lambda{ActiveSupport::Cache.lookup_store(:mongo_store, 5)}.should raise_error(TypeError)
-    end
-        
-    after(:all) do
-      c = Mongo::Connection.new
-      %w(bar mappy rails_cache yuna).each do |db|
-        c.drop_database(db)
-      end
-    end  
-  end
-  
-  describe "caching" do
-    before(:all) do
-      @store = ActiveSupport::Cache.lookup_store(:mongo_store, 'mongo_store_test')
-    end
-    
-    it "can write values" do
-      @store.write('fnord', 'I am vaguely disturbed.')
-      @store.collection.find_one(:key => 'fnord')['value'].should == "I am vaguely disturbed."
-    end
-    
-    it "can read values" do
-      @store.collection.insert({:key => 'yoo', :value => 'yar', :expires => 1.year.from_now})
-      @store.read('yoo').should == 'yar'
-    end
-    
-    it "can delete keys" do
-      @store.write('foo', 'bar')
-      @store.read('foo').should == 'bar'
-      @store.delete('foo')
-      @store.read('foo').should be_nil
-    end
-    
-    it "can delete keys matching a regular expression" do
-      @store.write('foo', 'bar')
-      @store.write('fodder', 'bother')
-      @store.write('yoo', 'yar')
-      # Initial state
-      @store.read('foo').should == 'bar'
-      @store.read('fodder').should == 'bother'
-      @store.read('yoo').should == 'yar'
-      # The work
-      @store.delete_matched /oo/
-      # Post state
-      @store.read('foo').should be_nil
-      @store.read('fodder').should == 'bother'
-      @store.read('yoo').should be_nil
-    end
-    
-    it "can expire a value with the :expires_in option" do
-      @store.write('ray', 'dar', :expires_in => 2.seconds)
-      @store.read('ray').should == 'dar'
-      sleep(3)
-      @store.read('ray').should be_nil
-    end
-    
-    after(:each) do
-      @store.collection.remove   # Clear our records
-    end
-    after(:all) do
-      c = Mongo::Connection.new
-      c.drop_database('mongo_store_test')
-    end
-  end
-end