bson 1.0.1 → 1.0.2

data/Rakefile

@@ -134,18 +134,18 @@ namespace :gem do
 
   desc "Install the gem locally"
   task :install do
+    sh "gem build bson.gemspec"
+    sh "gem install bson-*.gem"
     sh "gem build mongo-ruby-driver.gemspec"
     sh "gem install mongo-*.gem"
     sh "rm mongo-*.gem"
+    sh "rm bson-*.gem"
   end
 
   desc "Install the optional c extensions"
   task :install_extensions do
-    sh "gem build bson.gemspec"
     sh "gem build bson_ext.gemspec"
-    sh "gem install bson-*.gem"
     sh "gem install bson_ext-*.gem"
-    sh "rm bson-*.gem"
     sh "rm bson_ext-*.gem"
   end
 

data/bin/b2json

@@ -0,0 +1,63 @@
+#!/usr/bin/ruby
+# 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 'rubygems'
+require 'bson'
+
+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.rb [-h] [file1 [file2]]
+
+   Converts a BSON file to JSON on STDOUT.
+   You can pass multiple filename.
+   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/bson.gemspec

@@ -13,8 +13,11 @@ Gem::Specification.new do |s|
 
   s.files  = ['Rakefile', 'bson.gemspec', 'LICENSE.txt']
   s.files += ['lib/bson.rb'] + Dir['lib/bson/**/*.rb']
+  s.files += ['bin/b2json']
   s.test_files = Dir['test/mongo_bson/*.rb']
 
+  s.executables = ['b2json']
+
   s.has_rdoc = true
 
   s.authors = ['Jim Menard', 'Mike Dirolf', 'Kyle Banker']

data/lib/bson.rb

@@ -2,8 +2,10 @@
 
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
+MINIMUM_BSON_EXT_VERSION = "1.0.1"
+
 module BSON
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
   def self.serialize(obj, check_keys=false, move_id=false)
     BSON_CODER.serialize(obj, check_keys, move_id)
   end
@@ -12,13 +14,33 @@ module BSON
   def self.deserialize(buf=nil)
     BSON_CODER.deserialize(buf)
   end
+
+  # Reads a single BSON document from an IO object.
+  # This method is used in the executable b2json, bundled with
+  # the bson gem, for reading a file of bson documents.
+  #
+  # @param [IO] io an io object containing a bson object.
+  #
+  # @return [ByteBuffer]
+  def self.read_bson_document(io)
+    bytebuf = BSON::ByteBuffer.new
+    sz = io.read(4).unpack("V")[0]
+    bytebuf.put_int(sz)
+    bytebuf.put_array(io.read(sz-4).unpack("C*"))
+    bytebuf.rewind
+    return BSON.deserialize(bytebuf)
+  end
 end
 
 begin
   # Need this for running test with and without c ext in Ruby 1.9.
   raise LoadError if ENV['TEST_MODE'] && !ENV['C_EXT']
   require 'bson_ext/cbson'
-  raise LoadError unless defined?(CBson::VERSION) && CBson::VERSION == BSON::VERSION
+  raise LoadError unless defined?(CBson::VERSION)
+  if CBson::VERSION < MINIMUM_BSON_EXT_VERSION
+    puts "Able to load bson_ext version #{CBson::VERSION}, but >= #{MINIMUM_BSON_EXT_VERSION} is required."
+    raise LoadError
+  end
   require 'bson/bson_c'
   module BSON
     BSON_CODER = BSON_C

data/lib/bson/bson_c.rb

@@ -1,5 +1,21 @@
 # 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.
+# ++
+
 # A thin wrapper for the CBson class
 module BSON
   class BSON_C
@@ -10,7 +26,7 @@ module BSON
 
     def self.deserialize(buf=nil)
       if buf.is_a? String
-        to_deserialize = ByteBuffer.new(buf) if buf
+        buf = ByteBuffer.new(buf.unpack("C*")) if buf
       else
         buf = ByteBuffer.new(buf.to_a) if buf
       end

