bson 1.2.4-jruby → 1.3.0-jruby

data/lib/bson.rb

@@ -18,10 +18,10 @@
 
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
-MINIMUM_BSON_EXT_VERSION = "1.2.4"
+MINIMUM_BSON_EXT_VERSION = "1.3.0"
 
 module BSON
-  VERSION = "1.2.4"
+  VERSION = "1.3.0"
 
   if defined? Mongo::DEFAULT_MAX_BSON_SIZE
     DEFAULT_MAX_BSON_SIZE = Mongo::DEFAULT_MAX_BSON_SIZE
@@ -100,6 +100,7 @@ require 'bson/types/code'
 require 'bson/types/dbref'
 require 'bson/types/object_id'
 require 'bson/types/min_max_keys'
+require 'bson/types/timestamp'
 
 require 'base64'
 require 'bson/ordered_hash'

data/lib/bson/bson_ruby.rb

@@ -57,6 +57,11 @@ module BSON
       BINARY_ENCODING = Encoding.find('binary')
 
       def self.to_utf8_binary(str)
+        begin
+          str.unpack("U*")
+        rescue => ex
+          raise InvalidStringEncoding, "String not valid utf-8: #{str.inspect}"
+        end
         str.encode(UTF8_ENCODING).force_encoding(BINARY_ENCODING)
       end
     else
@@ -187,6 +192,8 @@ module BSON
         serialize_max_key_element(@buf, k)
       when MINKEY
         serialize_min_key_element(@buf, k)
+      when TIMESTAMP
+        serialize_timestamp_element(@buf, k, v)
       else
         raise "unhandled type #{type}"
       end
@@ -256,8 +263,7 @@ module BSON
           doc[key] = deserialize_code_w_scope_data(@buf)
         when TIMESTAMP
           key = deserialize_cstr(@buf)
-          doc[key] = [deserialize_number_int_data(@buf),
-          deserialize_number_int_data(@buf)]
+          doc[key] = deserialize_timestamp_data(@buf)
         when MAXKEY
           key = deserialize_cstr(@buf)
           doc[key] = MaxKey.new
@@ -341,6 +347,12 @@ module BSON
       Regexp.new(str, opts)
     end
 
+    def deserialize_timestamp_data(buf)
+      increment = buf.get_int
+      seconds = buf.get_int
+      Timestamp.new(seconds, increment)
+    end
+
     def encoded_str(str)
       if RUBY_VERSION >= '1.9'
         str.force_encoding("utf-8")
@@ -505,6 +517,14 @@ module BSON
       self.class.serialize_key(buf, key)
     end
 
+    def serialize_timestamp_element(buf, key, val)
+      buf.put(TIMESTAMP)
+      self.class.serialize_key(buf, key)
+
+      buf.put_int(val.increment)
+      buf.put_int(val.seconds)
+    end
+
     def serialize_oid_element(buf, key, val)
       buf.put(OID)
       self.class.serialize_key(buf, key)
@@ -593,6 +613,8 @@ module BSON
         MAXKEY
       when MinKey
         MINKEY
+      when Timestamp
+        TIMESTAMP
       when Numeric
         raise InvalidDocument, "Cannot serialize the Numeric type #{o.class} as BSON; only Fixum, Bignum, and Float are supported."
       when Date, DateTime

data/lib/bson/byte_buffer.rb

@@ -231,13 +231,17 @@ module BSON
     def more?
       @cursor < @str.size
     end
+    
+    def ==(other)
+      other.respond_to?(:to_s) && @str == other.to_s
+    end
 
-    def to_a
-      @str.unpack("C*")
+    def to_a(format="C*")
+      @str.unpack(format)
     end
 
-    def unpack(args)
-      to_a
+    def unpack(format="C*")
+      to_a(format)
     end
 
     def to_s
@@ -245,7 +249,6 @@ module BSON
     end
 
     def dump
-      i = 0
       @str.each_byte do |c, i|
         $stderr.puts "#{'%04d' % i}: #{'%02x' % c} #{'%03o' % c} #{'%s' % c.chr} #{'%3d' % c}"
         i += 1

data/lib/bson/ordered_hash.rb

@@ -62,11 +62,11 @@ module BSON
       end
 
       def keys
-        @ordered_keys || []
+        @ordered_keys# || []
       end
 
       def []=(key, value)
