bson 1.12.5-java → 2.0.0-java

metadata.gz.sig

@@ -1 +1 @@
-di4�U���xm43��rX�=��!agc,�>��O���݌e���l5h���Ï�еlj��^��*�,�Tl��KRТ
mer3ɹ���<<������}��1�DPJM���&��3���x�
+���T����jI�:`�kQ5���Ӟ6`�<Z���0r�|�V�|95Ɣ��/x.�._�{^�G���	q̺�@q��{I���Ip��k��C#2�YP+�:�

data/VERSION

@@ -1 +0,0 @@
-1.12.5

data/bin/b2json

@@ -1,63 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-# Copyright (C) 2009-2013 MongoDB, 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 'rubygems'
-require 'bson'
-
-# Note that this will not properly round-trip in all cases
-# from the output generated by j2bson.
-begin
-require 'yajl'
-rescue LoadError
-  puts "This script requires yajl. Please install as follows:"
-  puts "  gem install yajl-ruby"
-  Process.exit
-end
-
-# Convert all documents in an IO into JSON.
-def print_b2json(io)
-  while not io.eof? do
-    bsonobj = BSON.read_bson_document(io)
-    Yajl::Encoder.encode(bsonobj, STDOUT)
-    STDOUT << "\n"
-  end
-end
-
-# print usage
-def usage()
-    STDERR << <<END_OF_USAGE
-usage:  b2json [-h] [file1 [file2]]
-
-   Converts a BSON file to JSON on STDOUT.
-   You can pass multiple filenames.
-   If no filenames are passed, then STDIN is consumed.
-
-END_OF_USAGE
-    exit
-end
-
-# no arg, use STDIN
-# -h, print usage and exit
-# otherwise loop of filenames
-if ARGV.empty? then
-    print_b2json(STDIN)
-    exit
-elsif ARGV[0] == "-h" then
-    usage()
-else
-    ARGV.each { |fname| print_b2json(File.new(fname)) }
-end

data/bin/j2bson

@@ -1,64 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-# Copyright (C) 2009-2013 MongoDB, 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 'rubygems'
-require 'bson'
-
-# Note that, at the moment, this will not properly round-trip
-# in all cases from the output generated by b2json.
-begin
-require 'json/pure'  # broken with 'json/ext'
-rescue LoadError
-  puts "This script requires json/pure. Please install one of the following:"
-  puts "  gem install json_pure"
-  puts "  gem install json"
-  Process.exit
-end
-
-# Convert all JSON objects in an IO into BSON.
-def print_j2bson(io)
-  io.each_line do |line|
-    jsonobj = JSON.parse(line, { :object_class => BSON::OrderedHash } )
-    bsonobj = BSON.serialize(jsonobj)
-    STDOUT << bsonobj.to_s
-  end
-end
-
-# print usage
-def usage()
-    STDERR << <<END_OF_USAGE
-usage:  j2bson [-h] [file1 [file2]]
-
-   Converts a JSON file to BSON on STDOUT.
-   You can pass multiple filenames.
-   If no filenames are passed, then STDIN is consumed.
-
-END_OF_USAGE
-    exit
-end
-
-# no arg, use STDIN
-# -h, print usage and exit
-# otherwise loop of filenames
-if ARGV.empty? then
-    print_j2bson(STDIN)
-    exit
-elsif ARGV[0] == "-h" then
-    usage()
-else
-    ARGV.each { |fname| print_j2bson(File.new(fname)) }
-end

data/bson.gemspec

@@ -1,34 +0,0 @@
-Gem::Specification.new do |s|
-  s.name              = 'bson'
-
-  s.version           = File.read(File.join(File.dirname(__FILE__), 'VERSION'))
-  s.authors           = ['Emily Stolfo', 'Durran Jordan', 'Gary Murakami', 'Tyler Brock', 'Brandon Black']
-  s.email             = 'mongodb-dev@googlegroups.com'
-  s.homepage          = 'http://www.mongodb.org'
-  s.summary           = 'Ruby implementation of BSON'
-  s.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.'
-  s.rubyforge_project = 'bson'
-  s.license           = 'Apache License Version 2.0'
-
-  if File.exists?('gem-private_key.pem')
-    s.signing_key = 'gem-private_key.pem'
-    s.cert_chain  = ['gem-public_cert.pem']
-  else
-    warn 'Warning: No private key present, creating unsigned gem.'
-  end
-
-  s.files             = ['bson.gemspec', 'LICENSE', 'VERSION']
-  s.files             += ['bin/b2json', 'bin/j2bson', 'lib/bson.rb']
-  s.files             += Dir['lib/bson/**/*.rb']
-
-  if RUBY_PLATFORM =~ /java/
-    s.platform = 'java'
-    s.files    += ['ext/jbson/target/jbson.jar', 'ext/jbson/lib/java-bson.jar']
-  else
-    s.platform = Gem::Platform::RUBY
-  end
-
-  s.executables       = ['b2json', 'j2bson']
-  s.require_paths     = ['lib']
-  s.has_rdoc          = 'yard'
-end

data/lib/bson/bson_c.rb

@@ -1,37 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, 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.
-
-# A thin wrapper for the BSON C-Extension
-module BSON
-  class BSON_C
-
-    def self.serialize(obj, check_keys=false, move_id=false, max_bson_size=DEFAULT_MAX_BSON_SIZE)
-      ByteBuffer.new(CBson.serialize(obj, check_keys, move_id, max_bson_size))
-    end
-
-    def self.deserialize(buf=nil, opts={})
-      CBson.deserialize(ByteBuffer.new(buf).to_s, opts)
-    end
-
-    def self.max_bson_size
-      warn "BSON::BSON_CODER.max_bson_size is deprecated and will be removed in v2.0."
-      CBson.max_bson_size
-    end
-
-    def self.update_max_bson_size(connection)
-      warn "BSON::BSON_CODER.update_max_bson_size is deprecated and now a no-op. It will be removed in v2.0."
-      CBson.update_max_bson_size(connection)
-    end
-  end
-end

data/lib/bson/bson_java.rb

@@ -1,49 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, 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 'jruby'
-
-include Java
-
-jar_dir = File.expand_path(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
-    def self.serialize(obj, check_keys=false, move_id=false, max_bson_size=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)
-      ByteBuffer.new(enc.encode(obj))
-    end
-
-    def self.deserialize(buf, opts={})
-      dec = Java::OrgJbson::RubyBSONDecoder.new
-      callback = Java::OrgJbson::RubyBSONCallback.new(JRuby.runtime)
-      callback.set_opts(opts);
-      dec.decode(buf.to_s.to_java_bytes, callback)
-      callback.get
-    end
-
-    def self.max_bson_size
-      warn "BSON::BSON_CODER.max_bson_size is deprecated and will be removed in v2.0."
-      Java::OrgJbson::RubyBSONEncoder.max_bson_size(self)
-    end
-
-    def self.update_max_bson_size(connection)
-      warn "BSON::BSON_CODER.update_max_bson_size is deprecated and now a no-op. It will be removed in v2.0."
-      Java::OrgJbson::RubyBSONEncoder.update_max_bson_size(self, connection)
-    end
-  end
-end

data/lib/bson/bson_ruby.rb

@@ -1,645 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, 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
-  NULL_BYTE = "\x00"
-
-  # A BSON seralizer/deserializer in pure Ruby.
-  class BSON_RUBY
-    @@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
-    CODE_W_SCOPE = 15
-    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=DEFAULT_MAX_BSON_SIZE)
-      @buf = ByteBuffer.new('', max_bson_size)
-      @encoder = BSON_RUBY
-    end
-
-    if RUBY_VERSION >= '1.9'
-      UTF8_ENCODING   = Encoding.find('utf-8')
-      BINARY_ENCODING = Encoding.find('binary')
-
-      def self.to_utf8_binary(str)
-        begin
-          str.unpack("U*")
-        rescue
-          raise InvalidStringEncoding, "String not valid utf-8: #{str.inspect}"
-        end
-        str.dup.force_encoding(BINARY_ENCODING)
-      end
-    else
-      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.update_max_bson_size(connection)
-      warn "BSON::BSON_CODER.update_max_bson_size is deprecated and now a no-op. It will be removed in v2.0."
-      @@max_bson_size = connection.max_bson_size
-    end
-
-    def self.max_bson_size
-      warn "BSON::BSON_CODER.max_bson_size is deprecated and will be removed in v2.0."
-      @@max_bson_size
-    end
-
-    def self.serialize_cstr(buf, val)
-      buf.put_binary(to_utf8_binary(val.to_s))
-      buf.put_binary(NULL_BYTE)
-    end
-
-    def self.serialize_key(buf, key)
-      raise InvalidDocument, "Key names / regex patterns must not contain the NULL byte" if key.include? "\x00"
-      self.serialize_cstr(buf, key)
-    end
-
-    def to_a
-      @buf.to_a
-    end
-
-    def to_s
-      @buf.to_s
-    end
-
-    # Serializes an object.
-    # Implemented to ensure an API compatible with BSON extension.
-    def self.serialize(obj, check_keys=false, move_id=false, max_bson_size=DEFAULT_MAX_BSON_SIZE)
-      new(max_bson_size).serialize(obj, check_keys, move_id)
-    end
-
-    def self.deserialize(buf=nil, opts={})
-      new.deserialize(buf, opts)
-    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
-      # put in a placeholder for the total size
-      @buf.put_int(0)
-
-      # Write key/value pairs. Always write _id first if it exists.
-      if move_id
-        if obj.has_key? '_id'
-          serialize_key_value('_id', obj['_id'], false)
-        elsif obj.has_key? :_id
-          serialize_key_value('_id', obj[:_id], false)
-        end
-        obj.each {|k, v| serialize_key_value(k, v, check_keys) unless k == '_id' || k == :_id }
-      else
-        if obj.has_key?('_id') && obj.has_key?(:_id)
-          obj['_id'] = obj.delete(:_id)
-        end
-        obj.each {|k, v| serialize_key_value(k, v, check_keys) }
-      end
-
-      serialize_eoo_element(@buf)
-      if @buf.size > @buf.max_size
-        raise InvalidDocument, "Document is too large (#{@buf.size}). " +
-         "This BSON document is limited to #{@buf.max_size} bytes."
-      end
-      @buf.put_int(@buf.size, 0)
-      @buf
-    end
-
-    # Returns the array stored in the buffer.
-    # Implemented to ensure an API compatible with BSON extension.
-    def unpack
-      @buf.to_a
-    end
-
-    def serialize_key_value(k, v, check_keys)
-      k = k.to_s
-      if check_keys
-        if k[0] == ?$
-          raise InvalidKeyName.new("key #{k} must not start with '$'")
-        end
-        if k.include? ?.
-          raise InvalidKeyName.new("key #{k} must not contain '.'")
-        end
-      end
-      type = bson_type(v)
-      case type
-      when STRING, SYMBOL
-        serialize_string_element(@buf, k, v, type)
-      when NUMBER, NUMBER_INT
-        serialize_number_element(@buf, k, v, type)
-      when OBJECT
-        serialize_object_element(@buf, k, v, check_keys)
-      when OID
-        serialize_oid_element(@buf, k, v)
-      when ARRAY
-        serialize_array_element(@buf, k, v, check_keys)
-      when REGEX
-        serialize_regex_element(@buf, k, v)
-      when BOOLEAN
-        serialize_boolean_element(@buf, k, v)
-      when DATE
-        serialize_date_element(@buf, k, v)
-      when NULL
-        serialize_null_element(@buf, k)
-      when REF
-        serialize_dbref_element(@buf, k, v)
-      when BINARY
-        serialize_binary_element(@buf, k, v)
-      when UNDEFINED
-        serialize_null_element(@buf, k)
-      when CODE_W_SCOPE
-        serialize_code_w_scope(@buf, k, v)
-      when MAXKEY
-        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
-    end
-
-    def deserialize(buf=nil, opts={})
-      # If buf is nil, use @buf, assumed to contain already-serialized BSON.
-      # This is only true during testing.
-      if buf.is_a? String
-        @buf = ByteBuffer.new(buf.unpack("C*")) if buf
-      else
-        @buf = ByteBuffer.new(buf.to_a) if buf
-      end
-      @buf.rewind
-      @buf.get_int                # eat message size
-      doc = BSON::OrderedHash.new
-      while @buf.more?
-        type = @buf.get
-        case type
-        when STRING, CODE
-          key = deserialize_cstr(@buf)
-          doc[key] = deserialize_string_data(@buf)
-        when SYMBOL
-          key = deserialize_cstr(@buf)
-          doc[key] = deserialize_string_data(@buf).intern
-        when NUMBER
-          key = deserialize_cstr(@buf)
-          doc[key] = deserialize_number_data(@buf)
-        when NUMBER_INT
-          key = deserialize_cstr(@buf)
-          doc[key] = deserialize_number_int_data(@buf)
-        when NUMBER_LONG
-          key = deserialize_cstr(@buf)
-          doc[key] = deserialize_number_long_data(@buf)
-        when OID
-          key = deserialize_cstr(@buf)
-          doc[key] = deserialize_oid_data(@buf)
-        when ARRAY
-          key = deserialize_cstr(@buf)
-          doc[key] = deserialize_array_data(@buf, opts)
-        when REGEX
-          key = deserialize_cstr(@buf)
-          doc[key] = deserialize_regex_data(@buf, opts)
-        when OBJECT
-          key = deserialize_cstr(@buf)
-          doc[key] = deserialize_object_data(@buf, opts)
-        when BOOLEAN
-          key = deserialize_cstr(@buf)
-          doc[key] = deserialize_boolean_data(@buf)
-        when DATE
-          key = deserialize_cstr(@buf)
-          doc[key] = deserialize_date_data(@buf)
-        when NULL
-          key = deserialize_cstr(@buf)
-          doc[key] = nil
-        when UNDEFINED
-          key = deserialize_cstr(@buf)
-          doc[key] = nil
-        when REF
-          key = deserialize_cstr(@buf)
-          doc[key] = deserialize_dbref_data(@buf)
-        when BINARY
-          key = deserialize_cstr(@buf)
-          doc[key] = deserialize_binary_data(@buf)
-        when CODE_W_SCOPE
-          key = deserialize_cstr(@buf)
-          doc[key] = deserialize_code_w_scope_data(@buf)
-        when TIMESTAMP
-          key = deserialize_cstr(@buf)
-          doc[key] = deserialize_timestamp_data(@buf)
-        when MAXKEY
-          key = deserialize_cstr(@buf)
-          doc[key] = MaxKey.new
-        when MINKEY, 255 # This is currently easier than unpack the type byte as an unsigned char.
-          key = deserialize_cstr(@buf)
-          doc[key] = MinKey.new
-        when EOO
-          break
-        else
-          raise "Unknown type #{type}, key = #{key}"
-        end
-      end
-      @buf.rewind
-      doc
-    end
-
-    # For debugging.
-    def hex_dump
-      str = ''
-      @buf.to_a.each_with_index { |b,i|
-        if (i % 8) == 0
-          str << "\n" if i > 0
-          str << '%4d:  ' % i
-        else
-          str << ' '
-        end
-        str << '%02X' % b
-      }
-      str
-    end
-
-    def deserialize_date_data(buf)
-      milliseconds = buf.get_long
-      Time.at(milliseconds.to_f / 1000.0).utc # at() takes fractional seconds
-    end
-
-    def deserialize_boolean_data(buf)
-      buf.get == 1
-    end
-
-    def deserialize_number_data(buf)
-      buf.get_double
-    end
-
-    def deserialize_number_int_data(buf)
-      buf.get_int
-    end
-
-    def deserialize_number_long_data(buf)
-      buf.get_long
-    end
-
-    def deserialize_object_data(buf, opts={})
-      size = buf.get_int
-      buf.position -= 4
-      object = @encoder.new.deserialize(buf.get(size), opts)
-      if object.has_key? "$ref"
-        DBRef.new(object["$ref"], object["$id"])
-      else
-        object
-      end
-    end
-
-    def deserialize_array_data(buf, opts={})
-      h = deserialize_object_data(buf, opts)
-      a = []
-      h.each { |k, v| a[k.to_i] = v }
-      a
-    end
-
-    def deserialize_regex_data(buf, opts={})
-      compile = opts.key?(:compile_regex) ? opts[:compile_regex] : true
-      compile = true if compile.nil?
-      str = deserialize_cstr(buf)
-      options_str = deserialize_cstr(buf)
-      bson_regex = BSON::Regex.new(str, options_str)
-      compile ? bson_regex.try_compile : bson_regex
-    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")
-        if Encoding.default_internal
-          str.encode!(Encoding.default_internal)
-        end
-      end
-      str
-    end
-
-    def deserialize_string_data(buf)
-      len = buf.get_int
-      bytes = buf.get(len)
-      str = bytes[0..-2]
-      if str.respond_to? "pack"
-        str = str.pack("C*")
-      end
-      encoded_str(str)
-    end
-
-    def deserialize_code_w_scope_data(buf, opts={})
-      buf.get_int
-      len = buf.get_int
-      code = buf.get(len)[0..-2]
-      if code.respond_to? "pack"
-        code = code.pack("C*")
-      end
-
-      scope_size = buf.get_int
-      buf.position -= 4
-      scope = @encoder.new.deserialize(buf.get(scope_size), opts)
-
-      Code.new(encoded_str(code), scope)
-    end
-
-    def deserialize_oid_data(buf)
-      ObjectId.new(buf.get(12))
-    end
-
-    def deserialize_dbref_data(buf)
-      ns = deserialize_string_data(buf)
-      oid = deserialize_oid_data(buf)
-      DBRef.new(ns, oid)
-    end
-
-    def deserialize_binary_data(buf)
-      len = buf.get_int
-      type = buf.get
-      len = buf.get_int if type == Binary::SUBTYPE_BYTES
-      Binary.new(buf.get(len), type)
-    end
-
-    def serialize_eoo_element(buf)
-      buf.put(EOO)
-    end
-
-    def serialize_null_element(buf, key)
-      buf.put(NULL)
-      self.class.serialize_key(buf, key)
-    end
-
-    def serialize_dbref_element(buf, key, val) # this does NOT use the BSON "\x0C" DBPointer type
-      oh = BSON::OrderedHash.new
-      oh['$ref'] = val.namespace
-      oh['$id'] = val.object_id
-      serialize_object_element(buf, key, oh, false)
-    end
-
-    def serialize_binary_element(buf, key, val)
-      buf.put(BINARY)
-      self.class.serialize_key(buf, key)
-
-      bytes = val.to_a
-      num_bytes = bytes.length
-      subtype = val.respond_to?(:subtype) ? val.subtype : Binary::SUBTYPE_BYTES
-      if subtype == Binary::SUBTYPE_BYTES
-        buf.put_int(num_bytes + 4)
-        buf.put(subtype)
-        buf.put_int(num_bytes)
-        buf.put_array(bytes)
-      else
-        buf.put_int(num_bytes)
-        buf.put(subtype)
-        buf.put_array(bytes)
-      end
-    end
-
-    def serialize_boolean_element(buf, key, val)
-      buf.put(BOOLEAN)
-      self.class.serialize_key(buf, key)
-      buf.put(val ? 1 : 0)
-    end
-
-    def serialize_date_element(buf, key, val)
-      buf.put(DATE)
-      self.class.serialize_key(buf, key)
-      millisecs = (val.to_f * 1000).to_i
-      buf.put_long(millisecs)
-    end
-
-    def serialize_number_element(buf, key, val, type)
-      if type == NUMBER
-        buf.put(type)
-        self.class.serialize_key(buf, key)
-        buf.put_double(val)
-      else
-        if val > INT64_MAX or val < INT64_MIN
-          raise RangeError.new("MongoDB can only handle 8-byte ints")
-        end
-        if val > INT32_MAX or val < INT32_MIN
-          buf.put(NUMBER_LONG)
-          self.class.serialize_key(buf, key)
-          buf.put_long(val)
-        else
-          buf.put(type)
-          self.class.serialize_key(buf, key)
-          buf.put_int(val)
-        end
-      end
-    end
-
-    def serialize_object_element(buf, key, val, check_keys, opcode=OBJECT)
-      buf.put(opcode)
-      self.class.serialize_key(buf, key)
-      buf.put_array(@encoder.new.serialize(val, check_keys).to_a)
-    end
-
-    def serialize_array_element(buf, key, val, check_keys)
-      # Turn array into hash with integer indices as keys
-      h = BSON::OrderedHash.new
-      i = 0
-      val.each { |v| h[i] = v; i += 1 }
-      serialize_object_element(buf, key, h, check_keys, ARRAY)
-    end
-
-    def serialize_regex_element(buf, key, val)
-      buf.put(REGEX)
-      self.class.serialize_key(buf, key)
-
-      str = val.source
-      # We use serialize_key here since regex patterns aren't prefixed with
-      # length (can't contain the NULL byte).
-      self.class.serialize_key(buf, str)
-
-      options = val.options
-      options_str = ''
-
-      if val.is_a?(BSON::Regex)
-        options_str << 'i' if ((options & BSON::Regex::IGNORECASE) != 0)
-        options_str << 'l' if ((options & BSON::Regex::LOCALE_DEPENDENT) != 0)
-        options_str << 'm' if ((options & BSON::Regex::MULTILINE) != 0)
-        options_str << 's' if ((options & BSON::Regex::DOTALL) != 0)
-        options_str << 'u' if ((options & BSON::Regex::UNICODE) != 0)
-        options_str << 'x' if ((options & BSON::Regex::EXTENDED) != 0)
-      else
-        options_str << 'm' # Ruby regular expressions always use multiline mode
-        options_str << 'i' if ((options & Regexp::IGNORECASE) != 0)
-        # dotall on the server is multiline in Ruby
-        options_str << 's' if ((options & Regexp::MULTILINE) != 0)
-        options_str << 'x' if ((options & Regexp::EXTENDED) != 0)
-      end
-
-      options_str << val.extra_options_str if val.respond_to?(:extra_options_str)
-      # Must store option chars in alphabetical order
-      self.class.serialize_cstr(buf, options_str.split(//).sort.uniq.join)
-    end
-
-    def serialize_max_key_element(buf, key)
-      buf.put(MAXKEY)
-      self.class.serialize_key(buf, key)
-    end
-
-    def serialize_min_key_element(buf, key)
-      buf.put(MINKEY)
-      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)
-
-      buf.put_array(val.to_a)
-    end
-
-    def serialize_string_element(buf, key, val, type)
-      buf.put(type)
-      self.class.serialize_key(buf, key)
-
-      # Make a hole for the length
-      len_pos = buf.position
-      buf.put_int(0)
-
-      # Save the string
-      start_pos = buf.position
-      self.class.serialize_cstr(buf, val)
-      end_pos = buf.position
-
-      # Put the string size in front
-      buf.put_int(end_pos - start_pos, len_pos)
-
-      # Go back to where we were
-      buf.position = end_pos
-    end
-
-    def serialize_code_w_scope(buf, key, val)
-      buf.put(CODE_W_SCOPE)
-      self.class.serialize_key(buf, key)
-
-      # Make a hole for the length
-      len_pos = buf.position
-      buf.put_int(0)
-
-      buf.put_int(val.code.length + 1)
-      self.class.serialize_cstr(buf, val.code)
-      buf.put_array(@encoder.new.serialize(val.scope).to_a)
-
-      end_pos = buf.position
-      buf.put_int(end_pos - len_pos, len_pos)
-      buf.position = end_pos
-    end
-
-    def deserialize_cstr(buf)
-      chars = ""
-      while true
-        b = buf.get
-        break if b == 0
-        chars << b.chr
-      end
-      encoded_str(chars)
-    end
-
-    def bson_type(o)
-      case o
-      when nil
-        NULL
-      when Integer
-        NUMBER_INT
-      when Float
-        NUMBER
-      when ByteBuffer
-        BINARY
-      when Code
-        CODE_W_SCOPE
-      when String
-        STRING
-      when Array
-        ARRAY
-      when Regexp, BSON::Regex
-        REGEX
-      when ObjectId
-        OID
-      when DBRef
-        REF
-      when true, false
-        BOOLEAN
-      when Time
-        DATE
-      when Hash
-        OBJECT
-      when Symbol
-        SYMBOL
-      when MaxKey
-        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
-        raise InvalidDocument, "#{o.class} is not currently supported; " +
-        "use a UTC Time instance instead."
-      else
-        if defined?(ActiveSupport::Multibyte::Chars) && o.is_a?(ActiveSupport::Multibyte::Chars)
-          STRING
-        elsif defined?(ActiveSupport::TimeWithZone) && o.is_a?(ActiveSupport::TimeWithZone)
-          raise InvalidDocument, "ActiveSupport::TimeWithZone is not currently supported; " +
-          "use a UTC Time instance instead."
-        else
-          raise InvalidDocument, "Cannot serialize #{o.class} as a BSON type; it either isn't supported or won't translate to BSON."
-        end
-      end
-    end
-
-  end
-end