bson 1.8.0 → 1.8.2

data/VERSION

@@ -1 +1 @@
-1.8.0
+1.8.2

data/bson.gemspec

@@ -14,16 +14,14 @@ Gem::Specification.new do |s|
   s.files             += Dir['lib/bson/**/*.rb']
 
   if RUBY_PLATFORM =~ /java/
-    s.files           += ['ext/java/jar/jbson.jar', 'ext/java/jar/mongo-2.6.5.jar']
-    s.platform        = Gem::Platform::JAVA
+    s.platform = 'java'
+    s.files    += ['ext/jbson/target/jbson.jar', 'ext/jbson/lib/java-bson.jar']
   else
-    s.platform        = Gem::Platform::RUBY
+    s.platform = Gem::Platform::RUBY
   end
 
   s.test_files        = Dir['test/bson/*.rb']
   s.executables       = ['b2json', 'j2bson']
   s.require_paths     = ['lib']
   s.has_rdoc          = 'yard'
-
-  s.add_dependency('activesupport')
-end
+end

data/lib/bson.rb

@@ -1,5 +1,3 @@
-# encoding: UTF-8
-#
 # --
 # Copyright (C) 2008-2012 10gen Inc.
 #
@@ -46,57 +44,75 @@ module BSON
     bytebuf.rewind
     return BSON.deserialize(bytebuf)
   end
-end
 
-if RUBY_PLATFORM =~ /java/
-  jar_dir = File.join(File.dirname(__FILE__), '..', 'ext', 'java', 'jar')
-  require File.join(jar_dir, 'mongo-2.6.5.jar')
-  require File.join(jar_dir, 'jbson.jar')
-  require 'bson/bson_java'
-  module BSON
-    BSON_CODER = BSON_JAVA
+  def self.extension?
+    !((ENV.key?('BSON_EXT_DISABLED') && RUBY_PLATFORM =~ /java/) ||
+      (ENV.key?('BSON_EXT_DISABLED') || "\x01\x00\x00\x00".unpack("i")[0] != 1))
   end
-else
-  begin
-    # Need this for running test with and without c ext in Ruby 1.9.
-    raise LoadError if ENV['TEST_MODE'] && !ENV['C_EXT']
+end
 
-    # Raise LoadError unless little endian, since the C extensions
-    # only work on little-endian architectures.
-    raise LoadError unless "\x01\x00\x00\x00".unpack("i").first == 1
+begin
+  # Skips loading extensions if one of the following is true:
+  # 1) JRuby and BSON_EXT_DISABLED is set.
+  #     -OR-
+  # 2) Ruby MRI and big endian or BSON_EXT_DISABLED is set.
+  raise LoadError unless BSON.extension?
 
+  if RUBY_PLATFORM =~ /java/
+    require 'bson/bson_java'
+    module BSON
+      BSON_CODER = BSON_JAVA
+    end
+  else
     require 'bson_ext/cbson'
     raise LoadError unless defined?(CBson::VERSION)
     require 'bson/bson_c'
     module BSON
       BSON_CODER = BSON_C
     end
-  rescue LoadError
-    require 'bson/bson_ruby'
-    module BSON
-      BSON_CODER = BSON_RUBY
+  end
+rescue LoadError
+  require 'bson/bson_ruby'
+  module BSON
+    BSON_CODER = BSON_RUBY
+  end
+
+  if RUBY_PLATFORM =~ /java/
+    unless ENV['TEST_MODE']
+      warn <<-NOTICE
+      ** Notice: The BSON extension was not loaded. **
+
+      For optimal performance, use of the BSON extension is recommended. To
+      enable the extension make sure ENV['BSON_EXT_DISABLED'] is not set.
+      NOTICE
     end
+  else
     unless ENV['TEST_MODE']