data/lib/bson/bson_java.rb

@@ -0,0 +1,123 @@
+# encoding: UTF-8
+# A thin wrapper for the CBson class
+module BSON
+  module JMongo
+    import com.mongodb.BasicDBList
+    import com.mongodb.BasicDBObject
+    import com.mongodb.Bytes
+    import org.bson.BSONDecoder
+    import org.bson.BSONEncoder
+
+    import org.bson.BSONCallback
+    import org.bson.types.BasicBSONList
+    import org.bson.BasicBSONObject
+    import org.bson.types.Binary
+    import org.bson.types.ObjectId
+    import org.bson.types.Symbol
+    import org.bson.types.CodeWScope
+  end
+end
+
+module BSON
+  class BSON_JAVA
+    #ENC = JMongo::BSONEncoder.new
+    BSON::ObjectID
+
+    ENC = Java::OrgJbson::RubyBSONEncoder.new(JRuby.runtime)
+    DEC = JMongo::BSONDecoder.new
+
+
+    def self.deserialize(buf)
+      if buf.is_a? String
+        buf = ByteBuffer.new(buf.unpack("C*")) if buf
+      end
+      callback = Java::OrgJbson::RubyBSONCallback.new(JRuby.runtime)
+      DEC.decode(buf.to_a.to_java(Java::byte), callback)
+      callback.get
+    end
+
+    def deserialize(buf)
+      callback = Java::OrgJbson::RubyBSONCallback.new(JRuby.runtime)
+      DEC.decode(buf.to_a.to_java(Java::byte), callback)
+      callback.get
+    end
+
+    def self.serialize(obj, check=false, move=false)
+      ENC.encode(obj)
+    end
+
+    def to_dbobject obj
+      case obj
+      when Array
+        array_to_dblist obj
+      when Hash
+        hash_to_dbobject obj
+      #when BSON::Binary
+      #  JMongo::Binary.new(obj.subtype, obj.to_a)
+      when BSON::ObjectID
+        JMongo::ObjectId.new(obj.to_s)
+      when Regexp
+        str     = obj.source
+        options = obj.options
+        options_flag = 0
+        options_flag |= JavaPattern::CASE_INSENSITIVE if ((options & Regexp::IGNORECASE) != 0)
+        options_flag |= JavaPattern::MULTILINE  if ((options & Regexp::MULTILINE) != 0)
+        #options_flag |= JavaPattern::EXTENDED if ((options & Regexp::EXTENDED) != 0)
+        Java::JavaUtilRegex::Pattern.compile(str, options_flag)
+      when Symbol
+        JMongo::Symbol.new(obj)
+      when BSON::Binary
+        obj.put_int(obj.size, 0)
+        b = JMongo::Binary.new(obj.subtype, obj.to_a.to_java(Java::byte))
+        obj.to_a.to_java(Java::byte)
+      when BSON::DBRef
+
+
+      else
+        # primitive value, no conversion necessary
+        #puts "Un-handled class type [#{obj.class}]"
+        obj
+      end
+    end
+
+    def from_java_object(obj)
+      case obj
+       when JMongo::BasicBSONList
+        obj
+       when JMongo::BasicBSONObject
+        hsh = {}
+        obj.toMap.keySet.each do |key|
+          value    = obj.get(key)
+          hsh[key] = self.from_java_object(value)
+        end
+        hsh
+       when JMongo::ObjectId
+         BSON::ObjectID.from_string(obj.toStringMongod())
+       else
+         obj
+       end
+    end
+
+    private
+
+    def hash_to_dbobject doc
+      obj = JMongo::BasicDBObject.new
+
+      doc.each_pair do |key, value|
+        obj.append(key, to_dbobject(value))
+      end
+
+      obj
+    end
+
+    def array_to_dblist ary
+      list = JMongo::BasicDBList.new
+
+      ary.each_with_index do |element, index|
+        list.put(index, to_dbobject(element))
+      end
+
+      list
+    end
+  end
+end

