bson 1.0.4 → 1.0.5

data/Rakefile

@@ -58,23 +58,48 @@ namespace :test do
     t.verbose    = true
   end
 
-  Rake::TestTask.new(:pair_count) do |t|
-    t.test_files = FileList['test/replica/count_test.rb']
+  Rake::TestTask.new(:replica_pair_count) do |t|
+    t.test_files = FileList['test/replica_pairs/count_test.rb']
     t.verbose    = true
   end
 
-  Rake::TestTask.new(:pair_insert) do |t|
-    t.test_files = FileList['test/replica/insert_test.rb']
+  Rake::TestTask.new(:replica_pair_insert) do |t|
+    t.test_files = FileList['test/replica_pairs/insert_test.rb']
     t.verbose    = true
   end
 
-  Rake::TestTask.new(:pooled_pair_insert) do |t|
-    t.test_files = FileList['test/replica/pooled_insert_test.rb']
+  Rake::TestTask.new(:pooled_replica_pair_insert) do |t|
+    t.test_files = FileList['test/replica_pairs/pooled_insert_test.rb']
     t.verbose    = true
   end
 
-  Rake::TestTask.new(:pair_query) do |t|
-    t.test_files = FileList['test/replica/query_test.rb']
+  Rake::TestTask.new(:replica_pair_query) do |t|
+    t.test_files = FileList['test/replica_pairs/query_test.rb']
+    t.verbose    = true
+  end
+
+  Rake::TestTask.new(:replica_set_count) do |t|
+    t.test_files = FileList['test/replica_sets/count_test.rb']
+    t.verbose    = true
+  end
+
+  Rake::TestTask.new(:replica_set_insert) do |t|
+    t.test_files = FileList['test/replica_sets/insert_test.rb']
+    t.verbose    = true
+  end
+
+  Rake::TestTask.new(:pooled_replica_set_insert) do |t|
+    t.test_files = FileList['test/replica_sets/pooled_insert_test.rb']
+    t.verbose    = true
+  end
+
+  Rake::TestTask.new(:replica_set_query) do |t|
+    t.test_files = FileList['test/replica_sets/query_test.rb']
+    t.verbose    = true
+  end
+
+  Rake::TestTask.new(:replica_set_ack) do |t|
+    t.test_files = FileList['test/replica_sets/replication_ack_test.rb']
     t.verbose    = true
   end
 

data/bson.gemspec

@@ -1,4 +1,4 @@
-require "lib/bson"
+require "./lib/bson"
 
 Gem::Specification.new do |s|
   s.name = 'bson'

data/lib/bson.rb

@@ -2,10 +2,10 @@
 
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
-MINIMUM_BSON_EXT_VERSION = "1.0.4"
+MINIMUM_BSON_EXT_VERSION = "1.0.5"
 
 module BSON
-  VERSION = "1.0.4"
+  VERSION = "1.0.5"
   def self.serialize(obj, check_keys=false, move_id=false)
     BSON_CODER.serialize(obj, check_keys, move_id)
   end
@@ -60,6 +60,7 @@ require 'bson/types/binary'
 require 'bson/types/code'
 require 'bson/types/dbref'
 require 'bson/types/objectid'
+require 'bson/types/object_id'
 require 'bson/types/min_max_keys'
 
 require 'base64'

data/lib/bson/bson_ruby.rb

@@ -89,6 +89,7 @@ module BSON
     end
 
     def serialize(obj, check_keys=false, move_id=false)
+      raise(InvalidDocument, "BSON.serialize takes a Hash but got a #{obj.class}") unless obj.is_a?(Hash)
       raise "Document is null" unless obj
 
       @buf.rewind
@@ -360,7 +361,7 @@ module BSON
     end
 
     def deserialize_oid_data(buf)
-      ObjectID.new(buf.get(12))
+      ObjectId.new(buf.get(12))
     end
 
     def deserialize_dbref_data(buf)
@@ -562,6 +563,8 @@ module BSON
         REGEX
       when ObjectID
         OID
+      when ObjectId
+        OID
       when DBRef
         REF
       when true, false

data/lib/bson/exceptions.rb

@@ -32,6 +32,9 @@ module BSON
   # Raised when attempting to initialize an invalid ObjectID.
   class InvalidObjectID < BSONError; end
 