-      warn "\n**Notice: C extension not loaded. This is required for optimum MongoDB Ruby driver performance."
-      warn "  You can install the extension as follows:\n  gem install bson_ext\n"
-      warn "  If you continue to receive this message after installing, make sure that the"
-      warn "  bson_ext gem is in your load path and that the bson_ext and mongo gems are of the same version.\n"
+      warn <<-NOTICE
+      ** Notice: The native BSON extension was not loaded. **
+
+      For optimal performance, use of the BSON extension is recommended.
+
+      To enable the extension make sure ENV['BSON_EXT_DISABLED'] is not set
+      and run the following command:
+
+        gem install bson_ext
+
+      If you continue to receive this message after installing, make sure that
+      the bson_ext gem is in your load path.
+      NOTICE
     end
   end
 end
 
-require 'active_support'
-require 'active_support/hash_with_indifferent_access'
-
+require 'base64'
+require 'bson/bson_ruby'
+require 'bson/byte_buffer'
+require 'bson/exceptions'
+require 'bson/ordered_hash'
 require 'bson/types/binary'
 require 'bson/types/code'
 require 'bson/types/dbref'
-require 'bson/types/object_id'
 require 'bson/types/min_max_keys'
+require 'bson/types/object_id'
 require 'bson/types/timestamp'
-
-require 'base64'
-require 'bson/ordered_hash'
-require 'bson/byte_buffer'
-require 'bson/bson_ruby'
-require 'bson/exceptions'

data/lib/bson/bson_java.rb

@@ -1,11 +1,13 @@
 require 'jruby'
 
 include Java
+
+jar_dir = File.join(File.dirname(__FILE__), '../../ext/jbson')
+require File.join(jar_dir, 'lib/java-bson.jar')
+require File.join(jar_dir, 'target/jbson.jar')
+
 module BSON
   class BSON_JAVA
-
-    # TODO: Pool or cache instances of RubyBSONEncoder so that
-    # we don't create a new one on each call to #serialize.
     def self.serialize(obj, check_keys=false, move_id=false, max_bson_size=BSON::DEFAULT_MAX_BSON_SIZE)
       raise InvalidDocument, "BSON_JAVA.serialize takes a Hash" unless obj.is_a?(Hash)
       enc = Java::OrgJbson::RubyBSONEncoder.new(JRuby.runtime, check_keys, move_id, max_bson_size)

data/lib/bson/bson_ruby.rb

@@ -17,6 +17,8 @@
 # ++
 
 module BSON
+  NULL_BYTE = "\x00"
+
   # A BSON seralizer/deserializer in pure Ruby.
   class BSON_RUBY
 
@@ -24,27 +26,32 @@ module BSON
 
     @@max_bson_size = DEFAULT_MAX_BSON_SIZE
 
-    MINKEY = -1
-    EOO = 0
-    NUMBER = 1
-    STRING = 2
-    OBJECT = 3
-    ARRAY = 4
-    BINARY = 5
-    UNDEFINED = 6
-    OID = 7
-    BOOLEAN = 8
-    DATE = 9
-    NULL = 10
-    REGEX = 11
-    REF = 12
-    CODE = 13
-    SYMBOL = 14
+    MINKEY       = -1
+    EOO          = 0
+    NUMBER       = 1
+    STRING       = 2
+    OBJECT       = 3
+    ARRAY        = 4
+    BINARY       = 5
+    UNDEFINED    = 6
+    OID          = 7
+    BOOLEAN      = 8
+    DATE         = 9
+    NULL         = 10
+    REGEX        = 11
+    REF          = 12
+    CODE         = 13
+    SYMBOL       = 14
     CODE_W_SCOPE = 15
-    NUMBER_INT = 16
-    TIMESTAMP = 17
-    NUMBER_LONG = 18
-    MAXKEY = 127
+    NUMBER_INT   = 16
+    TIMESTAMP    = 17
+    NUMBER_LONG  = 18
+    MAXKEY       = 127
+
+    INT32_MIN = -(1 << 31) + 1
+    INT32_MAX =  (1 << 31) - 1
+    INT64_MIN = -2**64 / 2
+    INT64_MAX =  2**64 / 2 - 1
 
     def initialize(max_bson_size=BSON::DEFAULT_MAX_BSON_SIZE)
       @buf = ByteBuffer.new('', max_bson_size)
