tinymongo 0.1.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Peter Jihoon Kim
+
+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.rdoc

@@ -0,0 +1,48 @@
+= TinyMongo
+
+Simple MongoDB wrapper
+
+== Install
+
+  gem install tinymongo
+
+== Rails Setup
+
+To create TinyMongo config file (config/tinymongo.yml), do the following:
+
+  rails generate tinymongo
+  
+== Connecting To MongoDB directly (for non-Rails projects)
+
+  TinyMongo.configure({:host => 'localhost', :database => 'test'})
+  TinyMongo.connect
+  
+== Example
+
+  class Person < TinyMongo::Model
+    mongo_collection :people  # optional if using Rails
+    mongo_key :name
+    mongo_key :age
+    mongo_key :children
+  
+    def make_child
+      child = Person.new(:name => 'Baby', :age => 0)
+    
+      self.push({:children => child})
+    end
+  
+    def grow_up
+      self.inc({:age => 1})
+    end
+    
+    def set_stuff(n,a,c)
+      name = n
+      age = a
+      children = c
+      save
+    end
+  end
+  
+== Copyright
+
+Copyright (c) 2010 Peter Jihoon Kim. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,30 @@
+require 'rake'
+require 'rake/testtask'
+
+begin
+  require 'jeweler'
+  
+  Jeweler::Tasks.new do |s|
+    s.name              = "tinymongo"
+    s.summary           = "Simple MongoDB wrapper"
+    s.description       = s.summary
+    s.homepage          = "http://github.com/petejkim/tinymongo"
+    s.authors           = ["Peter Jihoon Kim"]
+    s.email             = "raingrove@gmail.com"
+    s.add_dependency 'mongo'
+    s.add_dependency 'bson'
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler - or one of its dependencies - is not available. " <<
+  "Install it with: sudo gem install jeweler -s http://gemcutter.org"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/test_*.rb'
+  t.verbose = true
+end
+
+task :default => :test

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/init.rb

@@ -0,0 +1,4 @@
+require 'tinymongo'
+
+TinyMongo.configure(YAML.load_file(Rails.root + 'config' + 'tinymongo.yml')[Rails.env])
+TinyMongo.connect

data/lib/generators/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Creates TinyMongo config file
+
+Example:
+    rails generate tinymongo
+
+    This will create:
+        config/tinymongo.yml

data/lib/generators/templates/tinymongo.yml.erb

@@ -0,0 +1,23 @@
+development:
+  host: localhost
+  port:
+  options:
+  database: <%= application_name %>_development
+  username: 
+  password: 
+
+test: 
+  host: localhost
+  port:
+  options:
+  database: <%= application_name %>_test
+  username: 
+  password: 
+
+production:
+  host: localhost
+  port:
+  options:
+  database: <%= application_name %>_production
+  username: 
+  password: 

data/lib/generators/tinymongo_generator.rb

@@ -0,0 +1,16 @@
+class TinymongoGenerator < Rails::Generators::Base
+  source_root File.expand_path('../templates', __FILE__)
+  
+  def generate_config
+    template "tinymongo.yml.erb", "config/tinymongo.yml"
+  end
+  
+  private
+  def application_name # from Rails::Generators::NamedBase
+    if defined?(Rails) && Rails.application
+      Rails.application.class.name.split('::').first.underscore
+    else
+      "application"
+    end
+  end
+end

data/lib/tinymongo/helper.rb