+  # Raised when attempting to initialize an invalid ObjectID.
+  class InvalidObjectId < BSONError; end
+
   # Raised when trying to insert a document that exceeds the 4MB limit or
   # when the document contains objects that can't be serialized as BSON.
   class InvalidDocument < BSONError; end

data/lib/bson/ordered_hash.rb

@@ -129,6 +129,12 @@ module BSON
         }
       end
 
+      def reject(&block)
+        clone = self.clone
+        return clone unless block_given?
+        clone.delete_if &block
+      end
+
       def clear
         super
         @ordered_set.clear

data/lib/bson/types/binary.rb

@@ -26,9 +26,10 @@ module BSON
   # Use this class when storing binary data in documents.
   class Binary < ByteBuffer
 
-    SUBTYPE_BYTES = 0x02
-    SUBTYPE_UUID = 0x03
-    SUBTYPE_MD5 = 0x05
+    SUBTYPE_SIMPLE = 0x00
+    SUBTYPE_BYTES  = 0x02
+    SUBTYPE_UUID   = 0x03
+    SUBTYPE_MD5    = 0x05
     SUBTYPE_USER_DEFINED = 0x80
 
     # One of the SUBTYPE_* constants. Default is SUBTYPE_BYTES.

data/lib/bson/types/object_id.rb

@@ -0,0 +1,184 @@
+# encoding: UTF-8
+
+# --
+# Copyright (C) 2008-2010 10gen Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+
+require 'thread'
+require 'socket'
+require 'digest/md5'
+
+module BSON
+
+  def BSON::ObjectId(s)
+    ObjectId.from_string(s)
+  end
+
+  # Generates MongoDB object ids.
+  #
+  # @core objectids
+  class ObjectId
+    @@lock  = Mutex.new
+    @@index = 0
+
+    # Create a new object id. If no parameter is given, an id corresponding
+    # to the ObjectId BSON data type will be created. This is a 12-byte value
+    # consisting of a 4-byte timestamp, a 3-byte machine id, a 2-byte process id,
+    # and a 3-byte counter.
+    #
+    # @param [Array] data should be an array of bytes. If you want
+    #   to generate a standard MongoDB object id, leave this argument blank.
+    def initialize(data=nil)
+      @data = data || generate
+    end
+
+    # Determine if the supplied string is legal. Legal strings will
+    # consist of 24 hexadecimal characters.
+    #
+    # @param [String] str
+    #
+    # @return [Boolean]
+    def self.legal?(str)
+      len = 24
+      str =~ /([0-9a-f]+)/i
+      match = $1
+      str && str.length == len && match == str
+    end
+
+    # Create an object id from the given time. This is useful for doing range
+    # queries; it works because MongoDB's object ids begin
+    # with a timestamp.
+    #
+    # @param [Time] time a utc time to encode as an object id.
+    #
+    # @return [Mongo::ObjectId]
+    #
+    # @example Return all document created before Jan 1, 2010.
+    #   time = Time.utc(2010, 1, 1)
+    #   time_id = ObjectId.from_time(time)
+    #   collection.find({'_id' => {'$lt' => time_id}})
+    def self.from_time(time)
+      self.new([time.to_i,0,0].pack("NNN").unpack("C12"))
+    end
+
+    # Adds a primary key to the given document if needed.
+    #
+    # @param [Hash] doc a document requiring an _id.
+    #
+    # @return [Mongo::ObjectId, Object] returns a newly-created or 
+    #   current _id for the given document.
+    def self.create_pk(doc)
+      doc.has_key?(:_id) || doc.has_key?('_id') ? doc : doc.merge!(:_id => self.new)
+    end
+
+    # Check equality of this object id with another.
+    #
+    # @param [Mongo::ObjectId] object_id
+    def eql?(object_id)
+      @data == object_id.instance_variable_get("@data")
+    end
+    alias_method :==, :eql?
+
+    # Get a unique hashcode for this object.
+    # This is required since we've defined an #eql? method.
+    #
+    # @return [Integer]
+    def hash
+      @data.hash
+    end
+
+    # Get an array representation of the object id.
+    #
+    # @return [Array]
+    def to_a
+      @data.dup
+    end
+
+    # Given a string representation of an ObjectId, return a new ObjectId
+    # with that value.
+    #
+    # @param [String] str
+    #
+    # @return [Mongo::ObjectId]
+    def self.from_string(str)
+      raise InvalidObjectId, "illegal ObjectId format" unless legal?(str)
+      data = []
+      12.times do |i|
+        data[i] = str[i * 2, 2].to_i(16)
+      end
+      self.new(data)
+    end
+
+    # Get a string representation of this object id.
+    #
+    # @return [String]
+    def to_s
+      str = ' ' * 24
+      12.times do |i|
+        str[i * 2, 2] = '%02x' % @data[i]
+      end
+      str
+    end
+
+    def inspect
+      "BSON::ObjectId('#{to_s}')"
+    end
+
+    # Convert to MongoDB extended JSON format. Since JSON includes type information,
+    # but lacks an ObjectId type, this JSON format encodes the type using an $oid key.
+    #
+    # @return [String] the object id represented as MongoDB extended JSON.
+    def to_json(*a)
+      "{\"$oid\": \"#{to_s}\"}"
+    end
+
+    # Return the UTC time at which this ObjectId was generated. This may
+    # be used in lieu of a created_at timestamp since this information
+    # is always encoded in the object id.
+    #
+    # @return [Time] the time at which this object was created.
+    def generation_time
+      Time.at(@data.pack("C4").unpack("N")[0]).utc
+    end
+
+    private
+
+    # This gets overwritten by the C extension if it loads.
+    def generate
+      oid = ''
+
+      # 4 bytes current time
+      time = Time.new.to_i
+      oid += [time].pack("N")
+
+      # 3 bytes machine
+      oid += Digest::MD5.digest(Socket.gethostname)[0, 3]
+
+      # 2 bytes pid
+      oid += [Process.pid % 0xFFFF].pack("n")
+
+      # 3 bytes inc
+      oid += [get_inc].pack("N")[1, 3]
+
+      oid.unpack("C12")
+    end
+
+    def get_inc
+      @@lock.synchronize do
+        @@index = (@@index + 1) % 0xFFFFFF
+      end
+    end
+  end
+end