@@ -52,7 +59,6 @@ module BSON
     end
 
     if RUBY_VERSION >= '1.9'
-      NULL_BYTE       = "\0".force_encoding('binary').freeze
       UTF8_ENCODING   = Encoding.find('utf-8')
       BINARY_ENCODING = Encoding.find('binary')
 
@@ -65,8 +71,6 @@ module BSON
         str.dup.force_encoding(BINARY_ENCODING)
       end
     else
-      NULL_BYTE = "\0"
-
       def self.to_utf8_binary(str)
         begin
           str.unpack("U*")
@@ -299,8 +303,7 @@ module BSON
     end
 
     def deserialize_date_data(buf)
-      unsigned = buf.get_long()
-      milliseconds = unsigned >= 2 ** 64 / 2 ? unsigned - 2**64 : unsigned
+      milliseconds = buf.get_long
       Time.at(milliseconds.to_f / 1000.0).utc # at() takes fractional seconds
     end
 
@@ -313,13 +316,11 @@ module BSON
     end
 
     def deserialize_number_int_data(buf)
-      unsigned = buf.get_int
-      unsigned >= 2**32 / 2 ? unsigned - 2**32 : unsigned
+      buf.get_int
     end
 
     def deserialize_number_long_data(buf)
-      unsigned = buf.get_long
-      unsigned >= 2 ** 64 / 2 ? unsigned - 2**64 : unsigned
+      buf.get_long
     end
 
     def deserialize_object_data(buf)
@@ -463,10 +464,10 @@ module BSON
         self.class.serialize_key(buf, key)
         buf.put_double(val)
       else
-        if val > 2**64 / 2 - 1 or val < -2**64 / 2
+        if val > INT64_MAX or val < INT64_MIN
           raise RangeError.new("MongoDB can only handle 8-byte ints")
         end
-        if val > 2**32 / 2 - 1 or val < -2**32 / 2
+        if val > INT32_MAX or val < INT32_MIN
           buf.put(NUMBER_LONG)
           self.class.serialize_key(buf, key)
           buf.put_long(val)

data/lib/bson/byte_buffer.rb

@@ -22,6 +22,10 @@ module BSON
 
     attr_reader :order, :max_size
 
+    INT32_PACK = 'l<'.freeze
+    INT64_PACK = 'q<'.freeze
+    DOUBLE_PACK = 'E'.freeze
+
     def initialize(initial_data="", max_size=BSON::DEFAULT_MAX_BSON_SIZE)
       @str = case initial_data
         when String then
@@ -37,45 +41,9 @@ module BSON
       end
 
       @cursor = @str.length
-      @order  = :little_endian
-      @int_pack_order    = 'V'
-      @double_pack_order = 'E'
       @max_size = max_size
     end
 
-    if RUBY_VERSION >= '1.9'
-      NULL_BYTE       = "\0".force_encoding('binary').freeze
-      UTF8_ENCODING   = Encoding.find('utf-8')
-      BINARY_ENCODING = Encoding.find('binary')
-      
-      def self.to_utf8_binary(str)
-        str.encode(UTF8_ENCODING).force_encoding(BINARY_ENCODING)
-      end
-    else
-      NULL_BYTE = "\0"
-      
-      def self.to_utf8_binary(str)
-        begin
-        str.unpack("U*")
-        rescue
-          raise InvalidStringEncoding, "String not valid utf-8: #{str.inspect}"
-        end
-        str
-      end
-    end
-
-    def self.serialize_cstr(buf, val)
-      buf.append!(to_utf8_binary(val.to_s))
-      buf.append!(NULL_BYTE)
-    end
-
-    # +endianness+ should be :little_endian or :big_endian. Default is :little_endian
-    def order=(endianness)
-      @order = endianness
-      @int_pack_order = endianness == :little_endian ? 'V' : 'N'
-      @double_pack_order = endianness == :little_endian ? 'E' : 'G'
-    end
-
     def rewind
       @cursor = 0
     end
@@ -147,31 +115,29 @@ module BSON
       @cursor += array.length
     end
 