@@ -0,0 +1,62 @@
+module TinyMongo
+  module Helper
+    class << self
+      def stringify_keys_in_hash(hash)
+        new_hash = {}
+        hash.each_pair { |key, value| new_hash[key.to_s] = value }
+        new_hash['_id'] = bson_object_id(new_hash['_id']) if(new_hash['_id'])
+        new_hash
+      end
+
+      def symbolify_keys_in_hash(hash)
+        new_hash = {}
+        hash.each_pair { |key, value| new_hash[key.to_sym] = value }
+        new_hash[:_id] = bson_object_id(new_hash[:_id]) if(new_hash[:_id])
+        new_hash
+      end
+      
+      def hashify_models_in(obj)
+        if(obj.instance_of? Hash)
+          hashify_models_in_hash(obj)
+        elsif(obj.instance_of? Array)
+          hashify_models_in_array(obj)
+        elsif(obj.kind_of? TinyMongo::Model)
+          obj.to_hash
+        else
+          obj
+        end
+      end
+      
+      def hashify_models_in_array(array)
+        new_array = []
+        array.each do |value|
+          new_array << hashify_models_in(value)
+        end
+        new_array
+      end
+      
+      def hashify_models_in_hash(hash)
+        new_hash = {}
+        hash.each_pair do |key,value|
+          key_s = key.to_s
+          if(key_s == '_id')
+            new_hash[key_s] = bson_object_id(value)
+          else
+            new_hash[key_s] = hashify_models_in(value)
+          end
+        end
+        new_hash
+      end
+      
+      def bson_object_id(id)
+        if(id.instance_of? BSON::ObjectID)
+          id
+        elsif(id.instance_of? String)
+          BSON::ObjectID(id)
+        else
+          BSON::ObjectID(id.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/tinymongo/model.rb

@@ -0,0 +1,276 @@
+module TinyMongo
+  class Model
+    class << self
+      def mongo_key(*args)
+        args.each do |key_name|
+          if([Symbol, String].include? key_name.class)
+            key_name_s = key_name.to_s
+            key_name_sym = key_name.to_sym
+
+            define_method(key_name_sym) do
+              instance_variable_get("@_tinymongo_hash")[key_name_s]
+            end
+
+            define_method("#{key_name_s}=".to_sym) do |val|
+              instance_variable_get("@_tinymongo_hash")[key_name_s] = val
+            end
+          end
+        end
+      end
+      
+      def mongo_collection(name)
+        @_tinymongo_collection_name = name.to_s
+      end
+      
+      def db
+        TinyMongo.db
+      end
+
+      def collection
+        if @_tinymongo_collection_name
+          TinyMongo.db[@_tinymongo_collection_name]
+        elsif(defined?(Rails))
+          TinyMongo.db[self.to_s.gsub('/','_').tableize]
+        else
+          TinyMongo.db[self.to_s]
+        end
+      end
+      
+      def find(*args)
+        new_args = []
+        args.each do |arg|
+          new_args << Helper.hashify_models_in(arg)
+        end
+        collection.find(*new_args)
+      end
+
+      def find_one(*args)
+        if([BSON::ObjectID, String].include? args[0].class)
+          self.new(collection.find_one({'_id' => Helper.bson_object_id(args[0])}))
+        else
+          self.new(collection.find_one(*args))
+        end
+      end
+
+      def create(hash)
+        obj = self.new(hash)
+        obj.save
+      end
+      
+      def delete(id)
+        collection.remove({ '_id' => Helper.bson_object_id(id)})
+      end
+
+      def delete_all
+        collection.drop
+      end
+      
+      def destroy_all
+        delete_all
+      end
+
+      def count
+        collection.count
+      end
+    end
+    
+    def _id
+      @_tinymongo_hash['_id']
+    end
+    
+    def _id=(val)
+      @_tinymongo_hash['_id'] = Helper.bson_object_id(val)
+    end
+  
+    def initialize(hash={})
+      @_tinymongo_hash = Helper.stringify_keys_in_hash(hash)
+    end
+    
+    def db
+      self.db
+    end
+  
+    def collection
+      self.class.collection
+    end
+    
+    def to_hash
+      @_tinymongo_hash.clone
+    end
+  
+    def save(v=true)
+      
+      if((v && (defined?(Rails) && self.valid?) || (!defined?(Rails))) || (!v))
+        begin
+          obj = create_or_update
+          return obj
+        rescue
+          return false
+        end
+      else
+        return false
+      end
+    end
+  
+    def update_attribute(name, value)
+      send(name.to_s + '=', value)
+      save(false)
+    end
+  
+    def update_attributes(hash)
+      hash.each_pair { |key, value| send(key.to_s + '=', value) }
+      save
+    end
+  
+    def delete
+      if(@_tinymongo_hash['_id'])
+        collection.remove({ '_id' => @_tinymongo_hash['_id'] })
+      end
+    end
+  
+    def destroy
+      delete
+    end
+  
+    def destroy(id)
+      delete(id)
+    end
+  
+    def inc(hash)
+      hash.each_pair do |key, value|
+        key = key.to_s
+        
+        if(@_tinymongo_hash[key] && (@_tinymongo_hash[key].kind_of? Numeric))
+          send(key + '=', (send(key) + value))
+        else
+          send(key + '=', value)
+        end
+      end
+    
+      if(@_tinymongo_hash['_id'])
+        collection.update({ '_id' => @_tinymongo_hash['_id'] }, { '$inc' => Helper.hashify_models_in_hash(hash) })
+      end
+    end
+  
+    def set(hash)
+      hash.each_pair { |key, value| send(key.to_s + '=', value) }
+    
+      if(@_tinymongo_hash['_id'])
+        collection.update({ '_id' => @_tinymongo_hash['_id'] }, { '$set' => Helper.hashify_models_in_hash(hash) })
+      end
+    end
+  
+    def unset(hash)
+      hash.each_key do |key| 
+        @_tinymongo_hash.delete(key.to_s)
+      end
+    
+      if(@_tinymongo_hash['_id'])
+        collection.update({ '_id' => @_tinymongo_hash['_id'] }, { '$unset' => Helper.hashify_models_in_hash(hash) })
+      end
+    end
+  
+    def push(hash)
+      hash.each_pair do |key, value|
+        key = key.to_s
+        
+        if(@_tinymongo_hash[key] && (@_tinymongo_hash[key].instance_of? Array))
+          send(key) << value
+        else
+          send(key + '=', value)
+        end
+      end
+    
+      if(@_tinymongo_hash['_id'])
+        collection.update({ '_id' => @_tinymongo_hash['_id'] }, { '$push' => Helper.hashify_models_in_hash(hash) })
+      end
+    end
+  
+    def push_all(hash)
+      hash.each_pair do |key, value|
+        key = key.to_s
+        
+        if(@_tinymongo_hash[key] && (@_tinymongo_hash[key].instance_of? Array))
+          value.each { |v| send(key) << value }
+        else
+          send(key + '=', value)
+        end
+      end
+
+      if(@_tinymongo_hash['_id'])
+        collection.update({ '_id' => @_tinymongo_hash['_id'] }, { '$pushAll' => Helper.hashify_models_in_hash(hash) })
+      end
+    end
+  
+    def add_to_set(hash)
+      hash.each_pair do |key, value|
+        key = key.to_s
+        
+        if(!(@_tinymongo_hash[key].include? value) && (@_tinymongo_hash[key].instance_of? Array))
+          send(key) << value
+        end
+      end
+    
+      if(@_tinymongo_hash['_id'])
+        collection.update({ '_id' => @_tinymongo_hash['_id'] }, { '$addToSet' => Helper.hashify_models_in_hash(hash) })
+      end
+    end
+  
+    def pop(hash)
+      hash.each_pair do |key, value|
+        key = key.to_s
+
+        if(@_tinymongo_hash[key] && (@_tinymongo_hash[key].instance_of? Array))
+          if(value == 1)
+            send(key).pop
+          elsif(value == -1)
+            send(key).shift
+          end
+        end
+      end
+    
+      if(@_tinymongo_hash['_id'])
+        collection.update({ '_id' => @_tinymongo_hash['_id'] }, { '$pop' => Helper.hashify_models_in_hash(hash) })
+      end
+    end
+  
+    def pull(hash)
+      hash.each_pair do |key, value|
+        key = key.to_s
+        if(@_tinymongo_hash[key] && (@_tinymongo_hash[key].instance_of? Array))
+          send(key).delete_if { |v| v == value }
+        end
+      end
+    
+      if(@_tinymongo_hash['_id'])
+        collection.update({ '_id' => @_tinymongo_hash['_id'] }, { '$pull' => Helper.hashify_models_in_hash(hash) })
+      end
+    end
+  
+    def pull_all(hash)
+      hash.each_pair do |key, value|
+        key = key.to_s
+        if(@_tinymongo_hash[key] && (@_tinymongo_hash[key].instance_of? Array))
+          value.each do |v|
+            send(key).delete_if { |w| w == v }
+          end
+        end
+      end
+    
+      if(@_tinymongo_hash['_id'])
+        collection.update({ '_id' => @_tinymongo_hash['_id'] }, { '$pullAll' => Helper.hashify_models_in_hash(hash) })
+      end
+    end
+  
+    protected  
+    def create_or_update
+      if(@_tinymongo_hash['_id'].nil?) # new 
+        @_tinymongo_hash['_id'] = collection.save(@_tinymongo_hash)
+      else # update
+        collection.update({ '_id' => @_tinymongo_hash['_id'] }, @_tinymongo_hash)
+      end
+      return self
+    end
+
+  end
+end

data/lib/tinymongo.rb

@@ -0,0 +1,43 @@
+require 'mongo'
+
+module TinyMongo
+  class << self
+    def configure(config)
+      config = Helper.stringify_keys_in_hash(config)
+    
+      @host = config['host'] || 'localhost'
+      @port = config['port']
+      @options = config['options'] || {}
+      @database = config['database'] || 'mongo'
+      @username = config['username']
+      @password = config['password']
+    end
+  
+    def db
+      @db
+    end
+
+    def connect
+      if defined?(PhusionPassenger) && @connection
+        PhusionPassenger.on_event(:starting_worker_process) do |forked|
+          @connection.connect_to_master if forked
+        end
+      end
+        
+      if(@connection.nil?)
+        @connection = Mongo::Connection.new(@host, @port, @options)
+        @db = @connection.db(@database)
+
+        if(@username && @password) 
+          auth = db.authenticate(@username, @password)
+          return nil unless(auth)
+        end
+      end
+      
+      true
+    end
+  end
+end
+
+require 'tinymongo/helper'
+require 'tinymongo/model'

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require 'tinymongo'

data/test/test_tinymongo.rb

@@ -0,0 +1,232 @@
+$: << (File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require 'test_helper'
+
+TinyMongo.configure({:host => 'localhost', :database => 'tinymongo_test'})
+TinyMongo.connect
+
+class Dummy < TinyMongo::Model
+  mongo_collection :dummies
+  mongo_key :foo
+  mongo_key :bar
+end
+
+class TinyMongoTest < Test::Unit::TestCase
+  def setup
+    TinyMongo.db['dummies'].drop()
+  end
+  
+  def test_helper_stringify_keys_in_hash
+    hash = {:foo => 'hello', :bar => 'world'}
+    assert_equal({'foo' => 'hello', 'bar' => 'world'}, TinyMongo::Helper.stringify_keys_in_hash(hash))
+  end
+
+  def test_helper_symbolify_keys_in_hash
+    hash = {'foo' => 'hello', 'bar' => 'world'}
+    assert_equal({:foo => 'hello', :bar => 'world'}, TinyMongo::Helper.symbolify_keys_in_hash(hash))
+  end
+  
+  def test_helper_hashify_models_in_hash
+    obj1 = Dummy.new(:foo => 'hello', :bar => 'world')
+    obj2 = Dummy.new(:foo => 'love', :bar => 'ek')
+    hash = { :obj1 => obj1, :obj2 => obj2, :hash => { :obj => obj1 }, :array => [obj1, obj2, 'yay'], :val => 'pete' }
+    assert_equal({ 'obj1'  => { 'foo' => 'hello', 'bar' => 'world' }, 
+                   'obj2'  => { 'foo' => 'love', 'bar' => 'ek' },
+                   'hash'  => { 'obj' => { 'foo' => 'hello', 'bar' => 'world' } },
+                   'array' => [ { 'foo' => 'hello', 'bar' => 'world' }, { 'foo' => 'love', 'bar' => 'ek' }, 'yay' ],
+                   'val'   => 'pete' },
+                 TinyMongo::Helper.hashify_models_in_hash(hash))
+  end
+  
+  def test_helper_hashify_models_in_array
+    obj1 = Dummy.new(:foo => 'hello', :bar => 'world')
+    obj2 = Dummy.new(:foo => 'love', :bar => 'ek')
+    array = [ obj1, obj2, { :obj => obj1 }, [obj1, obj2, 'yay'], 'pete' ]
+    assert_equal([ { 'foo' => 'hello', 'bar' => 'world' }, 
+                   { 'foo' => 'love', 'bar' => 'ek' },
+                   { 'obj' => { 'foo' => 'hello', 'bar' => 'world' } },
+                   [ { 'foo' => 'hello', 'bar' => 'world' }, { 'foo' => 'love', 'bar' => 'ek' }, 'yay' ],
+                   'pete' ],
+                 TinyMongo::Helper.hashify_models_in_array(array))
+  end
+  
+  def test_mongo_key
+    m = Dummy.new('foo' => 'hello')
+    m.bar = 'world'
+    
+    assert_equal 'hello', m.foo
+    assert_equal 'world', m.bar
+  end
+  
+  def test_save_new
+    hash = {'foo' => 'hello', 'bar' => 'world'}
+    
+    obj = Dummy.new(hash) 
+    obj.save # save to db
+    hash['_id'] = obj._id # add _id to hash
+    result = TinyMongo.db['dummies'].find_one({'_id' => obj._id})
+    assert_equal TinyMongo::Helper.stringify_keys_in_hash(hash), result # compare
+  end
+  
+  def test_create
+    hash = {'foo' => 'hello', 'bar' => 'world'}
+    
+    obj = Dummy.create(hash) # save to db
+    hash['_id'] = obj._id # add _id to hash
+    
+    result = TinyMongo.db['dummies'].find_one({'_id' => obj._id})
+    assert_equal TinyMongo::Helper.stringify_keys_in_hash(hash), result, result # compare
+  end
+
+  def test_save_update
+    obj = Dummy.create('foo' => 'hello') 
+    obj.foo = 'bye'
+    obj.save
+    
+    result = TinyMongo.db['dummies'].find_one({'_id' => obj._id})
+    assert_equal 'bye', result['foo']
+  end
+  
+  def test_update_attribute
+    obj = Dummy.create('foo' => 'hello') 
+    obj.update_attribute('foo', 'bye')
+    
+    result = TinyMongo.db['dummies'].find_one({'_id' => obj._id})
+    assert_equal 'bye', result['foo']
+  end
+  
+  def test_update_attributes
+    obj = Dummy.create('foo' => 'hello', 'bar' => 'world') 
+    obj.update_attributes({'foo' => 'world', 'bar' => 'hello'})
+    
+    result = TinyMongo.db['dummies'].find_one({'_id' => obj._id})
+    assert_equal 'world', result['foo']
+    assert_equal 'hello', result['bar']
+  end
+  
+  def test_find_one_using_id
+    o_id = TinyMongo.db['dummies'].save({'foo' => 'hello'})
+    
+    found = Dummy.find_one(o_id)
+    
+    assert_equal 'hello', found.foo
+    assert_equal o_id, found._id
+  end
+  
+  def test_find_one_using_id_string
+    o_id = TinyMongo.db['dummies'].save({'foo' => 'hello'})
+    
+    found = Dummy.find_one(o_id.to_s)
+    
+    assert_equal 'hello', found.foo
+    assert_equal o_id, found._id
+  end
+
+  def test_find_one_using_hash
+    o_id = TinyMongo.db['dummies'].save({'foo' => 'hello', 'bar' => 'world'})
+    
+    found = Dummy.find_one({'foo' => 'hello'})
+    
+    assert_equal 'hello', found.foo
+    assert_equal 'world', found.bar
+    assert_equal o_id, found._id
+  end
+  
+  def test_count
+    Dummy.create('foo' => 'hello')
+    Dummy.create('foo' => 'hello')
+    Dummy.create('foo' => 'hello')
+    
+    assert_equal 3, Dummy.count
+  end
+  
+  def test_delete
+    obj = Dummy.create('foo' => 'hello')
+    assert_equal 1, Dummy.count
+    obj.delete
+    assert_equal 0, Dummy.count
+  end
+  
+  def test_delete_using_id
+    obj = Dummy.create('foo' => 'hello')
+    assert_equal 1, Dummy.count
+    Dummy.delete(obj._id)
+    assert_equal 0, Dummy.count
+  end
+  
+  def test_delete_all
+    Dummy.create('foo' => 'hello')
+    Dummy.create('foo' => 'hello')
+    Dummy.create('foo' => 'hello')
+    assert_equal 3, Dummy.count
+    Dummy.delete_all
+    assert_equal 0, Dummy.count
+  end
+  
+  def test_inc
+    d = Dummy.create('foo' => 1)
+    assert_equal 1, TinyMongo.db['dummies'].find_one()['foo']
+    d.inc({'foo' => 1})
+    assert_equal 2, TinyMongo.db['dummies'].find_one()['foo']
+  end
+
+  def test_set
+    d = Dummy.create('foo' => 'hello')
+    assert_equal 'hello', TinyMongo.db['dummies'].find_one()['foo']
+    d.set({'foo' => 'bye'})
+    assert_equal 'bye', TinyMongo.db['dummies'].find_one()['foo']
+  end
+
+  def test_unset
+    d = Dummy.create('foo' => 'hello')
+    assert_equal 'hello', TinyMongo.db['dummies'].find_one()['foo']
+    d.unset({'foo' => 1})
+    assert_equal nil, TinyMongo.db['dummies'].find_one()['foo']
+  end
+
+  def test_push
+    d = Dummy.create('foo' => [])
+    assert_equal [], TinyMongo.db['dummies'].find_one()['foo']
+    d.push({'foo' => 'hello'})
+    assert_equal ['hello'], TinyMongo.db['dummies'].find_one()['foo']
+  end
+
+  def test_push_all
+    d = Dummy.create('foo' => [])
+    assert_equal [], TinyMongo.db['dummies'].find_one()['foo']
+    d.push_all({'foo' => ['hello','world']})
+    assert_equal ['hello', 'world'], TinyMongo.db['dummies'].find_one()['foo']
+  end
+
+  def test_add_to_set
+    d = Dummy.create('foo' => [1,2,3,4])
+    assert_equal [1,2,3,4], TinyMongo.db['dummies'].find_one()['foo']
+    d.add_to_set({'foo' => 1})
+    assert_equal [1,2,3,4], TinyMongo.db['dummies'].find_one()['foo']
+    d.add_to_set({'foo' => 5})
+    assert_equal [1,2,3,4,5], TinyMongo.db['dummies'].find_one()['foo']
+  end
+
+  def test_pop
+    d = Dummy.create('foo' => [1,2,3,4])
+    assert_equal [1,2,3,4], TinyMongo.db['dummies'].find_one()['foo']
+    d.pop({'foo' => 1})
+    assert_equal [1,2,3], TinyMongo.db['dummies'].find_one()['foo']
+    d.pop({'foo' => -1})
+    assert_equal [2,3], TinyMongo.db['dummies'].find_one()['foo']
+  end
+
+  def test_pull
+    d = Dummy.create('foo' => [1,1,2,2,2,3])
+    assert_equal [1,1,2,2,2,3], TinyMongo.db['dummies'].find_one()['foo']
+    d.pull({'foo' => 2})
+    assert_equal [1,1,3], TinyMongo.db['dummies'].find_one()['foo']
+  end
+
+  def test_pull_all
+    d = Dummy.create('foo' => [1,1,2,2,2,3])
+    assert_equal [1,1,2,2,2,3], TinyMongo.db['dummies'].find_one()['foo']
+    d.pull_all({'foo' => [1,2]})
+    assert_equal [3], TinyMongo.db['dummies'].find_one()['foo']
+  end
+  
+end

data/tinymongo.gemspec

@@ -0,0 +1,61 @@
+# 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{tinymongo}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Peter Jihoon Kim"]
+  s.date = %q{2010-07-21}
+  s.description = %q{Simple MongoDB wrapper}
+  s.email = %q{raingrove@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "init.rb",
+     "lib/generators/USAGE",
+     "lib/generators/templates/tinymongo.yml.erb",
+     "lib/generators/tinymongo_generator.rb",
+     "lib/tinymongo.rb",
+     "lib/tinymongo/helper.rb",
+     "lib/tinymongo/model.rb",
+     "test/test_helper.rb",
+     "test/test_tinymongo.rb",
+     "tinymongo.gemspec"
+  ]
+  s.homepage = %q{http://github.com/petejkim/tinymongo}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Simple MongoDB wrapper}
+  s.test_files = [
+    "test/test_helper.rb",
+     "test/test_tinymongo.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<mongo>, [">= 0"])
+      s.add_runtime_dependency(%q<bson>, [">= 0"])
+    else
+      s.add_dependency(%q<mongo>, [">= 0"])
+      s.add_dependency(%q<bson>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<mongo>, [">= 0"])
+    s.add_dependency(%q<bson>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: tinymongo
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Peter Jihoon Kim
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-21 00:00:00 +09: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 
+        segments: 
+        - 0
+        version: "0"
+  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 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: Simple MongoDB wrapper
+email: raingrove@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- init.rb
+- lib/generators/USAGE
+- lib/generators/templates/tinymongo.yml.erb
+- lib/generators/tinymongo_generator.rb
+- lib/tinymongo.rb
+- lib/tinymongo/helper.rb
+- lib/tinymongo/model.rb
+- test/test_helper.rb
+- test/test_tinymongo.rb
+- tinymongo.gemspec
+has_rdoc: true
+homepage: http://github.com/petejkim/tinymongo
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Simple MongoDB wrapper
+test_files: 
+- test/test_helper.rb
+- test/test_tinymongo.rb