data/lib/bson/types/objectid.rb

@@ -33,6 +33,8 @@ module BSON
     @@lock  = Mutex.new
     @@index = 0
 
+    # @deprecated
+    #
     # Create a new object id. If no parameter is given, an id corresponding
     # to the ObjectID BSON data type will be created. This is a 12-byte value
     # consisting of a 4-byte timestamp, a 3-byte machine id, a 2-byte process id,
@@ -41,6 +43,7 @@ module BSON
     # @param [Array] data should be an array of bytes. If you want
     #   to generate a standard MongoDB object id, leave this argument blank.
     def initialize(data=nil)
+      warn "BSON::ObjectID is deprecated. Please use BSON::ObjectId instead."
       @data = data || generate
     end
 
@@ -155,26 +158,24 @@ module BSON
 
     private
 
-    # We need to define this method only if CBson isn't loaded.
-    unless defined? CBson
-      def generate
-        oid = ''
+    # This gets overwritten by the C extension if it loads.
+    def generate
+      oid = ''
 
-        # 4 bytes current time
-        time = Time.new.to_i
-        oid += [time].pack("N")
+      # 4 bytes current time
+      time = Time.new.to_i
+      oid += [time].pack("N")
 
-        # 3 bytes machine
-        oid += Digest::MD5.digest(Socket.gethostname)[0, 3]
+      # 3 bytes machine
+      oid += Digest::MD5.digest(Socket.gethostname)[0, 3]
 
-        # 2 bytes pid
-        oid += [Process.pid % 0xFFFF].pack("n")
+      # 2 bytes pid
+      oid += [Process.pid % 0xFFFF].pack("n")
 
-        # 3 bytes inc
-        oid += [get_inc].pack("N")[1, 3]
+      # 3 bytes inc
+      oid += [get_inc].pack("N")[1, 3]
 
-        oid.unpack("C12")
-      end
+      oid.unpack("C12")
     end
 
     def get_inc

data/test/mongo_bson/bson_test.rb

@@ -22,6 +22,20 @@ class BSONTest < Test::Unit::TestCase
 
   include BSON
 
+  def test_require_hash
+    assert_raise_error InvalidDocument, "takes a Hash" do
+      BSON.serialize('foo')
+    end
+
+    assert_raise_error InvalidDocument, "takes a Hash" do
+      BSON.serialize(Object.new)
+    end
+
+    assert_raise_error InvalidDocument, "takes a Hash" do
+      BSON.serialize(Set.new)
+    end
+  end
+
   def test_read_bson_io_document
     doc = {'doc' => 'hello, world'}
     bson = BSON.serialize(doc)
