ruote-mongodb 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Nathan Stults
+
+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

@@ -0,0 +1,15 @@
+ruote-mongodb is a storage provider for the Ruote workflow engine: http://ruote.rubyforge.org/  It enables Ruote to store its data in MongoDB.
+
+INSTALLATION:
+If you're using bundler, you can include this in your Gemfile as follows:
+gem 'ruote-mongodb', :git=>"git://github.com/PlasticLizard/ruote-mongodb.git"
+
+USAGE:
+You can initialize Ruote::MongoDbStorage and pass it directly into the constructor for a Ruote::Worker just like any other Ruote storage provider.
+You can pass in connection information on the constructor as follows:
+Ruote::MongoDbStorage.new(:connection=>{"host"=>"localhost", "port"=>27017, "database"=>"Ruote", "username"=>"pat", "password"=>"s3cret"})
+You can pass also pass in a :config option in the constructor parameters with a path to a YAML file containing your configuration settings.  If you do that, also specify an :environment option representing which set of config settings to use (eg. "development" or Rails.env).
+Note that any specific connection settings you pass to the constructor will over-ride the settings from the YAML file.
+By default (if you don't pass anything in on the constructor), the provider will attempt to connect to host=localhost, port=27017, database=Ruote (unauthenticated)
+
+*** USE AT YOUR OWN RISK!  There is no warrany of any kind for this software. The author accepts no responsibility for data loss or any ohter harm that may come from using this software.  In particular, you should be aware that Ruote will call this storage provider's purge! method, which is designed to remove any collections from the database it's using which begin with the string stored in the @@collection_prefix class variable ("ruote_" by default).  If that sounds like it could be harmful, consider changing the prefix and/or configuring this provider to use its own database.

data/lib/ruote-mongodb.rb

@@ -0,0 +1,6 @@
+root = ::File.expand_path(File.join(File.dirname(__FILE__),'..'))
+
+require 'rubygems'
+require 'mongo'
+require 'yaml'
+require File.join(root,'lib','ruote-mongodb','mongodb_storage')

data/lib/ruote-mongodb/mongodb_storage.rb

@@ -0,0 +1,203 @@
+require 'ruote'
+require 'date'
+
+module Ruote
+  class MongoDbStorage
+    include StorageBase
+    include MonitorMixin
+
+    @@collection_prefix = "ruote_"
+    @@encoded_dollar_sign = "~#~"
+
+    def initialize(options={})
+      super()
+      db_config = {"host"=>"localhost", "port"=>27017, "database"=>"Ruote"}
+      options = options.dup
+      if environment = options.delete(:environment)
+        all_db_config=
+          File.open(options.delete(:config) || 'config/database.yml','r') do |f|
+            YAML.load(f)
+          end
+
+        raise "no configuration for environment: #{environment}" unless env_config = all_db_config[environment]
+        db_config.merge!(env_config)
+      end
+      #args take precedent over config
+      db_config.merge! options.delete(:connection) if options[:connection]
+
+      @db = Mongo::Connection.new(db_config['host'], db_config['port']).
+	db(db_config['database'])
+      if db_config['username'] && db_config['password']
+        @db.authenticate(db_config['username'], db_config['password'])
+      end
+
+      unless get('configurations','engine')
+        put(options.merge('type'=>'configurations', '_id'=>'engine')) 
+      end
+    end
+
+    def close_connection()
+      @db.connection.close()
+    end
+
+    def put(doc, opts={})
+      synchronize do
+        raise "doc must have a type" unless doc['type']
+        raise "doc must have an ID" unless doc['_id']
+        pre = get(doc['type'], doc['_id'])
+
+        if pre && pre['_rev'] != doc['_rev']
+          return pre
+        end
+
+        if pre.nil? && doc['_rev']
+          return true
+        end
+
+        doc = if opts[:update_rev]
+                doc['_rev'] = pre ? pre['_rev'] : -1
+                doc
+              else
+                doc.merge('_rev' => doc['_rev'] || -1)
+              end
+
+        doc['put_at'] = Ruote.now_to_utc_s
+        doc['_rev'] = doc['_rev'] + 1
+
+        encoded_doc = Rufus::Json.dup(doc)
+        to_mongo encoded_doc
+        get_collection(doc['type']).save(encoded_doc)
+
+        nil
+      end
+    end
+
+    def get(type, key)
+      synchronize do
+        doc = get_collection(type).find_one("_id" => key)
+        from_mongo doc if doc
+        doc
+      end
+    end
+
+    def delete(doc)
+      drev = doc['_rev']
+      raise ArgumentError.new("can't delete doc without _rev") unless drev
+      synchronize do
+        raise "doc must have a type" unless doc['type']
+        prev = get(doc['type'], doc['_id'])
+        return true if prev.nil?
+        doc['_rev'] ||= 0
+        if prev['_rev'] == drev
+          get_collection(doc['type']).remove("_id" => doc["_id"])
+          nil
+        else
+          prev
+        end
+      end
+    end
+
+    def get_many(type, key=nil, opts={})
+      synchronize do
+        return get_collection(type).count if opts[:count]
+        criteria = {}
+        find_opts = {}
+        find_opts[:limit] = opts[:limit] if opts[:limit]
+        find_opts[:skip] = opts[:skip] if opts[:skip]
+        find_opts[:sort] = ["_id", opts[:descending] ? :descending : :ascending]
+        if key
+          id_criteria = Array(key).map do |k|
+            case k.class.to_s
+            when "String" then "!#{k}$"
+            when "Regexp" then k.source
+            else k.to_s
+            end
+          end
+          criteria = {"_id" => /#{id_criteria.join "|"}/}
+        end
+        docs = get_collection(type).find(criteria, find_opts).to_a
+        docs.each do |doc|
+          from_mongo doc
+        end
+        docs
+      end
+    end
+
+    def ids(type)
+      synchronize do
+        result = get_collection(type).find({}, {:fields=>["_id"]}).map do |row|
+          row["_id"].to_s
+        end
+        result.sort
+      end
+    end
+
+    def purge!
+      synchronize do
+        @db.collection_names.each do |name| 
+          @db.drop_collection(name) if name =~ /^#{@@collection_prefix}/
+        end
+      end
+    end
+
+    def add_type(type)
+      synchronize do
+        get_collection(type).create_index("_id")
+      end
+    end
+
+    def purge_type!(type)
+      synchronize do
+        @db.drop_collection(@@collection_prefix + type)
+      end
+    end
+
+    private
+
+    def get_collection(type)
+      @db[@@collection_prefix + type]
+    end
+
+    # encodes unsupported data ($, Date) for storage in MongoDB
+    def from_mongo(doc)
+      mongo_encode(doc, /^#{@@encoded_dollar_sign}/, "$", :backward)
+    end
+
+    # unencodes unsupported values ($, Date) from storage in MongoDB
+    def to_mongo(doc)
+      mongo_encode(doc, /^\$/, @@encoded_dollar_sign, :forward)
+    end
+
+    # called by from_mongo and to_mongo
+    def mongo_encode(doc, pattern, replacement, date_conv)
+      if doc.is_a? Hash
+        doc.each_pair do |key, value|
+          new_key = key
+          if key.is_a?(String) && key =~ pattern
+            new_key = key.sub(pattern, replacement)
+            doc[new_key] = value
+            doc.delete key
+          end
+          mongo_encode(value, pattern, replacement, date_conv)
+          ensure_date_encoding(value, doc, new_key, date_conv)
+          doc[new_key] = value.to_s if value.is_a? Symbol
+        end
+      elsif doc.is_a? Array
+        doc.each_with_index do |entry, i|
+          mongo_encode(entry, pattern, replacement, date_conv)
+          ensure_date_encoding(entry, doc, i, date_conv)
+          doc[i] = entry.to_s if entry.is_a? Symbol
+        end
+      end
+    end
+
+    def ensure_date_encoding(value, doc, key, date_conv)
+      if value.is_a?(Date) && date_conv == :forward
+        doc[key] = "DT_" + value.to_s
+      end
+      if value.is_a?(String) && value[0,3] == "DT_" && date_conv == :backward
+        doc[key] = Date.parse(value[3..-1])
+      end
+    end
+  end
+end

data/spec/mongodb_storage_spec.rb

@@ -0,0 +1,225 @@
+require 'ruote-mongodb'
+require 'date'
+
+describe Ruote::MongoDbStorage do
+  describe "options" do
+    after :each do
+      File.delete("config/database.yml") if File.exist?("config/database.yml")
+    end
+
+    it "uses sensible defaults if no DB configuration specified" do
+      lambda {
+        Ruote::MongoDbStorage.new
+      }.should_not raise_error
+    end
+
+    it "fails if invalid server passed in on constructor" do
+      lambda {
+        Ruote::MongoDbStorage.new :connection=>{"host"=>"doesntexist"}
+      }.should raise_error Mongo::ConnectionFailure
+    end
+
+    it "fails if an environment is passed in but database.yml doesn't exist" do
+      lambda {
+        Ruote::MongoDbStorage.new :environment=>"test"
+      }.should raise_error "No such file or directory - config/database.yml"
+      #TODO: consider a better error message for this case
+    end
+
+    it "works when database.yml specifies valid settings for the environment" do
+      File.open("config/database.yml", "w") do |f|
+        f.puts "test:"
+        f.puts "    host: localhost"
+      end
+      lambda {
+        Ruote::MongoDbStorage.new :environment=>"test"
+      }.should_not raise_error
+    end
+
+    it "fails when environment doesn't exist in database.yml" do
+      File.open("config/database.yml", "w") do |f|
+        f.puts "test:"
+        f.puts "    host: localhost"
+      end
+      lambda {
+        Ruote::MongoDbStorage.new :environment=>"development"
+      }.should raise_error "no configuration for environment: development"
+    end
+
+    it "fails when invalid server in database.yml" do
+      File.open("config/database.yml", "w") do |f|
+        f.puts "test:"
+        f.puts "    host: doesntexist"
+      end
+      lambda {
+        Ruote::MongoDbStorage.new :environment=>"test"
+      }.should raise_error Mongo::ConnectionFailure
+    end
+  end
+
+  describe "provider" do
+    before :each do
+      @repo = Ruote::MongoDbStorage.new
+      @repo.purge!
+    end
+
+    after :each do
+      @repo.close_connection
+    end
+
+    it "can store and retrieve a document by ID" do
+      key = BSON::ObjectId.new.to_s
+      doc = {"_id" => key, "name" => "ralph", "type" => "test"}
+      result = @repo.put doc
+      result.should be_nil
+      doc = @repo.get 'test', key
+      doc["name"].should == "ralph"
+    end
+
+    it "can update a document by ID" do
+      key = BSON::ObjectId.new.to_s
+      doc = {"_id" => key, "name" => "ralph", "type" => "test"}
+      @repo.put doc
+      doc = @repo.get 'test', key
+      doc["name"] = "bill"
+      @repo.put doc
+      doc = @repo.get 'test', key
+      doc["name"].should == "bill"
+    end
+
+    it "can store documents with keys starting with dollar sign" do
+      key = BSON::ObjectId.new.to_s
+      doc = {"_id" => key, "type" => "test", "a" => ["$b" => "c"]}
+      @repo.put doc
+      doc = @repo.get 'test', key
+      doc["a"].should == ["$b" => "c"]
+    end
+
+    it "can store documents with dates" do
+      key = BSON::ObjectId.new.to_s
+      doc = {"_id" => key, "type" => "test", "a" => ["b" => Date.parse("11/9/2010")]}
+      @repo.put doc
+      doc = @repo.get 'test', key
+      doc["a"][0]["b"].to_s.should == "2010-11-09"
+    end
+
+    it "can store large floating point numbers accurately" do
+      key = BSON::ObjectId.new.to_s
+      doc = {"_id" => key, "type" => "test", "raw" => 1289501850.34665} #1289443610.7243}
+      @repo.put doc
+      doc = @repo.get 'test', key
+      doc["raw"].should == 1289501850.34665 #1289443610.7243
+    end
+
+    it "can retrieve a document by a string ID" do
+      key = "hello"
+      doc = {"_id" => key, "name" => "ralph", "type" => "test"}
+      @repo.put doc
+      doc = @repo.get 'test', key
+      doc["name"].should == "ralph"
+    end
+
+    it "can delete a document" do
+      key = BSON::ObjectId.new.to_s
+      doc = {"_id" => key, "name" => "ralph", "type" => "test", "_rev" => 0}
+      @repo.put doc
+      @repo.delete doc
+      @repo.get('test', key).should be_nil
+    end
+
+    it "will provide a list of IDs" do
+      key1 = "hello" + BSON::ObjectId.new.to_s
+      key2 = "hello" + BSON::ObjectId.new.to_s
+      key3 = "hello" + BSON::ObjectId.new.to_s
+      @repo.put({"_id" => key1, "name" => "ralph", "type" => "test"})
+      @repo.put({"_id" => key2, "name" => "ralph", "type" => "test"})
+      @repo.put({"_id" => key3, "name" => "ralph", "type" => "test2"})
+      @repo.ids("test").should == [key1, key2]
+      @repo.ids("test2").should == [key3]
+    end
+
+    it "only purges collections starting with the ruote_ prefix" do
+      db = @repo.instance_eval "@db"
+      db.drop_collection("something_else")
+      @repo.put({"_id" => BSON::ObjectId.new.to_s, "name" => "ralph", "type" => "test"})
+      @repo.put({"_id" => BSON::ObjectId.new.to_s, "name" => "bill", "type" => "test2"})
+      db.collection_names.should == ["system.indexes", "ruote_test", "ruote_test2"]
+      db["something_else"].insert({"name" => "doug"})
+      @repo.purge!
+      db.collection_names.should == ["system.indexes", "something_else"]
+    end
+
+    it "can purge a particular type" do
+      key1 = BSON::ObjectId.new.to_s
+      key2 = BSON::ObjectId.new.to_s
+      @repo.put({"_id" => key1, "name" => "ralph", "type" => "test"})
+      @repo.put({"_id" => key2, "name" => "bill", "type" => "test2"})
+      @repo.purge_type! "test2"
+      @repo.get('test', key1)["name"].should == "ralph"
+      @repo.get('test2', key2).should be_nil
+    end
+
+    describe "can get multiple documents" do
+      before :each do
+        key1 = "TANGO!ALPHA!BRAVO"
+        key2 = "TANGO!ALPHA-BRAVO"
+        key3 = "FOXTROT!ALPHA-BRAVO"
+        @repo.put({"_id"=>key1, "fname"=>"ralph", "lname"=>"A", "type"=>"test"})
+        @repo.put({"_id"=>key2, "fname"=>"bill", "lname"=>"B", "type"=>"test"})
+        @repo.put({"_id"=>key3, "fname"=>"nancy", "lname"=>"A", "type"=>"test"})
+      end
+
+      it "with criteria" do
+        search_key = ["BRAVO", /FOXTROT/]
+        docs = @repo.get_many("test", search_key)
+        docs.count.should == 2
+        (docs.select {|doc| doc["fname"] == "ralph"}).count.should == 1
+        (docs.select {|doc| doc["fname"] == "nancy"}).count.should == 1
+        (docs.select {|doc| doc["fname"] == "bill"}).count.should == 0
+      end
+
+      it "without criteria" do
+        docs = @repo.get_many("test", nil)
+        docs.count.should == 3
+      end
+
+      it "up to a certain limit" do
+        docs = @repo.get_many("test", nil, {:limit => 2})
+        docs.count.should == 2
+        (docs.select {|doc| doc["fname"] == "nancy"}).count.should == 1
+        (docs.select {|doc| doc["fname"] == "ralph"}).count.should == 1
+      end
+
+      it "skipping a certain number" do
+        docs = @repo.get_many("test", nil, {:skip => 2})
+        docs.count.should == 1
+        (docs.select {|doc| doc["fname"] == "bill"}).count.should == 1
+      end
+
+      it "in descending order" do
+        docs = @repo.get_many("test", nil, {:descending => true})
+        docs[0]["fname"].should == "bill"
+        docs[1]["fname"].should == "ralph"
+        docs[2]["fname"].should == "nancy"
+      end
+
+      it "in ascending order" do
+        docs = @repo.get_many("test", nil, {:descending => false})
+        docs[0]["fname"].should == "nancy"
+        docs[1]["fname"].should == "ralph"
+        docs[2]["fname"].should == "bill"
+      end
+
+      it "in asceneding order, by default" do
+        docs = @repo.get_many("test", nil)
+        docs[0]["fname"].should == "nancy"
+        docs[1]["fname"].should == "ralph"
+        docs[2]["fname"].should == "bill"
+      end
+
+      it "count" do
+        @repo.get_many("test", nil, {:count => true}).should == 3
+      end
+    end
+  end
+end

data/test/test_storage.rb

@@ -0,0 +1,264 @@
+require 'rubygems'
+require 'test/unit'
+require 'mongo'
+require 'lib/ruote-mongodb'
+
+#
+# note : using the 'errors' type, but this test is about generic storage, not
+#        about errors per se.
+#
+
+class UtStorage < Test::Unit::TestCase
+
+  def setup
+
+    # @s = determine_storage({})
+    @s = Ruote::MongoDbStorage.new
+
+    #@s.add_type('errors')
+
+    @s.put(
+      '_id' => 'toto',
+      'type' => 'errors',
+      'message' => 'testing')
+  end
+  def teardown
+
+    @s.get_many('errors').each do |d|
+      @s.delete(d)
+    end
+  end
+
+  def test_get_configuration
+
+    assert_not_nil @s.get_configuration('engine')
+  end
+
+  def test_get
+
+    h = @s.get('errors', 'toto')
+
+    assert_not_nil h['_rev']
+
+    h = @s.get('errors', 'nada')
+
+    assert_nil h
+  end
+
+  def test_put
+
+    doc =  {
+      '_id' => 'test_put', 'type' => 'errors', 'message' => 'testing (2)' }
+
+    @s.put(doc)
+
+    assert_nil doc['_rev']
+
+    h = @s.get('errors', 'test_put')
+
+    assert_not_nil h['_rev']
+    assert_not_nil h['put_at']
+  end
+
+  def test_put_fail
+
+    r = @s.put('_id' => 'toto', 'type' => 'errors', 'message' => 'more')
+
+    assert_equal 'toto', r['_id']
+    assert_not_nil r['_rev']
+  end
+
+  def test_put_update_rev
+
+    doc = { '_id' => 'tpur', 'type' => 'errors', 'message' => 'more' }
+
+    r = @s.put(doc, :update_rev => true)
+
+    assert_not_nil doc['_rev']
+  end
+
+  def test_put_put_and_put
+
+    doc = { '_id' => 'whiskas', 'type' => 'errors', 'message' => 'miam' }
+
+    r = @s.put(doc)
+    doc = @s.get('errors', 'whiskas')
+
+    r = @s.put(doc)
+    assert_nil r
+
+    doc = @s.get('errors', 'whiskas')
+
+    assert_not_nil doc['put_at']
+
+    r = @s.put(doc)
+    assert_nil r
+  end
+
+  def test_put_update_rev_twice
+
+    doc = { '_id' => 'tpurt', 'type' => 'errors', 'message' => 'more' }
+
+    r = @s.put(doc, :update_rev => true)
+    assert_nil r
+
+    doc = { '_id' => 'tpurt', 'type' => 'errors', 'message' => 'more' }
+
+    r = @s.put(doc, :update_rev => true)
+    assert_not_nil r
+  end
+
+  def test_delete_fail
+
+    # missing _rev
+
+    assert_raise(ArgumentError) do
+      @s.delete('_id' => 'toto')
+    end
+  end
+
+  def test_delete
+
+    doc = @s.get('errors', 'toto')
+    puts "test_delete: #{doc}"
+    r = @s.delete(doc)
+
+    assert_nil r
+  end
+
+  def test_delete_missing
+
+    r = @s.delete('_id' => 'x', '_rev' => '12-13231123132', 'type' => 'errors')
+
+    assert_equal true, r
+  end
+
+  def test_keys_should_be_string
+
+    doc = { '_id' => 'h0', 'type' => 'errors', :m0 => :z, :m1 => [ :a, :b ] }
+
+    @s.put(doc)
+
+    doc = @s.get('errors', 'h0')
+
+    assert_equal 'z', doc['m0']
+    assert_equal %w[ a b ], doc['m1']
+  end
+
+  # Updating a gone document must result in a 'true' reply.
+  #
+  def test_put_gone
+
+    h = @s.get('errors', 'toto')
+
+    assert_nil @s.delete(h)
+
+    h['colour'] = 'blue'
+
+    assert_equal true, @s.put(h)
+  end
+
+  def test_purge_type
+
+    @s.purge_type!('errors')
+
+    assert_equal 0, @s.get_many('errors').size
+  end
+
+  def test_clear
+
+    @s.clear
+
+    assert_equal 0, @s.get_many('errors').size
+  end
+
+  #def test_purge
+  #  @s.purge!
+  #  assert_equal 0, @s.get_many('errors').size
+  #end
+
+  def test_ids
+
+    @s.put('_id' => 't_ids0', 'type' => 'errors', 'message' => 'testing')
+    @s.put('_id' => 't_ids1', 'type' => 'errors', 'message' => 'testing')
+    @s.put('_id' => 't_ids2', 'type' => 'errors', 'message' => 'testing')
+
+    assert_equal %w[ t_ids0 t_ids1 t_ids2 toto ], @s.ids('errors').sort
+  end
+
+  def test_get_many
+
+    30.times do |i|
+      @s.put(
+        '_id' => "xx!#{i}",
+        'type' => 'errors',
+        'wfid' => i.to_s,
+        'msg' => "whatever #{i}")
+    end
+
+    assert_equal 31, @s.get_many('errors').size
+    assert_equal 1, @s.get_many('errors', '7').size
+    assert_equal 1, @s.get_many('errors', /!7$/).size
+    assert_equal 30, @s.get_many('errors', /^xx!/).size
+    assert_equal 30, @s.get_many('errors', /x/).size
+    assert_equal 10, @s.get_many('errors', nil, :limit => 10).size
+  end
+
+  def load_30_errors
+    30.times do |i|
+      @s.put(
+        '_id' => sprintf("yy!%0.2d", i),
+        'type' => 'errors',
+        'msg' => "whatever #{i}")
+    end
+  end
+
+  def test_get_many_options
+    load_30_errors
+
+    # limit
+
+    assert_equal 10, @s.get_many('errors', nil, :limit => 10).size
+
+    # count
+
+    assert_equal 31, @s.get_many('errors', nil, :count => true)
+
+    # skip and limit
+
+    assert_equal(
+      %w[ toto yy!00 yy!01 yy!02 ],
+      @s.get_many(
+        'errors', nil, :skip => 0, :limit => 4
+      ).collect { |d| d['_id'] })
+    assert_equal(
+      %w[ yy!02 yy!03 yy!04 ],
+      @s.get_many(
+        'errors', nil, :skip => 3, :limit => 3
+      ).collect { |d| d['_id'] })
+
+    # skip, limit and reverse
+
+    assert_equal(
+      %w[ yy!29 yy!28 yy!27 ],
+      @s.get_many(
+        'errors', nil, :skip => 0, :limit => 3, :descending => true
+      ).collect { |d| d['_id'] })
+    assert_equal(
+      %w[ yy!29 yy!28 yy!27 ],
+      @s.get_many(
+        'errors', nil, :skip => 0, :limit => 3, :descending => true
+      ).collect { |d| d['_id'] })
+  end
+
+#  def test_dump
+#    load_30_errors
+#    assert @s.dump('errors').length > 0
+#  end
+
+  def test_ids
+    load_30_errors
+    assert_equal 31, @s.ids('errors').length
+  end
+end
+

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification 
+name: ruote-mongodb
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Patrick Gannon
+- Nathan Stults
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-10 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mongo
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 1
+        - 1
+        - 1
+        version: 1.1.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bson
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 1
+        - 1
+        - 1
+        version: 1.1.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bson_ext
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 1
+        - 1
+        - 1
+        version: 1.1.1
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  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
+description: 
+email: 
+- hereiam@sonic.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/ruote-mongodb.rb
+- lib/ruote-mongodb/mongodb_storage.rb
+- test/test_storage.rb
+- spec/mongodb_storage_spec.rb
+- LICENSE
+- README
+has_rdoc: true
+homepage: http://github.com/PlasticLizard/ruote-mongodb
+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: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: MongoDB persistence for Ruote
+test_files: []
+