-        @ordered_keys ||= []
+        #@ordered_keys ||= []
         unless has_key?(key)
           @ordered_keys << key
         end
@@ -74,14 +74,14 @@ module BSON
       end
 
       def each
-        @ordered_keys ||= []
+        #@ordered_keys ||= []
         @ordered_keys.each { |k| yield k, self[k] }
         self
       end
       alias :each_pair :each
 
       def to_a
-        @ordered_keys ||= []
+        #@ordered_keys ||= []
         @ordered_keys.map { |k| [k, self[k]] }      
       end
 
@@ -96,13 +96,22 @@ module BSON
       end
 
       def merge!(other)
-        @ordered_keys ||= []
+        #@ordered_keys ||= []
         @ordered_keys += other.keys # unordered if not an BSON::OrderedHash
         @ordered_keys.uniq!
         super(other)
       end
 
       alias :update :merge!
+      
+      def dup
+        result = OrderedHash.new
+        #@ordered_keys ||= []
+        @ordered_keys.each do |key|
+          result[key] = self[key]
+        end
+        result
+      end
 
       def inspect
         str = '{'

data/lib/bson/types/binary.rb

@@ -43,7 +43,7 @@ module BSON
     #   SUBTYPE_BYTES, SUBTYPE_UUID, SUBTYPE_MD5, and SUBTYPE_USER_DEFINED.
     #
     # @see http://www.mongodb.org/display/DOCS/BSON#BSON-noteondatabinary BSON binary subtypes.
-    def initialize(data=[], subtype=SUBTYPE_BYTES)
+    def initialize(data=[], subtype=SUBTYPE_SIMPLE)
       super(data)
       @subtype = subtype
     end

data/lib/bson/types/object_id.rb

@@ -33,6 +33,8 @@ module BSON
     @@lock  = Mutex.new
     @@index = 0
 
+    attr_accessor :data
+
     # 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,
@@ -40,12 +42,15 @@ 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)
-      @data = data || generate
+    #
+    # @option opts :data (nil) An array of bytes to use as the object id.
+    # @option opts :time (nil) The value of this object ids timestamp. Note that
+    #   the remaining bytes will consist of the standard machine id, pid, and counter. If
+    #   you need a zeroed timestamp, used ObjectId.from_time.
+    def initialize(data=nil, time=nil)
+      @data = data || generate(time)
     end
 
-    attr_accessor :data
-
     # Determine if the supplied string is legal. Legal strings will
     # consist of 24 hexadecimal characters.
     #
@@ -62,14 +67,23 @@ module BSON
     #
     # @param [Time] time a utc time to encode as an object id.
     #
+    # @option opts [:unique] (false) If false, the object id's bytes
+    #   succeeding the timestamp will be zeroed; if true, they'll
+    #   consist of the standard machine id, pid, and counter.
+    #
     # @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"))
+    def self.from_time(time, opts={})
+      unique = opts.fetch(:unique, false)
+      if unique
+        self.new(nil, time)
+      else
+        self.new([time.to_i,0,0].pack("NNN").unpack("C12"))
+      end
     end
 
     # Adds a primary key to the given document if needed.
@@ -84,9 +98,9 @@ module BSON
 
     # Check equality of this object id with another.
     #
-    # @param [Mongo::ObjectId] object_id
+    # @param [BSON::ObjectId] object_id
     def eql?(object_id)
-      @data == object_id.instance_variable_get("@data")
+      object_id.kind_of?(BSON::ObjectId) and self.data == object_id.data
     end
     alias_method :==, :eql?
 
@@ -105,13 +119,6 @@ module BSON
       @data.dup
     end
 
-    # Get the array representation without cloning.
-    #
-    # @return [Array]
-    def data
-      @data
-    end
-
     # Given a string representation of an ObjectId, return a new ObjectId
     # with that value.
     #
@@ -145,10 +152,10 @@ module BSON
     def to_json(*a)
       "{\"$oid\": \"#{to_s}\"}"
     end
-    
+
     # Create the JSON hash structure convert to MongoDB extended format. Rails 2.3.3 
     # introduced as_json to create the needed hash structure to encode objects into JSON.
-    # 
+    #
     # @return [Hash] the hash representation as MongoDB extended JSON
     def as_json(options ={})
       {"$oid" => to_s}
@@ -166,12 +173,16 @@ module BSON
     private
 
     # This gets overwritten by the C extension if it loads.