@@ -309,6 +323,18 @@ class BSONTest < Test::Unit::TestCase
     assert_equal Binary::SUBTYPE_USER_DEFINED, bin2.subtype
   end
 
+  def test_binary_binary_subtype_0
+    bin = Binary.new([1, 2, 3, 4, 5], Binary::SUBTYPE_SIMPLE)
+
+    doc = {'bin' => bin}
+    bson = BSON::BSON_CODER.serialize(doc)
+    doc2 = BSON::BSON_CODER.deserialize(bson)
+    bin2 = doc2['bin']
+    assert_kind_of Binary, bin2
+    assert_equal [1, 2, 3, 4, 5], bin2.to_a
+    assert_equal Binary::SUBTYPE_SIMPLE, bin2.subtype
+  end
+
   def test_binary_byte_buffer
     bb = Binary.new
     5.times { |i| bb.put(i + 1) }

data/test/mongo_bson/jruby_bson_test.rb

@@ -98,22 +98,6 @@ class BSONTest < Test::Unit::TestCase
     assert_doc_pass({'foo' => :bar})
   end
 
-#  def test_binary
-#    doc = {'foo' => BSON::Binary.new("A".unpack("C*"))}
-#    #doc = assert_doc_pass({'foo' => BSON::Binary.new("A".unpack("C*"))})
-#    puts "First"
-#    p doc.to_a
-#    bson = @coder.serialize(doc)
-#    de = @coder.deserialize(bson)
-#    puts "Second"
-#    p de.to_a
-#    puts "subtype"
-#    p de['foo'].subtype
-#    puts "data"
-#    p de['foo'].data
-#    assert_equal doc, de
-#  end
-
   def test_valid_utf8_string
     doc = {'doc' => 'aé'}
     bson = bson = BSON::BSON_CODER.serialize(doc)
@@ -157,6 +141,7 @@ class BSONTest < Test::Unit::TestCase
     doc["c"] = 3
     doc["d"] = 4
     bson = BSON::BSON_CODER.serialize(doc)
+    p bson
     assert_equal doc, BSON::BSON_CODER.deserialize(bson)
   end
 

data/test/mongo_bson/jruby_encode_test.rb

@@ -37,9 +37,79 @@ class BSONTest < Test::Unit::TestCase
   
   def setup
     @encoder = BSON::BSON_CODER
+    con = Mongo::Connection.new
+    db = con['mongo-ruby-test']
+    @@test = db['col']
+    @@test.remove
   end
 
   def assert_doc_pass(doc)
+    bson = @encoder.serialize(doc)
+    puts "#{doc.inspect} serializes to #{bson.inspect}"
+    p bson.to_a
+
+    assert_equal doc, @encoder.deserialize(bson)
+  end
+
+  def test_code
+    @reduce_function = "1"#function (obj, prev) { prev.count += inc_value; }"
+    doc = {"a" => Code.new(@reduce_function, {"a" => 1})}
+    assert_doc_pass(doc)
+  end
+
+  def test_float
+    doc = {'a' => 1}
+    assert_doc_pass(doc)
+  end
+
+  def test_group_cmd
+    initial = {"c" => 0}
+    reduce = "function (obj, prev) { prev.c += inc_value; }"
+    group_command = {
+        "group" => {
+          "ns"      => 'col',
+          "$reduce" => reduce,
+          "cond"    => {},
+          "initial" => initial
+        }
+      }
+
+    assert_doc_pass(group_command)
+  end
+
+  context "Grouping" do
+    setup do 
+      @@test.remove
+      @@test.save("a" => 1)
+      @@test.save("b" => 1)
+      @initial = {"count" => 0}
+      @reduce_function = "function (obj, prev) { prev.count += inc_value; }"
+    end
+
+    should "group results using eval form" do
+      p @@test.group([], {}, @initial, Code.new(@reduce_function, {"inc_value" => 1}))
+      p @@test.group([], {}, @initial, Code.new(@reduce_function, {"inc_value" => 2}))
+      assert_equal 2, @@test.group([], {}, @initial, Code.new(@reduce_function, {"inc_value" => 1}))[0]["count"]
+      assert_equal 4, @@test.group([], {}, @initial, Code.new(@reduce_function, {"inc_value" => 2}))[0]["count"]
+    end
+  end
+
+#  def test_find_and_modify
+#    @@test << { :a => 1, :processed => false }
+#    @@test << { :a => 2, :processed => false }
+#    @@test << { :a => 3, :processed => false }
+#    p @@test.find.to_a
+#
+#    @@test.find_and_modify(:query => {}, :sort => [['a', -1]], :update => {"$set" => {"processed" => true}})
+#
+#    p @@test.find.to_a
+#    assert @@test.find_one({:a => 3})['processed']
+#  end
+#
+  def test_invalid_string
+    require 'iconv'
+    string = Iconv.conv('iso-8859-1', 'utf-8', 'aé')
+    doc = {'doc' => string}
     bson = @encoder.serialize(doc)
     assert_equal doc, @encoder.deserialize(bson)
   end