data/lib/bson/bson_ruby.rb

@@ -3,26 +3,23 @@
 # --
 # Copyright (C) 2008-2010 10gen Inc.
 #
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU Affero General Public License, version 3, as
-# published by the Free Software Foundation.
+# 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
 #
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
-# for more details.
+#     http://www.apache.org/licenses/LICENSE-2.0
 #
-# You should have received a copy of the GNU Affero General Public License
-# along with this program. If not, see <http://www.gnu.org/licenses/>.
+# 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 BSON seralizer/deserializer in pure Ruby.
   class BSON_RUBY
 
-    # why was this necessary?
-    #include Mongo
-
     MINKEY = -1
     EOO = 0
     NUMBER = 1
@@ -178,7 +175,7 @@ module BSON
       # 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) if buf
+        @buf = ByteBuffer.new(buf.unpack("C*")) if buf
       else
         @buf = ByteBuffer.new(buf.to_a) if buf
       end

data/lib/bson/types/objectid.rb

@@ -22,6 +22,10 @@ require 'digest/md5'
 
 module BSON
 
+  def BSON::ObjectID(s)
+    ObjectID.from_string(s)
+  end
+
   # Generates MongoDB object ids.
   #
   # @core objectids
@@ -129,11 +133,11 @@ module BSON
     end
 
     def inspect
-      {"$oid" => to_s}
+      "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 $id key.
+    # 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(escaped=false)

data/test/mongo_bson/basic_test.rb