-    def generate
+    def generate(oid_time=nil)
       oid = ''
 
       # 4 bytes current time
-      time = Time.new.to_i
-      oid += [time].pack("N")
+      if oid_time
+        t = oid_time.to_i
+      else
+        t = Time.new.to_i
+      end
+      oid += [t].pack("N")
 
       # 3 bytes machine
       oid += Digest::MD5.digest(Socket.gethostname)[0, 3]

data/lib/bson/types/timestamp.rb

@@ -0,0 +1,76 @@
+# encoding: UTF-8
+
+# --
+# Copyright (C) 2008-2011 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.
+# ++
+
+module BSON
+
+  # A class for representing BSON Timestamps. The Timestamp type is used
+  # by MongoDB internally; thus, it should be used by application developers
+  # for diagnostic purposes only.
+  class Timestamp
+    include Enumerable
+
+    attr_reader :seconds, :increment
+
+    # Create a new BSON Timestamp.
+    #
+    # @param [Integer] seconds The number of seconds 
+    # @param increment
+    def initialize(seconds, increment)
+      @seconds   = seconds
+      @increment = increment
+    end
+
+    def to_s
+      "seconds: #{seconds}, increment: #{increment}"
+    end
+
+    def ==(other)
+      self.seconds == other.seconds &&
+        self.increment == other.increment
+    end
+
+    # This is for backward-compatibility. Timestamps in the Ruby
+    # driver used to deserialize as arrays. So we provide
+    # an equivalent interface.
+    #
+    # @deprecated
+    def [](index)
+      warn "Timestamps are no longer deserialized as arrays. If you're working " +
+        "with BSON Timestamp objects, see the BSON::Timestamp class. This usage will " +
+        "be deprecated in Ruby Driver v2.0."
+      if index == 0
+        self.increment
+      elsif index == 1
+        self.seconds
+      else
+        nil
+      end
+    end
+
+    # This method exists only for backward-compatibility.
+    #
+    # @deprecated
+    def each
+      i = 0
+      while i < 2
+        yield self[i]
+        i += 1
+      end
+    end
+  end
+end

data/test/bson/bson_test.rb

@@ -1,10 +1,14 @@
 # encoding:utf-8
 require './test/test_helper'
-require 'complex'
+
+if RUBY_VERSION < '1.9'
+  require 'complex'
+  require 'rational'
+end
 require 'bigdecimal'
-require 'rational'
 
 begin
+  require 'tzinfo'
   require 'active_support/core_ext'
   Time.zone = "Pacific Time (US & Canada)"
   Zone = Time.zone.now
@@ -116,15 +120,23 @@ class BSONTest < Test::Unit::TestCase
     end
   else
     def test_non_utf8_string
-      bson = BSON::BSON_CODER.serialize({'str' => 'aé'.encode('iso-8859-1')})
-      result = BSON::BSON_CODER.deserialize(bson)['str']
-      assert_equal 'aé', result
-      assert_equal 'UTF-8', result.encoding.name
+      assert_raise BSON::InvalidStringEncoding do
+        BSON::BSON_CODER.serialize({'str' => 'aé'.encode('iso-8859-1')})
+      end
+    end
+
+    def test_invalid_utf8_string
+      str = "123\xD9"
+      assert !str.valid_encoding?
+      assert_raise BSON::InvalidStringEncoding do
+        BSON::BSON_CODER.serialize({'str' => str})
+      end
     end
 
     def test_non_utf8_key
-      bson = BSON::BSON_CODER.serialize({'aé'.encode('iso-8859-1') => 'hello'})
-      assert_equal 'hello', BSON::BSON_CODER.deserialize(bson)['aé']
+      assert_raise BSON::InvalidStringEncoding do
+        BSON::BSON_CODER.serialize({'aé'.encode('iso-8859-1') => 'hello'})
+      end
     end
 
     # Based on a test from sqlite3-ruby
@@ -134,14 +146,14 @@ class BSONTest < Test::Unit::TestCase
       str = "壁に耳あり、障子に目あり"
       bson = BSON::BSON_CODER.serialize("x" => str)
 
-      Encoding.default_internal = 'EUC-JP'
+      silently { Encoding.default_internal = 'EUC-JP' }
       out = BSON::BSON_CODER.deserialize(bson)["x"]
 
       assert_equal Encoding.default_internal, out.encoding
       assert_equal str.encode('EUC-JP'), out
       assert_equal str, out.encode(str.encoding)
     ensure