-    def put_int(i, offset=nil)
+    def put_num(i, offset, bytes)
+      pack_type = bytes == 4 ? INT32_PACK : INT64_PACK
       @cursor = offset if offset
       if more?
-        @str[@cursor, 4] = [i].pack(@int_pack_order)
+        @str[@cursor, bytes] = [i].pack(pack_type)
       else
         ensure_length(@cursor)
-        @str << [i].pack(@int_pack_order)
+        @str << [i].pack(pack_type)
       end
-      @cursor += 4
+      @cursor += bytes
+    end
+
+    def put_int(i, offset=nil)
+      put_num(i, offset, 4)
     end
 
     def put_long(i, offset=nil)
-      offset = @cursor unless offset
-      if @int_pack_order == 'N'
-        put_int(i >> 32, offset)
-        put_int(i & 0xffffffff, offset + 4)
-      else
-        put_int(i & 0xffffffff, offset)
-        put_int(i >> 32, offset + 4)
-      end
+      put_num(i, offset, 8)
     end
 
     def put_double(d, offset=nil)
       a = []
-      [d].pack(@double_pack_order).each_byte { |b| a << b }
+      [d].pack(DOUBLE_PACK).each_byte { |b| a << b }
       put_array(a, offset)
     end
 
@@ -209,24 +175,21 @@ module BSON
       check_read_length(4)
       vals = @str[@cursor..@cursor+3]
       @cursor += 4
-      vals.unpack(@int_pack_order)[0]
+      vals.unpack(INT32_PACK)[0]
     end
 
     def get_long
-      i1 = get_int
-      i2 = get_int
-      if @int_pack_order == 'N'
-        (i1 << 32) + i2
-      else
-        (i2 << 32) + i1
-      end
+      check_read_length(8)
+      vals = @str[@cursor..@cursor+7]
+      @cursor += 8
+      vals.unpack(INT64_PACK)[0]
     end
 
     def get_double
       check_read_length(8)
       vals = @str[@cursor..@cursor+7]
       @cursor += 8
-      vals.unpack(@double_pack_order)[0]
+      vals.unpack(DOUBLE_PACK)[0]
     end
 
     def more?

data/lib/bson/support/hash_with_indifferent_access.rb

@@ -0,0 +1,168 @@
+# encoding: UTF-8
+#
+# --
+# Copyright (C) 2008-2012 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 'active_support'
+begin
+  require 'active_support/hash_with_indifferent_access'
+rescue LoadError
+  # For ActiveSupport 2
+  require 'active_support/core_ext/hash/indifferent_access'
+end
+
+module ActiveSupport
+  class HashWithIndifferentAccess < Hash
+    def extractable_options?
+      true
+    end
+
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def default(key = nil)
+      if key.is_a?(Symbol) && include?(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    end
+
+    def self.new_from_hash_copying_default(hash)
+      ActiveSupport::HashWithIndifferentAccess.new(hash).tap do |new_hash|
+        new_hash.default = hash.default
+      end
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:key] = "value"
+    #
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    # Updates the instantized hash with values from the second:
+    #
+    #   hash_1 = HashWithIndifferentAccess.new
+    #   hash_1[:key] = "value"
+    #
+    #   hash_2 = HashWithIndifferentAccess.new
+    #   hash_2[:key] = "New Value!"
+    #
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    #
+    def update(other_hash)
+      other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+      self
+    end
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash["key"] = "value"
+    #   hash.key? :key  # => true
+    #   hash.key? "key" # => true
+    #
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    # Fetches the value for the specified key, same as doing hash[key]
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:a] = "x"
+    #   hash[:b] = "y"
+    #   hash.values_at("a", "b") # => ["x", "y"]
+    #
+    def values_at(*indices)
+      indices.collect {|key| self[convert_key(key)]}
+    end
+
+    # Returns an exact copy of the hash.
+    def dup
+      HashWithIndifferentAccess.new(self)
+    end
+
+    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+    # Does not overwrite the existing hash.
+    def merge(hash)
+      self.dup.update(hash)
+    end
+
+    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
+    def reverse_merge(other_hash)
+      super self.class.new_from_hash_copying_default(other_hash)
+    end
+
+    def reverse_merge!(other_hash)
+      replace(reverse_merge( other_hash ))
+    end
+
+    # Removes a specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def stringify_keys!; self end
+    def stringify_keys; dup end
+    def symbolize_keys; to_hash.symbolize_keys end
+    def to_options!; self end
+
+    # Convert to a Hash with String keys.
+    def to_hash
+      Hash.new(default).merge!(self)
+    end
+
+    protected
+      def convert_key(key)
+        key.kind_of?(Symbol) ? key.to_s : key
+      end
+
+      def convert_value(value)
+        case value
+        when Hash
+          self.class.new_from_hash_copying_default(value)
+        when Array
+          value.collect { |e| e.is_a?(Hash) ? self.class.new_from_hash_copying_default(e) : e }
+        else
+          value
+        end
+      end
+  end
+end

