mongo 0.0.2 → 0.0.3

data/README.rdoc

@@ -57,6 +57,23 @@ If you have the source code, you can run the tests.
 
 The tests assume that the Mongo database is running on the default port.
 
+The project mongo-qa (http://github.com/mongodb/mongo-qa) contains many more
+Mongo driver tests that are language independent. To run thoses tests as part
+of the "rake test" task, run
+
+  $ rake mongo_qa
+  $ rake test
+
+The mongo_qa task uses the "git clone" command to make a copy of that project
+in a directory named mongo-qa. If the directory already exists, then the
+mongo_qa task uses "git pull" to updated the code that's there. The Ruby
+driver tests will then use some of the data files from that project when it
+runs BSON tests. You can delete this directory at any time if you don't want
+to run those tests any more.
+
+Additionally, the script bin/validate is used by the mongo-qa project's
+validator script.
+
 
 = Documentation
 

data/Rakefile

@@ -7,7 +7,7 @@ require 'rake/gempackagetask'
 require 'rake/contrib/rubyforgepublisher'
 
 GEM = "mongo"
-GEM_VERSION = '0.0.2'
+GEM_VERSION = '0.0.3'
 SUMMARY = 'Simple pure-Ruby driver for the 10gen Mongo DB'
 DESCRIPTION = 'This is a simple pure-Ruby driver for the 10gen Mongo DB. For more information about Mongo, see http://www.mongodb.org.'
 AUTHOR = 'Jim Menard'
@@ -42,6 +42,17 @@ Rake::TestTask.new do |t|
   t.test_files = FileList['tests/test*.rb']
 end
 
+desc "Clone or pull (update) the mongo-qa project used for testing"
+task :mongo_qa do
+  if File.exist?('mongo-qa')
+    Dir.chdir('mongo-qa') do
+      system('git pull')
+    end
+  else
+    system('git clone git://github.com/mongodb/mongo-qa.git')
+  end
+end
+
 desc "Generate documentation"
 task :rdoc do
   FileUtils.rm_rf('html')

data/bin/validate

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+#
+# usage: validate somefile.xson somefile.bson
+#
+# Reads somefile.xson file (XML that describes a Mongo-type document),
+# converts it into a Ruby OrderedHash, runs that through the BSON
+# serialization code, and writes the BSON bytes to somefile.bson.
+#
+# In addition, this script takes the generated BSON, reads it in then writes
+# it back out to a temp BSON file. If they are different, we report that error
+# to STDOUT.
+#
+# This script is used by the mongo-qa project
+# (http://github.com/mongodb/mongo-qa).
+
+$LOAD_PATH[0,0] = File.join(File.dirname(__FILE__), '..', 'lib')
+require 'mongo'
+require 'mongo/util/xml_to_ruby'
+
+if ARGV.length < 2
+  $stderr.puts "usage: validate somefile.xson somefile.bson"
+  exit 1
+end
+
+# Translate the .xson XML into a Ruby object, turn that object into BSON, and
+# write the BSON to the file as requested.
+obj = File.open(ARGV[0], 'rb') { |f| XMLToRuby.new.xml_to_ruby(f) }
+bson = BSON.new.serialize(obj).to_a
+File.open(ARGV[1], 'wb') { |f| bson.each { |b| f.putc(b) } }
+
+# Now the additional testing. Read the generated BSON back in, deserialize it,
+# and re-serialize the results. Compare that BSON with the BSON from the file
+# we output.
+bson = File.open(ARGV[1], 'rb') { |f| f.read }
+bson = if RUBY_VERSION >= '1.9'
+         bson.bytes.to_a
+       else
+         bson.split(//).collect { |c| c[0] }
+       end
+
+# Turn the Ruby object into BSON bytes and compare with the BSON bytes from
+# the file.
+bson_from_ruby = BSON.new.serialize(obj).to_a
+
+if bson.length != bson_from_ruby.length
+  $stderr.puts "error: round-trip BSON lengths differ when testing #{ARGV[0]}"
+  exit 1
+elsif bson != bson_from_ruby
+  $stderr.puts "error: round-trip BSON contents differ when testing #{ARGV[0]}"
+  exit 1
+end

data/lib/mongo.rb

@@ -1,6 +1,8 @@
 require 'mongo/mongo'
 require 'mongo/objectid'
 require 'mongo/dbref'
+require 'mongo/binary'
+require 'mongo/undefined'
 require 'mongo/message'
 require 'mongo/db'
 require 'mongo/cursor'

data/lib/mongo/binary.rb

@@ -0,0 +1,34 @@
+# --
+# Copyright (C) 2008-2009 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.
+#
+# 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.
+#
+# 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/>.
+# ++
+
+module XGen
+  module Mongo
+    module Driver
+
+      # An array of binary bytes. The only reason this exists is so that the
+      # BSON encoder will know to output the Mongo BINARY type.
+      class Binary < String; end
+
+    end
+  end
+end
+
+class String
+  # Convert a string into a XGen::Mongo::Driver::Binary
+  def to_mongo_binary
+    XGen::Mongo::Driver::Binary.new(self)
+  end
+end

data/lib/mongo/cursor.rb

@@ -167,7 +167,7 @@ module XGen
           buf.put_array(@db.socket.recv(size-4).unpack("C*"), 4)
           @n_remaining -= 1
           buf.rewind
-          BSON.new.deserialize(buf)
+          BSON.new(@db).deserialize(buf)
         end
 
         def to_s

data/lib/mongo/objectid.rb

@@ -47,6 +47,14 @@ module XGen
         MACHINE = ( val = rand(0x1000000); [val & 0xff, (val >> 8) & 0xff, (val >> 16) & 0xff] )
         PID = ( val = rand(0x10000); [val & 0xff, (val >> 8) & 0xff]; )
 
+        # The string representation of an OID is different than its internal
+        # and BSON byte representations. The BYTE_ORDER here maps
+        # internal/BSON byte position (the index in BYTE_ORDER) to the
+        # position of the two hex characters representing that byte in the
+        # string representation. For example, the 0th BSON byte corresponds to
+        # the (0-based) 7th pair of hex chars in the string.
+        BYTE_ORDER = [7, 6, 5, 4, 3, 2, 1, 0, 11, 10, 9, 8]
+
         LOCK = Object.new
         LOCK.extend Mutex_m
 
@@ -57,12 +65,10 @@ module XGen
         # with that value.
         def self.from_string(str)
           data = []
-          i = str.to_i(16)
-          while i > 0
-            data << (i & 0xff)
-            i >>= 8
-          end
-          self.new(data.reverse)
+          BYTE_ORDER.each_with_index { |string_position, data_index|
+            data[data_index] = str[string_position * 2, 2].to_i(16)
+          }
+          self.new(data)
         end
 
         # +data+ is an array of bytes. If nil, a new id will be generated.
@@ -81,7 +87,11 @@ module XGen
         end
 
         def to_s
-          @data.collect { |b| '%02x' % b }.join
+          str = ' ' * 24
+          BYTE_ORDER.each_with_index { |string_position, data_index|
+            str[string_position * 2, 2] = '%02x' % @data[data_index]
+          }
+          str
         end
 
         # (Would normally be private, but isn't so we can test it.)

data/lib/mongo/undefined.rb

@@ -0,0 +1,31 @@
+# --
+# Copyright (C) 2008-2009 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.
+#
+# 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.
+#
+# 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/>.
+# ++
+
+module XGen
+  module Mongo
+    module Driver
+
+      # A special "undefined" type to match Mongo's storage of UNKNOWN values.
+      # "UNKNOWN" comes from JavaScript.
+      #
+      # NOTE: this class does not attempt to provide ANY of the semantics an
+      # "unknown" object might need. It isn't nil, it isn't special in any
+      # way, and there isn't any singleton value.
+      class Undefined < Object; end
+
+    end
+  end
+end

data/lib/mongo/util/bson.rb

@@ -14,6 +14,7 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 # ++
 
+require 'base64'
 require 'mongo/util/byte_buffer'
 require 'mongo/util/ordered_hash'
 require 'mongo/objectid'
@@ -46,7 +47,9 @@ class BSON
     buf.put_array(val.to_s.unpack("C*") + [0])
   end
 
-  def initialize
+  def initialize(db=nil)
+    # db is only needed during deserialization when the data contains a DBRef
+    @db = db
     @buf = ByteBuffer.new
   end
 
@@ -84,7 +87,13 @@ class BSON
         serialize_null_element(@buf, k)
       when REF
         serialize_dbref_element(@buf, k, v)
-      when BINARY, UNDEFINED, SYMBOL, CODE_W_SCOPE
+      when SYMBOL
+        serialize_symbol_element(@buf, k, v)
+      when BINARY
+        serialize_binary_element(@buf, k, v)
+      when UNDEFINED
+        serialize_undefined_element(@buf, k)
+      when CODE_W_SCOPE
         # TODO
         raise "unimplemented type #{type}"
       else
@@ -96,13 +105,13 @@ class BSON
     self
   end
 
-  def deserialize(buf=nil)
+  def deserialize(buf=nil, parent=nil)
     # If buf is nil, use @buf, assumed to contain already-serialized BSON.
     # This is only true during testing.
     @buf = ByteBuffer.new(buf.to_a) if buf
     @buf.rewind
     @buf.get_int                # eat message size
-    doc = {}
+    doc = OrderedHash.new
     while @buf.more?
       type = @buf.get
       case type
@@ -120,13 +129,13 @@ class BSON
         doc[key] = deserialize_oid_data(@buf)
       when ARRAY
         key = deserialize_cstr(@buf)
-        doc[key] = deserialize_array_data(@buf)
+        doc[key] = deserialize_array_data(@buf, doc)
       when REGEX
         key = deserialize_cstr(@buf)
         doc[key] = deserialize_regex_data(@buf)
       when OBJECT
         key = deserialize_cstr(@buf)
-        doc[key] = deserialize_object_data(@buf)
+        doc[key] = deserialize_object_data(@buf, doc)
       when BOOLEAN
         key = deserialize_cstr(@buf)
         doc[key] = deserialize_boolean_data(@buf)
@@ -136,10 +145,19 @@ class BSON
       when NULL
         key = deserialize_cstr(@buf)
         doc[key] = nil
+      when UNDEFINED
+        key = deserialize_cstr(@buf)
+        doc[key] = XGen::Mongo::Driver::Undefined.new
       when REF
         key = deserialize_cstr(@buf)
-        doc[key] = deserialize_dbref_data(@buf)
-      when BINARY, UNDEFINED, SYMBOL, CODE_W_SCOPE
+        doc[key] = deserialize_dbref_data(@buf, key, parent)
+      when SYMBOL
+        key = deserialize_cstr(@buf)
+        doc[key] = deserialize_symbol_data(@buf)
+      when BINARY
+        key = deserialize_cstr(@buf)
+        doc[key] = deserialize_binary_data(@buf)
+      when CODE_W_SCOPE
         # TODO
         raise "unimplemented type #{type}"
       when EOO
@@ -183,14 +201,14 @@ class BSON
     buf.get_int
   end
 
-  def deserialize_object_data(buf)
+  def deserialize_object_data(buf, parent)
     size = buf.get_int
     buf.position -= 4
-    BSON.new.deserialize(buf.get(size))
+    BSON.new(@db).deserialize(buf.get(size), parent)
   end
 
-  def deserialize_array_data(buf)
-    h = deserialize_object_data(buf)
+  def deserialize_array_data(buf, parent)
+    h = deserialize_object_data(buf, parent)
     a = []
     h.each { |k, v| a[k.to_i] = v }
     a
@@ -216,12 +234,22 @@ class BSON
     XGen::Mongo::Driver::ObjectID.new(buf.get(12))
   end
 
-  def deserialize_dbref_data(buf)
+  def deserialize_dbref_data(buf, key, parent)
     ns = deserialize_cstr(buf)
     oid = deserialize_oid_data(buf)
-    # TODO fix parent, field_name, db of DBRef. Does that need to be done here
-    # or by the caller?
-    XGen::Mongo::Driver::DBRef.new(nil, nil, nil, ns, oid)
+    XGen::Mongo::Driver::DBRef.new(parent, key, @db, ns, oid)
+  end
+
+  def deserialize_symbol_data(buf)
+    deserialize_cstr(buf).intern
+  end
+
+  def deserialize_binary_data(buf)
+    len = buf.get_int
+    bytes = buf.get(len)
+    str = ''
+    bytes.each { |c| str << c.chr }
+    str.to_mongo_binary
   end
 
   def serialize_eoo_element(buf)
@@ -240,6 +268,31 @@ class BSON
     buf.put_array(val.object_id.to_a)
   end
 
+  def serialize_symbol_element(buf, key, val)
+    buf.put(SYMBOL)
+    self.class.serialize_cstr(buf, key)
+    self.class.serialize_cstr(buf, val)
+  end
+
+  def serialize_binary_element(buf, key, val)
+    buf.put(BINARY)
+    self.class.serialize_cstr(buf, key)
+    buf.put_int(val.length)
+    bytes = if RUBY_VERSION >= '1.9'
+              val.bytes.to_a
+            else
+              a = []
+              val.each_byte { |byte| a << byte }
+              a
+            end
+    buf.put_array(bytes)
+  end
+
+  def serialize_undefined_element(buf, key)
+    buf.put(UNDEFINED)
+    self.class.serialize_cstr(buf, key)
+  end
+
   def serialize_boolean_element(buf, key, val)
     buf.put(BOOLEAN)
     self.class.serialize_cstr(buf, key)
@@ -337,6 +390,8 @@ class BSON
       NUMBER_INT
     when Numeric
       NUMBER
+    when XGen::Mongo::Driver::Binary # must be before String
+      BINARY
     when String
       # magic awful stuff - the DB requires that a where clause is sent as CODE
       key == "$where" ? CODE : STRING
@@ -354,6 +409,10 @@ class BSON
       DATE
     when Hash
       OBJECT
+    when Symbol
+      SYMBOL
+    when XGen::Mongo::Driver::Undefined
+      UNDEFINED
     else
       raise "Unknown type of object: #{o.class.name}"
     end

data/lib/mongo/util/ordered_hash.rb

@@ -53,7 +53,7 @@ class OrderedHash < Hash
 
   def inspect
     str = '{'
-    str << @ordered_keys.collect { |k| "\"#{k}\"=>#{self.[](k).inspect}" }.join(", ")
+    str << (@ordered_keys || []).collect { |k| "\"#{k}\"=>#{self.[](k).inspect}" }.join(", ")
     str << '}'
   end
 

data/lib/mongo/util/xml_to_ruby.rb

@@ -0,0 +1,102 @@
+# --
+# Copyright (C) 2008-2009 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.
+#
+# 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.
+#
+# 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/>.
+# ++
+
+require 'rexml/document'
+require 'mongo'
+
+# Converts a .xson file (an XML file that describes a Mongo-type document) to
+# an OrderedHash.
+class XMLToRuby
+
+  include XGen::Mongo::Driver
+
+  def xml_to_ruby(io)
+    doc = REXML::Document.new(io)
+    doc_to_ruby(doc.root.elements['doc'])
+  end
+
+  protected
+
+  def element_to_ruby(e)
+    type = e.name
+    child = e.elements[1]
+    case type
+    when 'oid'
+      ObjectID.from_string(e.text)
+    when 'ref'
+      dbref_to_ruby(e.elements)
+    when 'int'
+      e.text.to_i
+    when 'number'
+      e.text.to_f
+    when 'string', 'code'
+      e.text.to_s
+    when 'binary'
+      Base64.decode64(e.text.to_s).to_mongo_binary
+    when 'symbol'
+      e.text.to_s.intern
+    when 'boolean'
+      e.text.to_s == 'true'
+    when 'array'
+      array_to_ruby(e.elements)
+    when 'date'
+      Time.at(e.text.to_f / 1000.0)
+    when 'regex'
+      regex_to_ruby(e.elements)
+    when 'null'
+      nil
+    when 'undefined'
+      Undefined.new
+    when 'doc'
+      doc_to_ruby(e)
+    else
+      raise "Unknown type #{type} in element with name #{e.attributes['name']}"
+    end
+  end
+
+  def doc_to_ruby(element)
+    oh = OrderedHash.new
+    element.elements.each { |e| oh[e.attributes['name']] = element_to_ruby(e) }
+    oh
+  end
+
+  def array_to_ruby(elements)
+    a = []
+    elements.each { |e|
+      index_str = e.attributes['name']
+      a[index_str.to_i] = element_to_ruby(e)
+    }
+    a
+  end
+
+  def regex_to_ruby(elements)
+    pattern = elements['pattern'].text
+    options_str = elements['options'].text || ''
+
+    options = 0
+    options |= Regexp::IGNORECASE if options_str.include?('i')
+    options |= Regexp::MULTILINE if options_str.include?('m')
+    options |= Regexp::EXTENDED if options_str.include?('x')
+    Regexp.new(pattern, options)
+  end
+
+  def dbref_to_ruby(elements)
+    ns = elements['ns'].text
+    oid_str = elements['oid'].text
+    DBRef.new(nil, nil, nil, ns, ObjectID.from_string(oid_str))
+  end
+
+end

data/tests/test_bson.rb

@@ -8,6 +8,9 @@ class BSONTest < Test::Unit::TestCase
   include XGen::Mongo::Driver
 
   def setup
+    # We don't pass a DB to the constructor, even though we are about to test
+    # deserialization. This means that when we deserialize, any DBRefs will
+    # have nil @db ivars. That's fine for now.
     @b = BSON.new
   end
 
@@ -79,11 +82,36 @@ class BSONTest < Test::Unit::TestCase
 
   def test_dbref
     oid = ObjectID.new
-    doc = {'dbref' => DBRef.new(nil, nil, nil, 'namespace', oid)}
+    doc = {}
+    doc['dbref'] = DBRef.new(doc, 'dbref', nil, 'namespace', oid)
     @b.serialize(doc)
     doc2 = @b.deserialize
     assert_equal 'namespace', doc2['dbref'].namespace
     assert_equal oid, doc2['dbref'].object_id
   end
 
+  def test_symbol
+    doc = {'sym' => :foo}
+    @b.serialize(doc)
+    doc2 = @b.deserialize
+    assert_equal :foo, doc2['sym']
+  end
+
+  def test_binary
+    bin = 'binstring'.to_mongo_binary
+    assert_kind_of Binary, bin
+
+    doc = {'bin' => bin}
+    @b.serialize(doc)
+    doc2 = @b.deserialize
+    assert_equal 'binstring', doc2['bin']
+  end
+
+  def test_undefined
+    doc = {'undef' => Undefined.new}
+    @b.serialize(doc)
+    doc2 = @b.deserialize
+    assert_kind_of Undefined, doc2['undef']
+  end
+
 end

data/tests/test_objectid.rb

@@ -73,4 +73,16 @@ class ObjectIDTest < Test::Unit::TestCase
     assert_equal @o.to_s, o2.to_s
   end
 
+  def test_from_string_leading_zeroes
+    hex_str = '000000000000000000abcdef'
+    o = ObjectID.from_string(hex_str)
+    assert_equal hex_str, o.to_s
+  end
+
+  def test_byte_order
+    hex_str = '000102030405060708090A0B'
+    o = ObjectID.from_string(hex_str)
+    assert_equal [0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x0b, 0x0a, 0x09, 0x08], o.to_a
+  end
+
 end

data/tests/test_round_trip.rb

@@ -1,11 +1,16 @@
 HERE = File.dirname(__FILE__)
 $LOAD_PATH[0,0] = File.join(HERE, '..', 'lib')
 require 'mongo'
-require 'rexml/document'
+require 'mongo/util/xml_to_ruby'
 require 'test/unit'
 
 # For each xml/bson file in the data subdirectory, we turn the XML into an
 # OrderedHash and then test both Ruby-to-BSON and BSON-to-Ruby translations.
+#
+# There is a whole other project that includes similar tests
+# (http://github.com/mongodb/mongo-qa). If the directory ../mongo-qa exists,
+# then we find the BSON test files there and use those, too. Use the Rake task
+# "mongo_qa" to obtain those tests.
 class RoundTripTest < Test::Unit::TestCase
 
   include XGen::Mongo::Driver
@@ -16,117 +21,96 @@ class RoundTripTest < Test::Unit::TestCase
     unless @@ruby
       names = Dir[File.join(HERE, 'data', '*.xml')].collect {|f| File.basename(f).sub(/\.xml$/, '') }
       @@ruby = {}
-      names.each { |name| @@ruby[name] = xml_to_ruby(name) }
+      names.each { |name|
+        File.open(File.join(HERE, 'data', "#{name}.xml")) { |f|
+          @@ruby[name] = XMLToRuby.new.xml_to_ruby(f)
+        }
+      }
     end
   end
 
-  def xml_to_ruby(name)
-    File.open(File.join(HERE, 'data', "#{name}.xml")) { |f|
-      doc = REXML::Document.new(f)
-      doc_to_ruby(doc.root.elements['doc'])
-    }
-  end
-
-  def element_to_ruby(e)
-    type = e.name
-    child = e.elements[1]
-    case type
-    when 'oid'
-      ObjectID.from_string(e.text)
-    when 'ref'
-      dbref_to_ruby(e.elements)
-    when 'int'
-      e.text.to_i
-    when 'number'
-      e.text.to_f
-    when 'string', 'code'
-      e.text.to_s
-    when 'boolean'
-      e.text.to_s == 'true'
-    when 'array'
-      array_to_ruby(e.elements)
-    when 'date'
-      Time.at(e.text.to_f / 1000.0)
-    when 'regex'
-      regex_to_ruby(e.elements)
-    when 'null'
-      nil
-    when 'doc'
-      doc_to_ruby(e)
-    else
-      raise "Unknown type #{type} in element with name #{e.attributes['name']}"
-    end
+  def test_dummy
+    assert true
   end
 
-  def doc_to_ruby(element)
-    oh = OrderedHash.new
-    element.elements.each { |e| oh[e.attributes['name']] = element_to_ruby(e) }
-    oh
+  def self.create_test_for_round_trip_files_in_dir(dir)
+    names = Dir[File.join(dir, '*.xson')].collect {|f| File.basename(f).sub(/\.xson$/, '') }
+    names.each { |name|
+      eval <<EOS
+def test_#{name}_#{dir.gsub(/[^a-zA-Z0-9_]/, '_')}
+  one_round_trip("#{dir}", "#{name}")
+end
+EOS
+    }
   end
 
-  def array_to_ruby(elements)
-    a = []
-    elements.each { |e|
-      index_str = e.attributes['name']
-      a[index_str.to_i] = element_to_ruby(e)
+  # Dynamically generate one test for each test file. This way, if one test
+  # fails the others will still run.
+  create_test_for_round_trip_files_in_dir(File.join(HERE, 'data'))
+  mongo_qa_dir = File.join(HERE, '..', 'mongo-qa/modules/bson_tests')
+  if File.exist?(mongo_qa_dir)
+    %w(basic_types complex single_types).each { |subdir_name|
+      create_test_for_round_trip_files_in_dir(File.join(mongo_qa_dir, subdir_name))
     }
-    a
   end
 
-  def regex_to_ruby(elements)
-    pattern = elements['pattern'].text
-    options_str = elements['options'].text || ''
-
-    options = 0
-    options |= Regexp::IGNORECASE if options_str.include?('i')
-    options |= Regexp::MULTILINE if options_str.include?('m')
-    options |= Regexp::EXTENDED if options_str.include?('x')
-    Regexp.new(pattern, options)
-  end
+  # Round-trip comparisons of Ruby-to-BSON and back.
+  # * Take the objects that were read from XML
+  # * Turn them into BSON bytes
+  # * Compare that with the BSON files we have
+  # * Turn those BSON bytes back in to Ruby objects
+  # * Turn them back into BSON bytes
+  # * Compare that with the BSON files we have (or the bytes that were already
+  #   generated)
+  def one_round_trip(dir, name)
+    obj = File.open(File.join(dir, "#{name}.xson")) { |f|
+      XMLToRuby.new.xml_to_ruby(f)
+    }
 
-  def dbref_to_ruby(elements)
-    ns = elements['ns'].text
-    oid_str = elements['oid'].text
-    DBRef.new(nil, nil, nil, ns, ObjectID.from_string(oid_str))
-  end
+    File.open(File.join(dir, "#{name}.bson"), 'r') { |f|
+      # Read the BSON from the file
+      bson = f.read
+      bson = if RUBY_VERSION >= '1.9'
+               bson.bytes.to_a
+             else
+               bson.split(//).collect { |c| c[0] }
+             end
 
-# DEBUG
-#   def test_foo
-#     $stderr.puts "#{@@ruby['smorgasbord'].class.name}" # DEBUG
-#     $stderr.puts "@@ruby['smorgasbord'] = #{@@ruby['smorgasbord'].inspect.gsub(/, /, ",\n")}" # DEBUG
-#   end
+      # Turn the Ruby object into BSON bytes and compare with the BSON bytes
+      # from the file.
+      bson_from_ruby = BSON.new.serialize(obj).to_a
 
-  def test_ruby_to_bson
-    @@ruby.each { |name, obj|
-      File.open(File.join(HERE, 'data', "#{name}.bson"), 'r') { |f|
-        bson = f.read
-        bson = if RUBY_VERSION >= '1.9'
-                 bson.bytes
-               else
-                 bson.split(//).collect { |c| c[0] }
-        end
-        bson_from_ruby = BSON.new.serialize(obj).to_a
+      begin
         assert_equal bson.length, bson_from_ruby.length
         assert_equal bson, bson_from_ruby
-      }
+      rescue => ex
+#         File.open(File.join(dir, "#{name}_out_a.bson"), 'wb') { |f| # DEBUG
+#           bson_from_ruby.each { |b| f.putc(b) }
+#         }
+        raise ex
+      end
+
+      # Turn those BSON bytes back into a Ruby object.
+      #
+      # We're passing a nil db to the contructor here, but that's OK because
+      # the BSON DBFef bytes don't contain the db object in any case, and we
+      # don't care what the database is.
+      obj_from_bson = BSON.new(nil).deserialize(ByteBuffer.new(bson_from_ruby))
+      assert_kind_of OrderedHash, obj_from_bson
+
+      # Turn that Ruby object into BSON and compare it to the original BSON
+      # bytes.
+      bson_from_ruby = BSON.new.serialize(obj_from_bson).to_a
+      begin
+        assert_equal bson.length, bson_from_ruby.length
+        assert_equal bson, bson_from_ruby
+      rescue => ex
+#         File.open(File.join(dir, "#{name}_out_b.bson"), 'wb') { |f| # DEBUG
+#           bson_from_ruby.each { |b| f.putc(b) }
+#         }
+        raise ex
+      end
     }
   end
 
-#   def test_bson_to_ruby
-#     @@ruby.each { |name, obj|
-#       File.open(File.join(HERE, 'data', "#{name}.bson"), 'r') { |f|
-#         bson = f.read
-#         obj_from_bson = BSON.new.deserialize(ByteBuffer.new(bson.split(//)))
-#         assert_equal obj, obj_from_bson
-#       }
-#     }
-#   end
-
-#   # Technically reduntant, given the other tests
-#   def test_roundtrips
-#     @@ruby.each { |name, obj|
-      
-#     }
-#   end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mongo
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Jim Menard
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-09 00:00:00 -05:00
+date: 2009-01-12 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -23,7 +23,9 @@ extra_rdoc_files: []
 
 files: 
 - bin/mongo_console
+- bin/validate
 - lib/mongo/admin.rb
+- lib/mongo/binary.rb
 - lib/mongo/collection.rb
 - lib/mongo/cursor.rb
 - lib/mongo/db.rb
@@ -42,9 +44,11 @@ files:
 - lib/mongo/mongo.rb
 - lib/mongo/objectid.rb
 - lib/mongo/query.rb
+- lib/mongo/undefined.rb
 - lib/mongo/util/bson.rb
 - lib/mongo/util/byte_buffer.rb
 - lib/mongo/util/ordered_hash.rb
+- lib/mongo/util/xml_to_ruby.rb
 - lib/mongo.rb
 - tests/test_admin.rb
 - tests/test_bson.rb