-      Encoding.default_internal = before_enc
+      silently { Encoding.default_internal = before_enc }
     end
   end
 
@@ -161,12 +173,12 @@ class BSONTest < Test::Unit::TestCase
     assert_doc_pass(doc)
   end
 
-   def test_double
-     doc = {'doc' => 41.25}
-     assert_doc_pass(doc)
-   end
+  def test_double
+    doc = {'doc' => 41.25}
+    assert_doc_pass(doc)
+  end
 
- def test_int
+  def test_int
     doc = {'doc' => 42}
     assert_doc_pass(doc)
 
@@ -246,8 +258,14 @@ class BSONTest < Test::Unit::TestCase
     assert_in_delta doc['date'], doc2['date'], 0.001
   end
 
+  def test_date_in_array
+    doc = {'date' => [Time.now.utc]}
+    bson = @encoder.serialize(doc)
+    doc2 = @encoder.deserialize(bson)
+  end
+
   def test_date_returns_as_utc
-    doc = {'date' => Time.now}
+    doc = {'date' => Time.now.utc}
     bson = @encoder.serialize(doc)
     doc2 = @encoder.deserialize(bson)
     assert doc2['date'].utc?
@@ -277,7 +295,7 @@ class BSONTest < Test::Unit::TestCase
       ensure
         if !invalid_date.is_a? Time
           assert_equal InvalidDocument, e.class
-          assert_match /UTC Time/, e.message
+          assert_match(/UTC Time/, e.message)
         end
       end
     end
@@ -311,6 +329,20 @@ class BSONTest < Test::Unit::TestCase
     bin = Binary.new
     'binstring'.each_byte { |b| bin.put(b) }
 
+    doc = {'bin' => bin}
+    bson = @encoder.serialize(doc)
+    doc2 = @encoder.deserialize(bson)
+    bin2 = doc2['bin']
+    assert_kind_of Binary, bin2
+    assert_equal 'binstring', bin2.to_s
+    assert_equal Binary::SUBTYPE_SIMPLE, bin2.subtype
+  end
+
+  def test_binary_with_deprecated_subtype
+    bin = Binary.new
+    'binstring'.each_byte { |b| bin.put(b) }
+    bin.subtype = Binary::SUBTYPE_BYTES
+
     doc = {'bin' => bin}
     bson = @encoder.serialize(doc)
     doc2 = @encoder.deserialize(bson)
@@ -328,7 +360,7 @@ class BSONTest < Test::Unit::TestCase
     bin2 = doc2['bin']
     assert_kind_of Binary, bin2
     assert_equal 'somebinarystring', bin2.to_s
-    assert_equal Binary::SUBTYPE_BYTES, bin2.subtype
+    assert_equal Binary::SUBTYPE_SIMPLE, bin2.subtype
   end
 
   def test_binary_type
@@ -368,7 +400,7 @@ class BSONTest < Test::Unit::TestCase
     bin2 = doc2['bin']
     assert_kind_of Binary, bin2
     assert_equal [1, 2, 3, 4, 5], bin2.to_a
-    assert_equal Binary::SUBTYPE_BYTES, bin2.subtype
+    assert_equal Binary::SUBTYPE_SIMPLE, bin2.subtype
   end
 
   def test_put_id_first
@@ -393,15 +425,24 @@ class BSONTest < Test::Unit::TestCase
   if !(RUBY_PLATFORM =~ /java/)
     def test_timestamp
       val = {"test" => [4, 20]}
-      assert_equal val, @encoder.deserialize([0x13, 0x00, 0x00, 0x00,
-                                        0x11, 0x74, 0x65, 0x73,
-                                        0x74, 0x00, 0x04, 0x00,
-                                        0x00, 0x00, 0x14, 0x00,
-                                        0x00, 0x00, 0x00])
+      result = @encoder.deserialize([0x13, 0x00, 0x00, 0x00,
+                                     0x11, 0x74, 0x65, 0x73,
+                                     0x74, 0x00, 0x04, 0x00,
+                                     0x00, 0x00, 0x14, 0x00,
+                                     0x00, 0x00, 0x00])
 
+      assert_equal 4, result["test"][0]
+      assert_equal 20, result["test"][1]
     end
   end
 