@@ -179,15 +249,40 @@ class BSONTest < Test::Unit::TestCase
 #    bson = BSON::BSON_CODER.serialize(doc)
 #    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
 #  end
+#
+#  def test_obj
+#    doc = {'doc' => {'age' => 42, 'name' => 'Spongebob', 'shoe_size' => 9.5}}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#
+#    doc = {"a" => 10, "b" => 20}# {'doc' => {'age' => 42, 'name' => 'Spongebob', 'shoe_size' => 9.5}}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#  end
+#
+#  def test_oh
+#    oh = BSON::OrderedHash.new
+#    oh["z"] = 10
+#    oh["a"] = 1
+#    bson = BSON::BSON_CODER.serialize(oh)
+#    p bson
+#    assert_equal oh, BSON::BSON_CODER.deserialize(bson)
+#  end
 #
   def test_ordered_hash
-    doc = BSON::OrderedHash.new
-    doc["b"] = 1
-    doc["a"] = 2
-    doc["c"] = 3
-    doc["d"] = 4
-    bson = BSON::BSON_CODER.serialize(doc)
-    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+ #   doc = BSON::OrderedHash.new
+ #   doc["b"] = 1
+ #   doc["a"] = 2
+ #   doc["c"] = 3
+ #   doc["d"] = 4
+ #   bson1 = BSON::BSON_CODER.serialize(doc)
+ #   bson2 = BSON::BSON_RUBY.serialize({"b" => 1, "a" => 2, "c" => 3, "d" => 4})
+ #   bson3 = BSON::BSON_RUBY.serialize({"b" => '1', "a" => '2', "c" => '3', "d" => '4'})
+ #   p bson1
+ #   p bson2
+ #   p bson3
+ #   p BSON::BSON_CODER.deserialize(bson3)
+ #   assert_equal doc, BSON::BSON_RUBY.deserialize(bson3)
   end
 #
 #  def test_object

data/test/mongo_bson/object_id_test.rb