data/lib/bson/types/binary.rb

@@ -26,10 +26,10 @@ module BSON
   # Use this class when storing binary data in documents.
   class Binary < ByteBuffer
 
-    SUBTYPE_SIMPLE = 0x00
-    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

@@ -173,7 +173,7 @@ module BSON
 
     private
 
-    if RUBY_PLATFORM =~ /java/
+    if RUBY_PLATFORM =~ /java/ && BSON.extension?
       @@generator = Java::OrgBsonTypes::ObjectId
       @@machine_id = [@@generator.genMachineId].pack("N")[0,3]
 

data/test/bson/bson_test.rb

@@ -349,7 +349,7 @@ class BSONTest < Test::Unit::TestCase
     doc2 = @encoder.deserialize(bson)
 
     # Java doesn't deserialize to DBRefs
-    if RUBY_PLATFORM =~ /java/
+    if RUBY_PLATFORM =~ /java/ && BSON.extension?
       assert_equal 'namespace', doc2['dbref']['$ns']
       assert_equal oid, doc2['dbref']['$id']
     else

data/test/bson/byte_buffer_test.rb

@@ -45,10 +45,6 @@ class ByteBufferTest < Test::Unit::TestCase
     assert_equal 4, @buf.length
   end
 
-  def test_default_order
-    assert_equal :little_endian, @buf.order
-  end
-
   def test_long_length
     @buf.put_long 1027
     assert_equal 8, @buf.length
@@ -66,29 +62,31 @@ class ByteBufferTest < Test::Unit::TestCase
     assert_equal 41.2, @buf.get_double
   end
   
-  if defined?(Encoding)
-    def test_serialize_cstr_converts_encoding_to_utf8
-      theta = "hello \xC8".force_encoding("ISO-8859-7")
-      ByteBuffer.serialize_cstr(@buf, theta)
-      assert_equal "hello \xCE\x98\0", @buf.to_s
-      assert_equal Encoding.find('binary'), @buf.to_s.encoding
-    end
-    
-    def test_serialize_cstr_validates_data_as_utf8
-      assert_raises(Encoding::UndefinedConversionError) do
-        ByteBuffer.serialize_cstr(@buf, "hello \xFF")
+  if BSON_CODER == BSON::BSON_RUBY
+    if defined?(Encoding)
+      def test_serialize_cstr_throws_error_for_bad_utf8
+        bad = "hello \xC8".force_encoding("ISO-8859-7")
+        assert_raises(BSON::InvalidStringEncoding) do
+          BSON_CODER::serialize_cstr(@buf, bad)
+        end
       end