+  def test_timestamp_type
+    ts = Timestamp.new(5000, 100)
+    doc = {:ts => ts}
+    bson = @encoder.serialize(doc)
+    assert_equal ts, @encoder.deserialize(bson)["ts"]
+  end
+
   def test_overflow
     doc = {"x" => 2**75}
     assert_raise RangeError do
@@ -439,7 +480,7 @@ class BSONTest < Test::Unit::TestCase
       rescue => e
       ensure
         assert_equal InvalidDocument, e.class
-        assert_match /Cannot serialize/, e.message
+        assert_match(/Cannot serialize/, e.message)
       end
     end
   end
@@ -573,7 +614,7 @@ class BSONTest < Test::Unit::TestCase
       @encoder.serialize({"he\0llo" => "world"}, true)
     end
 
-    assert_raise_error BSON::InvalidKeyName, "$hello" do
+    assert_raise BSON::InvalidKeyName do
       @encoder.serialize({"$hello" => "world"}, true)
     end
 
@@ -581,7 +622,7 @@ class BSONTest < Test::Unit::TestCase
       @encoder.serialize({"hello" => {"$hello" => "world"}}, true)
     end
 
-    assert_raise_error BSON::InvalidKeyName, ".hello" do
+    assert_raise BSON::InvalidKeyName  do
       @encoder.serialize({".hello" => "world"}, true)
     end
 

data/test/bson/byte_buffer_test.rb

@@ -21,6 +21,13 @@ class ByteBufferTest < Test::Unit::TestCase
     assert_equal 1, @buf.get
   end
 
+  def test_unpack
+    @buf.put_array([17, 2, 3, 4])
+    assert_equal [17, 2, 3, 4], @buf.to_a
+    assert_equal ["11020304"], @buf.unpack("H*")
+    assert_equal ["11020304"], @buf.to_a("H*")
+  end
+
   def test_one_get_returns_array_length_one
     @buf.put_array([1, 2, 3, 4])
     @buf.rewind
@@ -186,5 +193,16 @@ class ByteBufferTest < Test::Unit::TestCase
     @buf.get_int
     assert !@buf.more?
   end
+  
+  def test_equality
+    @buf = ByteBuffer.new("foo")
+    assert_equal @buf, @buf
+    assert_equal ByteBuffer.new(""), ByteBuffer.new("")
+    assert_equal ByteBuffer.new("123"), ByteBuffer.new("123")
+    assert_not_equal ByteBuffer.new("123"), ByteBuffer.new("1234")
+    assert_equal @buf, "foo"
+    assert_not_equal @buf, 123
+    assert_not_equal @buf, nil
+  end
 
 end

data/test/bson/object_id_test.rb

@@ -126,14 +126,27 @@ class ObjectIdTest < Test::Unit::TestCase
     time = Time.now.utc
     id   = ObjectId.from_time(time)
 
+    assert id.to_a[4, 8].all? {|byte| byte == 0 }
     assert_equal time.to_i, id.generation_time.to_i
   end
 
+  def test_from_time_unique
+    time = Time.now.utc
+    id   = ObjectId.from_time(time, :unique => true)
+
+    mac_id = Digest::MD5.digest(Socket.gethostname)[0, 3].unpack("C3")
+    assert_equal id.to_a[4, 3], mac_id
+    assert_equal time.to_i, id.generation_time.to_i
+
+    id2 = ObjectId.new(nil, time)
+    assert_equal time.to_i, id2.generation_time.to_i
+  end
+
   def test_json
     id = ObjectId.new
     assert_equal "{\"$oid\": \"#{id}\"}", id.to_json
   end
-  
+
   def test_as_json
     id = ObjectId.new
     assert_equal({"$oid" => id.to_s}, id.as_json)

data/test/bson/ordered_hash_test.rb

@@ -194,4 +194,11 @@ class OrderedHashTest < Test::Unit::TestCase
     copy[:foo] = 1
     assert copy.keys != @oh.keys
   end
+  
+  def test_dup
+    oh2 = @oh.dup
+    oh2['f'] = 9
+    assert_nil @oh['f']
+    assert_equal ['c', 'a', 'z'], @oh.keys
+  end
 end

data/test/bson/timestamp_test.rb