@@ -0,0 +1,132 @@
+require 'test/test_helper'
+require 'rubygems'
+require 'json'
+
+class ObjectIdTest < Test::Unit::TestCase
+
+  include Mongo
+  include BSON
+
+  def setup
+    @o = ObjectId.new
+  end
+
+  def test_hashcode
+    assert_equal @o.instance_variable_get(:@data).hash, @o.hash
+  end
+
+  def test_array_uniq_for_equilavent_ids
+    a = ObjectId.new('123')
+    b = ObjectId.new('123')
+    assert_equal a, b
+    assert_equal 1, [a, b].uniq.size
+  end
+
+  def test_create_pk_method
+    doc = {:name => 'Mongo'}
+    doc = ObjectId.create_pk(doc)
+    assert doc[:_id]
+
+    doc = {:name => 'Mongo', :_id => '12345'}
+    doc = ObjectId.create_pk(doc)
+    assert_equal '12345', doc[:_id]
+  end
+
+  def test_different
+    a = ObjectId.new
+    b = ObjectId.new
+    assert_not_equal a.to_a, b.to_a
+    assert_not_equal a, b
+  end
+
+  def test_eql?
+    o2 = ObjectId.new(@o.to_a)
+    assert_equal @o, o2
+  end
+
+  def test_to_s
+    s = @o.to_s
+    assert_equal 24, s.length
+    s =~ /^([0-9a-f]+)$/
+    assert_equal 24, $1.length
+  end
+
+  def test_method
+    assert_equal ObjectId.from_string(@o.to_s), BSON::ObjectId(@o.to_s)
+  end
+
+  def test_inspect
+    assert_equal "BSON::ObjectId('#{@o.to_s}')", @o.inspect
+  end
+
+  def test_save_and_restore
+    host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
+    port = ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT
+    db = Connection.new(host, port).db(MONGO_TEST_DB)
+    coll = db.collection('test')
+
+    coll.remove
+    coll << {'a' => 1, '_id' => @o}
+
+    row = coll.find().collect.first
+    assert_equal 1, row['a']
+    assert_equal @o, row['_id']
+  end
+
+  def test_from_string
+    hex_str = @o.to_s
+    o2 = ObjectId.from_string(hex_str)
+    assert_equal hex_str, o2.to_s
+    assert_equal @o, o2
+    assert_equal @o.to_s, o2.to_s
+  end
+
+  def test_illegal_from_string
+    assert_raise InvalidObjectId do 
+      ObjectId.from_string("")
+    end
+  end
+
+  def test_legal
+    assert !ObjectId.legal?(nil)
+    assert !ObjectId.legal?("fred")
+    assert !ObjectId.legal?("0000")
+    assert !ObjectId.legal?('000102030405060708090A0')
+    assert ObjectId.legal?('000102030405060708090A0B')
+    assert ObjectId.legal?('abcdefABCDEF123456789012')
+    assert !ObjectId.legal?('abcdefABCDEF12345678901x')
+  end
+
+  def test_from_string_leading_zeroes
+    hex_str = '000000000000000000000000'
+    o = ObjectId.from_string(hex_str)
+    assert_equal hex_str, o.to_s
+  end
+
+  def test_byte_order
+    hex_str = '000102030405060708090A0B'
+    o = ObjectId.from_string(hex_str)
+    assert_equal [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b], o.to_a
+  end
+
+  def test_generation_time
+    time = Time.now
+    id   = ObjectId.new
+    generated_time = id.generation_time
+
+    assert_in_delta time.to_i, generated_time.to_i, 2
+    assert_equal "UTC", generated_time.zone
+  end
+
+  def test_from_time
+    time = Time.now.utc
+    id   = ObjectId.from_time(time)
+
+    assert_equal time.to_i, id.generation_time.to_i
+  end
+
+  def test_json
+    id = ObjectId.new
+    assert_equal "{\"$oid\": \"#{id}\"}", id.to_json
+  end
+end

data/test/mongo_bson/ordered_hash_test.rb

@@ -179,4 +179,12 @@ class OrderedHashTest < Test::Unit::TestCase
     assert !@oh.keys.include?('z')
   end
 
+  def test_reject
+    new = @oh.reject { |k, v| k == 'foo' }
+    assert new.keys == @oh.keys
+
+    new = @oh.reject { |k, v| k == 'z' }
+    assert !new.keys.include?('z')
+  end
+
 end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: bson
 version: !ruby/object:Gem::Version 
+  hash: 29
   prerelease: false
   segments: 
   - 1
   - 0
-  - 4
-  version: 1.0.4
+  - 5
+  version: 1.0.5
 platform: ruby
 authors: 
 - Jim Menard
@@ -16,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-13 00:00:00 -04:00
+date: 2010-08-27 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -43,9 +44,20 @@ files:
 - lib/bson/types/code.rb
 - lib/bson/types/dbref.rb
 - lib/bson/types/min_max_keys.rb
+- lib/bson/types/object_id.rb
 - lib/bson/types/objectid.rb
 - bin/b2json
 - bin/j2bson
+- test/mongo_bson/basic_test.rb
+- test/mongo_bson/binary_test.rb
+- test/mongo_bson/bson_test.rb
+- test/mongo_bson/byte_buffer_test.rb
+- test/mongo_bson/jruby_bson_test.rb
+- test/mongo_bson/jruby_encode_test.rb
+- test/mongo_bson/json_test.rb
+- test/mongo_bson/object_id_test.rb
+- test/mongo_bson/objectid_test.rb
+- test/mongo_bson/ordered_hash_test.rb
 has_rdoc: true
 homepage: http://www.mongodb.org
 licenses: []
@@ -56,23 +68,27 @@ 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.3.7
 signing_key: 
 specification_version: 3
 summary: Ruby implementation of BSON
@@ -84,5 +100,6 @@ test_files:
 - test/mongo_bson/jruby_bson_test.rb
 - test/mongo_bson/jruby_encode_test.rb
 - test/mongo_bson/json_test.rb
+- test/mongo_bson/object_id_test.rb
 - test/mongo_bson/objectid_test.rb
 - test/mongo_bson/ordered_hash_test.rb