-    end
-  else
-    def test_serialize_cstr_forces_encoding_to_utf8
-      # Unicode snowman (\u2603)
-      ByteBuffer.serialize_cstr(@buf, "hello \342\230\203")
-      assert_equal "hello \342\230\203\0", @buf.to_s
-    end
-    
-    def test_serialize_cstr_validates_data_as_utf8
-      assert_raises(BSON::InvalidStringEncoding) do
-        ByteBuffer.serialize_cstr(@buf, "hello \xFF")
+
+      def test_serialize_cstr_does_not_validate_data_as_utf8
+        assert_raises(BSON::InvalidStringEncoding) do
+          BSON_CODER::serialize_cstr(@buf, "hello \xFF")
+        end
+      end
+    else
+      def test_serialize_cstr_forces_encoding_to_utf8
+        # Unicode snowman (\u2603)
+        BSON_CODER::serialize_cstr(@buf, "hello \342\230\203")
+        assert_equal "hello \342\230\203\0", @buf.to_s
+      end
+
+      def test_serialize_cstr_validates_data_as_utf8
+        assert_raises(BSON::InvalidStringEncoding) do
+          BSON_CODER::serialize_cstr(@buf, "hello \xFF")
+        end
       end
     end
   end

data/test/bson/hash_with_indifferent_access_test.rb

@@ -1,6 +1,16 @@
 # encoding:utf-8
 require 'test_helper'
-require 'support/hash_with_indifferent_access'
+
+# Note: HashWithIndifferentAccess is so commonly used
+# that we always need to make sure that the driver works
+# with it. However, the bson gem should never need to
+# depend on it.
+
+# As a result, ActiveSupport is no longer a gem dependency and it should remain
+# that way. It must be required by the application code or
+# via bundler for developmet.
+
+require 'bson/support/hash_with_indifferent_access'
 
 class HashWithIndifferentAccessTest < Test::Unit::TestCase
   include BSON

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bson
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.8.2
   prerelease: 
 platform: ruby
 authors:
@@ -12,24 +12,8 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-27 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 2013-01-17 00:00:00.000000000 Z
+dependencies: []
 description: A Ruby BSON implementation for MongoDB. For more information about Mongo,
   see http://www.mongodb.org. For more information on BSON, see http://www.bsonspec.org.
 email: mongodb-dev@googlegroups.com
@@ -45,26 +29,27 @@ files:
 - bin/b2json
 - bin/j2bson
 - lib/bson.rb
-- lib/bson/ordered_hash.rb
 - lib/bson/bson_c.rb
-- lib/bson/types/dbref.rb
-- lib/bson/types/min_max_keys.rb
-- lib/bson/types/timestamp.rb
-- lib/bson/types/code.rb
-- lib/bson/types/binary.rb
-- lib/bson/types/object_id.rb
 - lib/bson/bson_java.rb
+- lib/bson/bson_ruby.rb
 - lib/bson/byte_buffer.rb
 - lib/bson/exceptions.rb
-- lib/bson/bson_ruby.rb
-- test/bson/hash_with_indifferent_access_test.rb
-- test/bson/bson_test.rb
+- lib/bson/ordered_hash.rb
+- lib/bson/support/hash_with_indifferent_access.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/object_id.rb
+- lib/bson/types/timestamp.rb
 - test/bson/binary_test.rb
-- test/bson/ordered_hash_test.rb
-- test/bson/timestamp_test.rb
+- test/bson/bson_test.rb
 - test/bson/byte_buffer_test.rb
-- test/bson/object_id_test.rb
+- test/bson/hash_with_indifferent_access_test.rb
 - test/bson/json_test.rb
+- test/bson/object_id_test.rb
+- test/bson/ordered_hash_test.rb
+- test/bson/timestamp_test.rb
 homepage: http://www.mongodb.org
 licenses: []
 post_install_message: 
@@ -77,6 +62,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 682470089809443431
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -90,12 +78,12 @@ signing_key:
 specification_version: 3
 summary: Ruby implementation of BSON
 test_files:
-- test/bson/hash_with_indifferent_access_test.rb
-- test/bson/bson_test.rb
 - test/bson/binary_test.rb
-- test/bson/ordered_hash_test.rb
-- test/bson/timestamp_test.rb
+- test/bson/bson_test.rb
 - test/bson/byte_buffer_test.rb
-- test/bson/object_id_test.rb
+- test/bson/hash_with_indifferent_access_test.rb
 - test/bson/json_test.rb
+- test/bson/object_id_test.rb
+- test/bson/ordered_hash_test.rb
+- test/bson/timestamp_test.rb
 has_rdoc: yard