@@ -0,0 +1,24 @@
+require './test/test_helper'
+
+class TiumestampTest < Test::Unit::TestCase
+  include Mongo
+
+  def test_timestamp_equality
+    t1 = Timestamp.new(5000, 200)
+    t2 = Timestamp.new(5000, 200)
+    assert_equal t2, t1
+  end
+
+  def test_implements_array_for_backward_compatibility
+    ts = Timestamp.new(5000, 200)
+    assert_equal 200, ts[0]
+    assert_equal 5000, ts[1]
+
+    array = ts.map {|t| t }
+    assert_equal 2, array.length
+
+    assert_equal 200, array[0]
+    assert_equal 5000, array[1]
+  end
+
+end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: bson
 version: !ruby/object:Gem::Version 
-  hash: 23
   prerelease: false
   segments: 
   - 1
-  - 2
-  - 4
-  version: 1.2.4
+  - 3
+  - 0
+  version: 1.3.0
 platform: jruby
 authors: 
 - Jim Menard
@@ -17,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-23 00:00:00 -05:00
+date: 2011-04-01 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -33,30 +32,31 @@ extra_rdoc_files: []
 files: 
 - LICENSE.txt
 - lib/bson.rb
-- lib/bson/bson_c.rb
-- lib/bson/bson_java.rb
 - lib/bson/bson_ruby.rb
-- lib/bson/byte_buffer.rb
+- lib/bson/bson_c.rb
 - lib/bson/exceptions.rb
 - lib/bson/ordered_hash.rb
-- lib/bson/types/binary.rb
-- lib/bson/types/code.rb
 - lib/bson/types/dbref.rb
-- lib/bson/types/min_max_keys.rb
+- lib/bson/types/code.rb
 - lib/bson/types/object_id.rb
+- lib/bson/types/binary.rb
+- lib/bson/types/timestamp.rb
+- lib/bson/types/min_max_keys.rb
+- lib/bson/byte_buffer.rb
+- lib/bson/bson_java.rb
 - bin/b2json
 - bin/j2bson
 - ext/java/jar/bson-2.2.jar
 - ext/java/jar/jbson.jar
 - ext/java/jar/mongo-2.4.jar
-- test/bson/binary_test.rb
-- test/bson/bson_string_test.rb
-- test/bson/bson_test.rb
 - test/bson/byte_buffer_test.rb
-- test/bson/hash_with_indifferent_access_test.rb
-- test/bson/json_test.rb
+- test/bson/binary_test.rb
 - test/bson/object_id_test.rb
+- test/bson/json_test.rb
+- test/bson/timestamp_test.rb
+- test/bson/bson_test.rb
 - test/bson/ordered_hash_test.rb
+- test/bson/hash_with_indifferent_access_test.rb
 has_rdoc: true
 homepage: http://www.mongodb.org
 licenses: []
@@ -71,7 +71,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -80,7 +79,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -92,11 +90,11 @@ signing_key:
 specification_version: 3
 summary: Ruby implementation of BSON
 test_files: 
-- test/bson/binary_test.rb
-- test/bson/bson_string_test.rb
-- test/bson/bson_test.rb
 - test/bson/byte_buffer_test.rb
-- test/bson/hash_with_indifferent_access_test.rb
-- test/bson/json_test.rb
+- test/bson/binary_test.rb
 - test/bson/object_id_test.rb
+- test/bson/json_test.rb
+- test/bson/timestamp_test.rb
+- test/bson/bson_test.rb
 - test/bson/ordered_hash_test.rb
+- test/bson/hash_with_indifferent_access_test.rb

data/test/bson/bson_string_test.rb

@@ -1,30 +0,0 @@
-# encoding:utf-8
-require './test/test_helper'
-require 'complex'
-require 'bigdecimal'
-require 'rational'
-
-class BSONTest < Test::Unit::TestCase
-
-  include BSON
-
-  def setup
-    @encoder = BSON::BSON_CODER
-  end
-
-  def assert_doc_pass(doc, options={})
-    bson = @encoder.serialize(doc)
-    if options[:debug]
-      puts "DEBUGGING DOC:"
-      p bson.to_a
-      puts "DESERIALIZES TO:"
-    end
-    assert_equal @encoder.serialize(doc).to_a, bson.to_a
-    assert_equal doc, @encoder.deserialize(bson)
-  end
-
-  def test_string
-    assert_doc_pass({:a => "hello"})
-  end
-
-end