@@ -0,0 +1,99 @@
+# encoding:utf-8
+require 'test/test_helper'
+require 'complex'
+require 'bigdecimal'
+require 'rational'
+require 'benchmark'
+
+MEDIUM = {
+  'integer' => 5,
+  'number' => 5.05,
+  'boolean' => false,
+  'array' => ['test', 'benchmark']
+}
+
+
+LARGE = {
+  'base_url' => 'http://www.example.com/test-me',
+  'total_word_count' => 6743,
+  'access_time' => Time.now,
+  'meta_tags' => {
+    'description' => 'i am a long description string',
+    'author' => 'Holly Man',
+    'dynamically_created_meta_tag' => 'who know\n what'
+  },
+  'page_structure' => {
+    'counted_tags' => 3450,
+    'no_of_js_attached' => 10,
+    'no_of_images' => 6
+  },
+  'harvested_words' => ['10gen','web','open','source','application','paas',
+                        'platform-as-a-service','technology','helps',
+                        'developers','focus','building','mongodb','mongo'] * 20
+}
+
+
+
+begin
+  require 'active_support/core_ext'
+  require 'active_support/hash_with_indifferent_access'
+  Time.zone = "Pacific Time (US & Canada)"
+  Zone = Time.zone.now
+rescue LoadError
+  warn 'Could not test BSON with HashWithIndifferentAccess.'
+  module ActiveSupport
+    class TimeWithZone
+    end
+  end
+  Zone = ActiveSupport::TimeWithZone.new
+end
+
+class BSONTest < Test::Unit::TestCase
+  include BSON
+
+  def test_string
+    doc = {'doc' => 'hello, world'}
+    bson = bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_object
+    doc = {'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_oid
+    doc = {'doc' => ObjectID.new}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_array
+    doc = {'doc' => [1, 2, "a", "b"]}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_speed
+
+  Benchmark.bm do |x|
+    x.report('serialize obj') do
+      1000.times do
+        BSON::BSON_CODER.serialize(LARGE)
+      end
+    end
+  end
+
+
+
+  Benchmark.bm do |x|
+        b = BSON::BSON_CODER.serialize(LARGE)
+    x.report('deserialize obj') do
+      1000.times do
+        BSON::BSON_CODER.deserialize(b)
+      end
+    end
+  end
+  end
+end

data/test/mongo_bson/bson_test.rb

@@ -22,12 +22,28 @@ class BSONTest < Test::Unit::TestCase
 
   include BSON
 
+  def test_read_bson_io_document
+    doc = {'doc' => 'hello, world'}
+    bson = BSON.serialize(doc)
+    io = StringIO.new
+    io.write(bson.to_s)
+    io.rewind
+    assert_equal BSON.deserialize(bson), BSON.read_bson_document(io)
+  end
+
   def test_serialize_returns_byte_buffer
     doc = {'doc' => 'hello, world'}
     bson = BSON.serialize(doc)
     assert bson.is_a?(ByteBuffer)
   end
 
+  def test_deserialize_from_string
+    doc = {'doc' => 'hello, world'}
+    bson = BSON.serialize(doc)
+    string = bson.to_s
+    assert_equal doc, BSON.deserialize(string)
+  end
+
   def test_deprecated_bson_module
     doc = {'doc' => 'hello, world'}
     bson = BSON.serialize(doc)

data/test/mongo_bson/jruby_bson_test.rb

@@ -0,0 +1,242 @@
+# encoding:utf-8
+require 'test/test_helper'
+require 'complex'
+require 'bigdecimal'
+require 'rational'
+require 'benchmark'
+
+MEDIUM = {
+  'integer' => 5,
+  'number' => 5.05,
+  'boolean' => false,
+  'array' => ['test', 'benchmark']
+}
+
+
+LARGE = {
+  'base_url' => 'http://www.example.com/test-me',
+  'total_word_count' => 6743,
+  'access_time' => Time.now,
+  'meta_tags' => {
+    'description' => 'i am a long description string',
+    'author' => 'Holly Man',
+    'dynamically_created_meta_tag' => 'who know\n what'
+  },
+  'page_structure' => {
+    'counted_tags' => 3450,
+    'no_of_js_attached' => 10,
+    'no_of_images' => 6
+  },
+  'harvested_words' => ['10gen','web','open','source','application','paas',
+                        'platform-as-a-service','technology','helps',
+                        'developers','focus','building','mongodb','mongo'] * 20
+}
+
+
+
+begin
+  require 'active_support/core_ext'
+  require 'active_support/hash_with_indifferent_access'
+  Time.zone = "Pacific Time (US & Canada)"
+  Zone = Time.zone.now
+rescue LoadError
+  warn 'Could not test BSON with HashWithIndifferentAccess.'
+  module ActiveSupport
+    class TimeWithZone
+    end
+  end
+  Zone = ActiveSupport::TimeWithZone.new
+end
+
+class BSONTest < Test::Unit::TestCase
+  include BSON
+  
+  def setup
+    @coder = BSON::BSON_CODER
+  end
+
+  def assert_doc_pass(doc)
+    bson = @coder.serialize(doc)
+    assert_equal doc, @coder.deserialize(bson)
+  end
+
+  def test_string
+    assert_doc_pass({'doc' => 'hello, world'})
+  end
+
+  def test_nested_string
+    assert_doc_pass({'doc' => {'text' => 'hello, world'}})
+  end
+
+  def test_array
+    assert_doc_pass({'doc' => ['1', 2, 3]})
+  end
+
+  def test_object
+    assert_doc_pass({'doc' => {'age' => 42, 'name' => 'Spongebob', 'shoe_size' => 9.5}})
+  end
+
+  def test_boolean
+    doc = {'foo' => true}
+    bson = @coder.serialize(doc)
+    assert_equal doc, @coder.deserialize(bson)
+  end
+
+  def test_nil
+    assert_doc_pass({'foo' => nil})
+  end
+
+  def test_time
+    assert_doc_pass({'foo' => Time.now})
+  end
+
+  def test_regex
+    assert_doc_pass({'foo' => /^a/im})
+  end
+
+  def test_symbol
+    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)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_valid_utf8_key
+    doc = {'aé' => 'hello'}
+    bson = bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_number
+    doc = {'doc' => 41.99}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_int
+    doc = {'doc' => 42}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+
+    doc = {"doc" => -5600}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+
+    doc = {"doc" => 2147483647}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+
+    doc = {"doc" => -2147483648}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, 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)
+  end
+
+  def test_object
+    doc = {'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_oid
+    doc = {'doc' => ObjectID.new}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_array
+    doc = {'doc' => [1, 2, 'a', 'b']}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_regex
+    doc = {'doc' => /foobar/i}
+    bson = BSON::BSON_CODER.serialize(doc)
+    doc2 = BSON::BSON_CODER.deserialize(bson)
+    assert_equal doc, doc2
+
+    r = doc2['doc']
+    assert_kind_of Regexp, r
+
+    doc = {'doc' => r}
+    bson_doc = BSON::BSON_CODER.serialize(doc)
+    doc2 = nil
+    doc2 = BSON::BSON_CODER.deserialize(bson_doc)
+    assert_equal doc, doc2
+  end
+
+  def test_boolean
+    doc = {'doc' => true}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_date
+    doc = {'date' => Time.now}
+    bson = BSON::BSON_CODER.serialize(doc)
+    doc2 = BSON::BSON_CODER.deserialize(bson)
+    # Mongo only stores up to the millisecond
+    assert_in_delta doc['date'], doc2['date'], 0.001
+  end
+
+  def test_date_returns_as_utc
+    doc = {'date' => Time.now}
+    bson = BSON::BSON_CODER.serialize(doc)
+    doc2 = BSON::BSON_CODER.deserialize(bson)
+    assert doc2['date'].utc?
+  end
+
+  def test_dbref
+    oid = ObjectID.new
+    doc = {}
+    doc['dbref'] = DBRef.new('namespace', oid)
+    bson = BSON::BSON_CODER.serialize(doc)
+    doc2 = BSON::BSON_CODER.deserialize(bson)
+    assert_equal 'namespace', doc2['dbref'].namespace
+    assert_equal oid, doc2['dbref'].object_id
+  end
+
+  def test_symbol
+    doc = {'sym' => :foo}
+    bson = BSON::BSON_CODER.serialize(doc)
+    doc2 = BSON::BSON_CODER.deserialize(bson)
+    assert_equal :foo, doc2['sym']
+  end
+
+#  def test_regex_extended
+#    assert_doc_pass({'foo' => /^a/x})
+#  end
+#
+   def test_object_id
+     assert_doc_pass({'_id' => BSON::ObjectID.new})
+   end
+end

data/test/mongo_bson/jruby_encode_test.rb

@@ -0,0 +1,269 @@
+# encoding:utf-8
+require 'test/test_helper'
+require 'complex'
+require 'bigdecimal'
+require 'rational'
+require 'benchmark'
+
+MEDIUM = {
+  'integer' => 5,
+  'number' => 5.05,
+  'boolean' => false,
+  'array' => ['test', 'benchmark']
+}
+
+
+LARGE = {
+  'base_url' => 'http://www.example.com/test-me',
+  'total_word_count' => 6743,
+  'access_time' => 123, #Time.now,
+  'meta_tags' => {
+    'description' => 'i am a long description string',
+    'author' => 'Holly Man',
+    'dynamically_created_meta_tag' => 'who know\n what'
+  },
+  'page_structure' => {
+    'counted_tags' => 3450,
+    'no_of_js_attached' => 10,
+    'no_of_images' => 6
+  },
+  'harvested_words' => ['10gen','web','open','source','application','paas',
+                        'platform-as-a-service','technology','helps',
+                        'developers','focus','building','mongodb','mongo'] * 20
+}
+
+class BSONTest < Test::Unit::TestCase
+  include BSON
+  
+  def setup
+    @coder = BSON::BSON_CODER
+  end
+
+  def assert_doc_pass(doc)
+    bson = @coder.serialize(doc)
+    assert_equal doc, @coder.deserialize(bson)
+  end
+
+#  def test_symbol_key
+#    doc     = {:foo => "bar"}
+#    p doc.keys
+#    bson    = @coder.serialize(doc)
+#    new_doc = {"foo" => "bar"}
+#    assert_equal new_doc, @coder.deserialize(bson)
+#  end
+#
+#  def test_string
+#    assert_doc_pass({'doc' => 'hello, world'})
+#  end
+#
+  require 'iconv'
+      def test_invalid_string
+      require 'iconv'
+      string = Iconv.conv('iso-8859-1', 'utf-8', 'aé')
+      doc = {'doc' => string}
+      bson = @coder.serialize(doc)
+      assert_equal doc, @coder.deserialize(bson)
+    end
+
+
+#  def test_nested_string
+#    assert_doc_pass({'doc' => {'text' => 'hello, world'}})
+#  end
+#
+#  def test_array
+#    assert_doc_pass({'doc' => ['1', '2', '3']})
+#  end
+#
+#  def test_number
+#    assert_doc_pass({'doc' => 1})
+#  end
+#
+#  def test_object
+#    assert_doc_pass({'doc' => {'age' => 42, 'name' => 'Spongebob', 'shoe_size' => 9.5}})
+#  end
+#
+#  def test_boolean
+#    assert_doc_pass({'foo' => true})
+#    assert_doc_pass({'foo' => false})
+#  end
+#
+#  def test_nil
+#    assert_doc_pass({'foo' => nil})
+#  end
+#
+#  def test_time
+#    assert_doc_pass({'foo' => Time.now})
+#  end
+#
+#  def test_simple_regex
+#    assert_doc_pass({'foo' => /^a/})
+#  end
+#
+#  def test_regex_with_options
+#    assert_doc_pass({'foo' => /^a/imx})
+#  end
+#
+#  def test_symbol
+#    assert_doc_pass({'foo' => :bar})
+#  end
+#
+#  def test_binary
+#    doc = {'foo' => BSON::Binary.new("ABCDE".unpack("C*"))}
+#    bson = @coder.serialize(doc)
+#    de = @coder.deserialize(bson)
+#    assert_equal doc, de
+#  end
+#
+#  def test_valid_utf8_string
+#    doc = {'doc' => 'aé'}
+#    bson = bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#  end
+#
+#  def test_valid_utf8_key
+#    doc = {'aé' => 'hello'}
+#    bson = bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#  end
+#
+#  def test_number
+#    doc = {'doc' => 41.99}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#  end
+#
+#  def test_int
+#    doc = {'doc' => 42}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#
+#    doc = {"doc" => -5600}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#
+#    doc = {"doc" => 2147483647}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#
+#    doc = {"doc" => -2147483648}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, 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)
+#  end
+#
+#  def test_object
+#    doc = {'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_oid
+##    doc = {'doc' => ObjectID.new}
+##    bson = BSON::BSON_CODER.serialize(doc)
+##    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+##  end
+##
+##  def test_array
+##    doc = {'doc' => [1, 2, 'a', 'b']}
+##    bson = BSON::BSON_CODER.serialize(doc)
+##    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+##  end
+##
+##  def test_invalid_object
+##    doc = {'foo' => Object.new}
+##    assert_raise InvalidDocument do
+##      @coder.serialize(doc)
+##    end
+##
+##    assert_raise InvalidDocument do
+##      @coder.serialize({'date' => Date.today})
+##    end
+##  end
+##
+##
+##  def test_regex
+##    doc = {'doc' => /foobar/i}
+##    bson = BSON::BSON_CODER.serialize(doc)
+##    doc2 = BSON::BSON_CODER.deserialize(bson)
+##    assert_equal doc, doc2
+##
+##    r = doc2['doc']
+##    assert_kind_of Regexp, r
+##
+##    doc = {'doc' => r}
+##    bson_doc = BSON::BSON_CODER.serialize(doc)
+##    doc2 = nil
+##    doc2 = BSON::BSON_CODER.deserialize(bson_doc)
+##    assert_equal doc, doc2
+##  end
+##
+#  def test_boolean
+#    doc = {'doc' => true}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#  end
+#
+#  def test_date
+#    doc = {'date' => Time.now}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    doc2 = BSON::BSON_CODER.deserialize(bson)
+#    # Mongo only stores up to the millisecond
+#    assert_in_delta doc['date'], doc2['date'], 0.001
+#  end
+#
+#  def test_date_returns_as_utc
+#    doc = {'date' => Time.now}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    doc2 = BSON::BSON_CODER.deserialize(bson)
+#    assert doc2['date'].utc?
+#  end
+#
+##  def test_dbref
+##    oid = ObjectID.new
+##    doc = {}
+##    doc['dbref'] = DBRef.new('namespace', oid)
+##    bson = BSON::BSON_CODER.serialize(doc)
+##    doc2 = BSON::BSON_CODER.deserialize(bson)
+##    assert_equal 'namespace', doc2['dbref'].namespace
+##    assert_equal oid, doc2['dbref'].object_id
+##  end
+##
+#  def test_symbol
+#    doc = {'sym' => :foo}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    doc2 = BSON::BSON_CODER.deserialize(bson)
+#    assert_equal :foo, doc2['sym']
+#  end
+##
+###  def test_regex_extended
+###    assert_doc_pass({'foo' => /^a/x})
+###  end
+###
+#   def test_object_id
+#     assert_doc_pass({'_id' => BSON::ObjectID.new})
+#   end
+#
+#   def test_where
+#     assert_doc_pass({'$where' => "function() { print('hello'); }"})
+#   end
+#
+#   def test_min_max_keys
+#     assert_doc_pass({'doc' => BSON::MaxKey.new})
+#     assert_doc_pass({'doc' => BSON::MinKey.new})
+#   end
+#
+#   def test_code
+#     code = BSON::Code.new("print('hello')")
+#     code.scope = {:foo => 2}
+#     assert_doc_pass({'doc' => code})
+#   end
+end

data/test/mongo_bson/objectid_test.rb

@@ -1,4 +1,6 @@
 require 'test/test_helper'
+require 'rubygems'
+require 'json'
 
 class ObjectIDTest < Test::Unit::TestCase
 
@@ -49,9 +51,12 @@ class ObjectIDTest < Test::Unit::TestCase
     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
-    obj = {'$oid' => @o.to_s}
-    assert_equal obj, @o.inspect
+    assert_equal "BSON::ObjectID('#{@o.to_s}')", @o.inspect
   end
 
   def test_save_and_restore

metadata

@@ -1,43 +1,45 @@
 --- !ruby/object:Gem::Specification 
 name: bson
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors: 
-- Jim Menard
-- Mike Dirolf
-- Kyle Banker
+  - Jim Menard
+  - Mike Dirolf
+  - Kyle Banker
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-05-07 00:00:00 -04:00
+date: 2010-06-05 00:00:00 -04:00
 default_executable: 
 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
-executables: []
-
+executables: 
+  - b2json
 extensions: []
 
 extra_rdoc_files: []
 
 files: 
-- Rakefile
-- bson.gemspec
-- LICENSE.txt
-- lib/bson.rb
-- lib/bson/bson_c.rb
-- lib/bson/bson_ruby.rb
-- lib/bson/byte_buffer.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/objectid.rb
+  - Rakefile
+  - bson.gemspec
+  - 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/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/objectid.rb
+  - bin/b2json
 has_rdoc: true
 homepage: http://www.mongodb.org
 licenses: []
@@ -46,18 +48,18 @@ post_install_message:
 rdoc_options: []
 
 require_paths: 
-- lib
+  - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   version: 
 requirements: []
 
@@ -67,8 +69,11 @@ signing_key:
 specification_version: 3
 summary: Ruby implementation of BSON
 test_files: 
-- test/mongo_bson/binary_test.rb
-- test/mongo_bson/bson_test.rb
-- test/mongo_bson/byte_buffer_test.rb
-- test/mongo_bson/objectid_test.rb
-- test/mongo_bson/ordered_hash_test.rb
+  - 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/objectid_test.rb
+  - test/mongo_bson/ordered_hash_test.rb