em-mongo 0.1.1 → 0.2.4

data/lib/em-mongo/collection.rb

@@ -15,7 +15,7 @@ module EM::Mongo
       skip  = opts.delete(:skip) || 0
       limit = opts.delete(:limit) || 0
 
-      @connection.find(@name, skip, limit, selector, &blk)
+      @connection.find(@name, skip, limit, selector, nil, &blk)
     end
 
     def first(selector={}, opts={}, &blk)
@@ -26,7 +26,7 @@ module EM::Mongo
     end
 
     def insert(obj)
-      obj[:_id] ||= EM::Mongo::Util.unique_id 
+      obj['_id'] ||= EM::Mongo::Util.unique_id
       @connection.insert(@name, obj)
       obj
     end
@@ -36,11 +36,5 @@ module EM::Mongo
       true
     end
 
-    #def method_missing meth
-    #  puts meth
-    #  raise ArgumentError, 'collection cannot take block' if block_given?
-    #  (@subns ||= {})[meth] ||= self.class.new("#{@ns}.#{meth}", @client)
-    #end
-
   end
 end

data/lib/em-mongo/connection.rb

@@ -19,6 +19,9 @@ module EM::Mongo
     OP_INSERT   = 2002
     OP_QUERY    = 2004
     OP_DELETE   = 2006
+    
+    STANDARD_HEADER_SIZE = 16
+    RESPONSE_HEADER_SIZE = 20
 
     attr_reader :connection
 
@@ -30,56 +33,73 @@ module EM::Mongo
       @is_connected
     end
 
-    # RMongo interface
+    # XXX RMongo interface
     def collection(db = DEFAULT_DB, ns = DEFAULT_NS)
       raise "Not connected" if not connected?
       EM::Mongo::Collection.new(db, ns, self)
     end
 
+    def new_request_id
+      @request_id += 1
+    end
+
     # MongoDB Commands
 
-    def send_command(id, *args, &blk)
-      request_id = @request_id += 1
+    def message_headers(operation, request_id, message)
+      headers = BSON::ByteBuffer.new
+      headers.put_int(16 + message.size)
+      headers.put_int(request_id)
+      headers.put_int(0)
+      headers.put_int(operation)
+      headers
+    end
 
-      callback {
-        buf  = Buffer.new
-        buf.write :int, request_id,
-                  :int, response = 0,
-                  :int, operation = id
+    def send_command(buffer, request_id, &blk)
 
-        buf.write *args
-        send_data [ buf.size + 4 ].pack('i') # header length first
-        send_data buf.data
-      }
+      callback do
+        send_data buffer
+      end
 
       @responses[request_id] = blk if blk
       request_id
     end
 
+
     def insert(collection_name, documents)
-      # XXX multiple documents?
-      send_command(OP_INSERT, :int,      RESERVED,
-                              :cstring,  collection_name,
-                              :bson,     documents)
+      message = BSON::ByteBuffer.new([0, 0, 0, 0])
+      BSON::BSON_RUBY.serialize_cstr(message, collection_name)
+
+      documents = [documents] if not documents.is_a?(Array)
+      documents.each { |doc| message.put_array(BSON::BSON_CODER.serialize(doc, true, true).to_a) }
+
+      req_id = new_request_id
+      message.prepend!(message_headers(OP_INSERT, req_id, message))
+      send_command(message.to_s, req_id)
     end
 
     def delete(collection_name, selector)
-      send_command(OP_DELETE, :int,      RESERVED,
-                              :cstring,  collection_name,
-                              :int,      RESERVED,
-                              :bson,     selector)
+      message = BSON::ByteBuffer.new([0, 0, 0, 0])
+      BSON::BSON_RUBY.serialize_cstr(message, collection_name)
+      message.put_int(0)
+      message.put_array(BSON::BSON_CODER.serialize(selector, false, true).to_a)
+      req_id = new_request_id
+      message.prepend!(message_headers(OP_DELETE, req_id, message))
+      send_command(message.to_s, req_id)
     end
 
-    def find(collection_name, skip, limit, query, &blk)
-      send_command(OP_QUERY,  :int,       RESERVED,
-                              :cstring,   collection_name,
-                              :int,       skip,
-                              :int,       limit,
-                              :bson,      query,
-                              &blk)
+    def find(collection_name, skip, limit, query, fields, &blk)
+      message = BSON::ByteBuffer.new
+      message.put_int(RESERVED) # query options
+      BSON::BSON_RUBY.serialize_cstr(message, collection_name)
+      message.put_int(skip)
+      message.put_int(limit)
+      message.put_array(BSON::BSON_CODER.serialize(query, false).to_a)
+      message.put_array(BSON::BSON_CODER.serialize(fields, false).to_a) if fields
+      req_id = new_request_id
+      message.prepend!(message_headers(OP_QUERY, req_id, message))
+      send_command(message.to_s, req_id, &blk)
     end
 
-
     # EM hooks
     def initialize(options={})
       @request_id = 0
@@ -88,7 +108,7 @@ module EM::Mongo
       @host = options[:host] || DEFAULT_IP
       @port = options[:port] || DEFAULT_PORT
 
-      @on_close = proc{
+      @on_close = proc {
         raise Error, "could not connect to server #{@host}:#{@port}"
       }
       timeout options[:timeout] if options[:timeout]
@@ -101,36 +121,82 @@ module EM::Mongo
     end
 
     def connection_completed
-      log 'connected'
-      @buf = Buffer.new
+      @buffer = BSON::ByteBuffer.new
       @is_connected = true
       @on_close = proc{
       }
       succeed
     end
 
-    def receive_data data
-      log "receive_data: #{data.size}"#, data
 
-      @buf << data
+    def message_received?
+      size = @buffer.get_int
+      @buffer.rewind
+      @buffer.size >= size-4 ? true : false
+    end
+
+    def receive_data(data)
+
+      @buffer.put_array(data.unpack('C*'))
+      @buffer.rewind
+      return if @buffer.size < STANDARD_HEADER_SIZE
+
+      if message_received?
+
+        # Header
+        header = BSON::ByteBuffer.new
+        header.put_array(@buffer.get(STANDARD_HEADER_SIZE))
+        unless header.size == STANDARD_HEADER_SIZE
+          raise "Short read for DB header: " +
+            "expected #{STANDARD_HEADER_SIZE} bytes, saw #{header.size}"
+        end
+        header.rewind
+        size        = header.get_int
+        request_id  = header.get_int
+        response_to = header.get_int
+        op          = header.get_int
+
+        # Response Header
+        response_header = BSON::ByteBuffer.new
+        response_header.put_array(@buffer.get(RESPONSE_HEADER_SIZE))
+        if response_header.length != RESPONSE_HEADER_SIZE
+          raise "Short read for DB response header; " +
+            "expected #{RESPONSE_HEADER_SIZE} bytes, saw #{response_header.length}"
+        end
+
+        response_header.rewind
+        result_flags     = response_header.get_int
+        cursor_id        = response_header.get_long
+        starting_from    = response_header.get_int
+        number_remaining = response_header.get_int
 
-      until @buf.empty?
-        size = @buf._peek(0, 4, 'I')
+        # Documents
+        docs = (1..number_remaining).map do |n|
 
-        break unless @buf.size >= size-4
+          buf = BSON::ByteBuffer.new
+          buf.put_int(@buffer.get_int)
 
-        size, id, response, operation = @buf.read(:int, :int, :int, :int)
-        reserved, cursor, start, num = @buf.read(:int, :longlong, :int, :int)
+          buf.rewind
+          size = buf.get_int
 
-        results = (1..num).map do
-          @buf.read(:bson)
+          if size > @buffer.size
+            @buffer = ''
+            raise "Buffer Overflow: Failed to parse buffer"
+          end
+          buf.put_array(@buffer.get(size-4), 4)
+
+          buf.rewind
+          BSON::BSON_CODER.deserialize(buf)
         end
 
-        if cb = @responses.delete(response)
-          cb.call(results)
+        @buffer.clear
+
+        if cb = @responses.delete(response_to)
+          cb.call(docs)
         end
-        close_connection if @close_pending and @responses.size == 0
+        close_connection if @close_pending and @responses.size == 0 
       end
+      
     end
 
     def send_data data

data/lib/em-mongo.rb

@@ -1,30 +1,29 @@
-require 'eventmachine'
-require 'pp'
 
-begin
-  require 'securerandom'
-rescue LoadError
-  require 'uuid'
-end
+require "eventmachine"
+begin; require "bson_ext"; rescue LoadError; require "bson"; end
+
 
 module EM::Mongo
-  VERSION = '0.0.1'
+
+  module Version
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 4
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+
+  NAME    = 'em-mongo'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
-  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  PATH    = ::File.dirname(LIBPATH) + ::File::SEPARATOR
 
   class Util
     def self.unique_id
-      if defined? SecureRandom
-        SecureRandom.hex(12)
-      else
-        UUID.new.generate(:compact).gsub(/^(.{20})(.{8})(.{4})$/){ $1+$3 }
-      end 
+      BSON::ObjectID.new.to_s
     end
   end
 end
 
 require File.join(EM::Mongo::LIBPATH, "em-mongo/connection")
-require File.join(EM::Mongo::LIBPATH, "em-mongo/buffer")
 require File.join(EM::Mongo::LIBPATH, "em-mongo/collection")
 
 EMMongo = EM::Mongo

data/spec/collection_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.expand_path('spec_helper', File.dirname(__FILE__))
 
 describe EMMongo::Collection do
   include EM::SpecHelper
@@ -22,20 +22,31 @@ describe EMMongo::Collection do
 
   it 'should insert an object' do
     EM::Spec::Mongo.collection do |collection|
-      obj = collection.insert(:hello => 'world')
-      obj.keys.should include :_id
-      obj[:_id].should be_a_kind_of String
-      obj[:_id].length.should == 24
+      obj = collection.insert('hello' => 'world')
+      obj.keys.should include '_id'
+      obj['_id'].should be_a_kind_of String
+      obj['_id'].length.should == 24
       EM::Spec::Mongo.close
     end
   end
 
-  it 'should find an object' do
+  it 'should find an object by attribute' do
     EM::Spec::Mongo.collection do |collection|
-      collection.insert(:hello => 'world') 
-      r = collection.find({:hello => "world"},{}) do |res|
+      collection.insert("hello" => 'world') 
+      r = collection.find({"hello" => "world"},{}) do |res|
         res.size.should >= 1
-        res[0][:hello].should == "world"
+        res[0]["hello"].should == "world"
+        EM::Spec::Mongo.close
+      end
+    end
+  end
+
+  it 'should find an object by id' do
+    EM::Spec::Mongo.collection do |collection|
+      obj = collection.insert('hello' => 'world') 
+      collection.find({'_id' => obj['_id']},{}) do |res|
+        res.size.should >= 1
+        res[0]['hello'].should == "world"
         EM::Spec::Mongo.close
       end
     end
@@ -43,8 +54,8 @@ describe EMMongo::Collection do
 
   it 'should find all objects' do
     EM::Spec::Mongo.collection do |collection|
-      collection.insert(:one => 'one')
-      collection.insert(:two => 'two')
+      collection.insert('one' => 'one')
+      o = collection.insert('two' => 'two')
       collection.find do |res|
         res.size.should >= 2
         EM::Spec::Mongo.close
@@ -54,9 +65,9 @@ describe EMMongo::Collection do
 
   it 'should remove an object' do
     EM::Spec::Mongo.collection do |collection|
-      obj = collection.insert(:hello => 'world')
-      collection.remove(obj)
-      collection.find({:hello => "world"}) do |res|
+      obj = collection.insert('hello' => 'world')
+      collection.remove('_id' => obj['_id'])
+      collection.find({'hello' => "world"}) do |res|
         res.size.should == 0
         EM::Spec::Mongo.close
       end
@@ -65,8 +76,8 @@ describe EMMongo::Collection do
 
   it 'should remove all objects' do
     EM::Spec::Mongo.collection do |collection|
-      collection.insert(:one => 'one')
-      collection.insert(:two => 'two')
+      collection.insert('one' => 'one')
+      collection.insert('two' => 'two')
       collection.remove
       collection.find do |res|
         res.size.should == 0
@@ -75,37 +86,52 @@ describe EMMongo::Collection do
     end
   end
 
+  it 'should insert a Time' do
+    EM::Spec::Mongo.collection do |collection|
+      t = Time.now.utc.freeze
+      collection.insert('date' => t)
+      collection.find do |res|
+        res[0]['date'].to_s.should == t.to_s
+        EM::Spec::Mongo.close
+      end
+    end
+  end
+
   it 'should insert a complex object' do
     EM::Spec::Mongo.collection do |collection|
       obj = {
-        :array => [1,2,3],
-        :float => 123.456,
-        :hash => {:boolean => true},
-        :nil => nil,
-        :symbol => :name,
-        :string => 'hello world',
-        :time => Time.at(Time.now.to_i),
-        :regex => /abc$/ix
+        'array' => [1,2,3],
+        'float' => 123.456,
+        'hash' => {'boolean' => true},
+        'nil' => nil,
+        'symbol' => :name,
+        'string' => 'hello world',
+        'time' => Time.now.to_f,
+        'regex' => /abc$/ix
       }
-      obj = collection.insert(obj)
-      collection.find(:_id => obj[:_id]) do |ret|
-        ret.should == [ obj ]
+      retobj = collection.insert(obj)
+      collection.find({'_id' => obj['_id']}) do |ret|
+        ret.size.should == 1
+        ret[0].each_key do |key|
+          ret[0][key].should == obj[key]
+        end
         EM::Spec::Mongo.close
       end
+      
     end
   end
 
   it 'should find an object using nested properties' do
     EM::Spec::Mongo.collection do |collection|
       collection.insert({
-        :name => 'Google',
-        :address => {
-          :city => 'Mountain View',
-          :state => 'California'}
+        'name' => 'Google',
+        'address' => {
+          'city' => 'Mountain View',
+          'state' => 'California'}
       })
 
       collection.first('address.city' => 'Mountain View') do |res|
-        res[:name].should == 'Google'
+        res['name'].should == 'Google'
         EM::Spec::Mongo.close
       end
     end
@@ -114,12 +140,12 @@ describe EMMongo::Collection do
   it 'should find objects with specific values' do
     EM::Spec::Mongo.collection do |collection|
       @numbers.each do |num, word|
-        collection.insert(:num => num, :word => word)
+        collection.insert({'num' => num, 'word' => word})
       end
 
-      collection.find({:num => {'$in' => [1,3,5]}}) do |res|
+      collection.find({'num' => {'$in' => [1,3,5]}}) do |res|
         res.size.should == 3
-        res.map{|r| r[:num] }.sort.should == [1,3,5]
+        res.map{|r| r['num'] }.sort.should == [1,3,5]
         EM::Spec::Mongo.close
       end
     end
@@ -128,12 +154,12 @@ describe EMMongo::Collection do
   it 'should find objects greater than something' do
     EM::Spec::Mongo.collection do |collection|
       @numbers.each do |num, word|
-        collection.insert(:num => num, :word => word)
+        collection.insert('num' => num, 'word' => word)
       end
 
-      collection.find({:num => {'$gt' => 3}}) do |res|
+      collection.find({'num' => {'$gt' => 3}}) do |res|
         res.size.should == 6
-        res.map{|r| r[:num] }.sort.should == [4,5,6,7,8,9]
+        res.map{|r| r['num'] }.sort.should == [4,5,6,7,8,9]
         EM::Spec::Mongo.close
       end
     end

data/spec/connection_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.expand_path('spec_helper', File.dirname(__FILE__))
 
 describe EMMongo::Connection do
   include EM::SpecHelper
@@ -32,7 +32,7 @@ describe EMMongo::Connection do
   # Support the old RMongo interface for now
   it 'should instantiate a Collection' do
     EM::Spec::Mongo.connection do |connection|
-      connection.collection.is_a?(Collection).should == true
+      connection.collection.is_a?(EM::Mongo::Collection).should == true
       EM::Spec::Mongo.close
     end 
   end
@@ -40,9 +40,9 @@ describe EMMongo::Connection do
   it 'should instantiate a Databse' do
     EM::Spec::Mongo.connection do |connection|
       db1 = connection.db
-      db1.is_a?(Database).should == true
+      db1.is_a?(EM::Mongo::Database).should == true
       db2 = connection.db('db2')
-      db2.is_a?(Database).should == true
+      db2.is_a?(EM::Mongo::Database).should == true
       db2.should_not == db1
       EM::Spec::Mongo.close
     end 

data/spec/spec_helper.rb

@@ -1,10 +1,9 @@
-require File.dirname(__FILE__) + '/../lib/em-mongo'
+require "rubygems"
+require "bundler"
 
-#$LOAD_PATH << File.dirname(__FILE__)+'/../../em-spec/lib'
-#require File.dirname(__FILE__)+'/../../em-spec/lib/em/spec'
-#require 'spec'
-#require File.dirname(__FILE__)+'/../../em-spec/lib/em/spec/rspec'
-#EM.spec_backend = EventMachine::Spec::Rspec
+Bundler.setup(:test)
+
+require File.expand_path('../lib/em-mongo', File.dirname(__FILE__))
 
 require "em-spec/rspec"
 

metadata

@@ -4,17 +4,17 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 4
+  version: 0.2.4
 platform: ruby
 authors: 
-- tmm1, bcg
+- bcg
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-03-03 00:00:00 -05:00
+date: 2010-04-19 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -31,8 +31,22 @@ dependencies:
         version: 0.12.10
   type: :runtime
   version_requirements: *id001
-description: em-mongo
-email: 
+- !ruby/object:Gem::Dependency 
+  name: bson
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 20
+        - 1
+        version: 0.20.1
+  type: :runtime
+  version_requirements: *id002
+description: EventMachine drive for MongoDB.
+email: brenden.grace@gmail.com
 executables: []
 
 extensions: []
@@ -40,7 +54,6 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/em-mongo/buffer.rb
 - lib/em-mongo/collection.rb
 - lib/em-mongo/connection.rb
 - lib/em-mongo.rb
@@ -73,9 +86,8 @@ rubyforge_project:
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: em-mongo based on rmongo
+summary: EventMachine drive for MongoDB.
 test_files: 
-- spec/buffer_spec.rb
 - spec/collection_spec.rb
 - spec/connection_spec.rb
 - spec/spec_helper.rb

data/lib/em-mongo/buffer.rb

@@ -1,414 +0,0 @@
-if [].map.respond_to? :with_index
-  class Array
-    def enum_with_index
-      each.with_index
-    end
-  end
-else
-  require 'enumerator'
-end
-
-module EM::Mongo
-  class Buffer
-    class Overflow    < Exception; end
-    class InvalidType < Exception; end
-    
-    def initialize data = ''
-      @data = data
-      @pos = 0
-    end
-    attr_reader :pos
-    
-    def data
-      @data.clone
-    end
-    alias :contents :data
-    alias :to_s :data
-
-    def << data
-      @data << data.to_s
-      self
-    end
-    
-    def length
-      @data.length
-    end
-    alias :size :length
-    
-    def empty?
-      pos == length
-    end
-    
-    def rewind
-      @pos = 0
-    end
-    
-    def read *types
-      values = types.map do |type|
-        case type
-        when :byte
-          _read(1, 'C')
-        when :short
-          _read(2, 'n')
-        when :int
-          _read(4, 'I')
-        when :double
-          _read(8, 'd')
-        when :long
-          _read(4, 'N')
-        when :longlong
-          upper, lower = _read(8, 'NN')
-          upper << 32 | lower
-        when :cstring
-          str = @data.unpack("@#{@pos}Z*").first
-          @data.slice!(@pos, str.size+1)
-          str
-        when :oid
-          # _read(12, 'i*').enum_with_index.inject([]) do |a, (num, i)|
-          #   a[ i == 0 ? 1 : i == 1 ? 0 : i ] = num # swap first two
-          #   a
-          # end.map do |num|
-          #   num.to_s(16).rjust(8,'0')
-          # end.join('')
-
-          _read(12, 'I*').map do |num|
-            num.to_s(16).rjust(8,'0')
-          end.join('')
-        when :bson
-          bson = {}
-          data = Buffer.new _read(read(:int)-4)
-          
-          until data.empty?
-            type = data.read(:byte)
-            next if type == 0 # end of object
-
-            key = data.read(:cstring).intern
-
-            bson[key] = case type
-                        when 1 # number
-                          data.read(:double)
-                        when 2 # string
-                          data.read(:int)
-                          data.read(:cstring)
-                        when 3 # object
-                          data.read(:bson)
-                        when 4 # array
-                          data.read(:bson).inject([]){ |a, (k,v)| a[k.to_s.to_i] = v; a }
-                        when 5 # binary
-                          data._read data.read(:int)
-                        when 6 # undefined
-                        when 7 # oid
-                          data.read(:oid)
-                        when 8 # bool
-                          data.read(:byte) == 1 ? true : false
-                        when 9 # time
-                          Time.at data.read(:longlong)/1000.0
-                        when 10 # nil
-                          nil
-                        when 11 # regex
-                          source = data.read(:cstring)
-                          options = data.read(:cstring).split('')
-                          
-                          options = { 'i' => 1, 'm' => 2, 'x' => 4 }.inject(0) do |s, (o, n)|
-                            s |= n if options.include?(o)
-                            s
-                          end
-
-                          Regexp.new(source, options)
-                        when 12 # ref
-                          ref = {}
-                          ref[:_ns] = data.read(:cstring)
-                          ref[:_id] = data.read(:oid)
-                          ref
-                        when 13 # code
-                          data.read(:int)
-                          data.read(:cstring)
-                        when 14 # symbol
-                          data.read(:int)
-                          data.read(:cstring).intern
-                        end
-          end
-          
-          bson
-        else
-          raise InvalidType, "Cannot read data of type #{type}"
-        end
-      end
-      
-      types.size == 1 ? values.first : values
-    end
-    
-    def write *args
-      args.each_slice(2) do |type, data|
-        case type
-        when :byte
-          _write(data, 'C')
-        when :short
-          _write(data, 'n')
-        when :int
-          _write(data, 'I')
-        when :double
-          _write(data, 'd')
-        when :long
-          _write(data, 'N')
-        when :longlong
-          lower =  data & 0xffffffff
-          upper = (data & ~0xffffffff) >> 32
-          _write([upper, lower], 'NN')
-        when :cstring
-          _write(data.to_s + "\0")
-        when :oid
-          # data.scan(/.{8}/).enum_with_index.inject([]) do |a, (num, i)|
-          #   a[ i == 0 ? 1 : i == 1 ? 0 : i ] = num # swap first two
-          #   a
-          # end.each do |num|
-          #   write(:int, num.to_i(16))
-          # end
-          data.scan(/.{8}/).each do |num|
-            write(:int, num.to_i(16))
-          end
-        when :bson
-          buf = Buffer.new
-          data.each do |key,value|
-            case value
-            when Numeric
-              id = 1
-              type = :double
-            when String
-              if key == :_id
-                id = 7
-                type = :oid
-              else
-                id = 2
-                type = proc{ |out|
-                  out.write(:int, value.length+1)
-                  out.write(:cstring, value)
-                }
-              end
-            when Hash
-              if data.keys.map{|k| k.to_s}.sort == %w[ _id _ns ]
-                id = 12 # ref
-                type = proc{ |out|
-                  out.write(:cstring, data[:_ns])
-                  out.write(:oid, data[:_id])
-                }
-              else
-                id = 3
-                type = :bson
-              end
-            when Array
-              id = 4
-              type = :bson
-              value = value.enum_with_index.inject({}){ |h, (v, i)| h.update i => v }
-            when TrueClass, FalseClass
-              id = 8
-              type = :byte
-              value = value ? 1 : 0
-            when Time
-              id = 9
-              type = :longlong
-              value = value.to_i * 1000 + (value.tv_usec/1000)
-            when NilClass
-              id = 10
-              type = nil
-            when Regexp
-              id = 11
-              type = proc{ |out|
-                out.write(:cstring, value.source)
-                out.write(:cstring, { 'i' => 1, 'm' => 2, 'x' => 4 }.inject('') do |s, (o, n)|
-                  s += o if value.options & n > 0
-                  s
-                end)
-              }
-            when Symbol
-              id = 14
-              type = proc{ |out|
-                out.write(:int, value.to_s.length+1)
-                out.write(:cstring, value.to_s)
-              }
-            end
-
-            buf.write(:byte, id)
-            buf.write(:cstring, key)
-
-            if type.respond_to? :call
-              type.call(buf)
-            elsif type
-              buf.write(type, value)
-            end
-          end
-          buf.write(:byte, 0) # eoo
-
-          write(:int, buf.size+4)
-          _write(buf.to_s)
-        else
-          raise InvalidType, "Cannot write data of type #{type}"
-        end
-      end
-      self
-    end
-
-    def _peek(pos, size, pack)
-      data = @data[pos,size]
-      data = data.unpack(pack)
-      data = data.pop if data.size == 1
-      data
-    end
-
-    def _read size, pack = nil
-      if @pos + size > length
-        raise Overflow
-      else
-        data = @data[@pos,size]
-        @data[@pos,size] = ''
-        if pack
-          data = data.unpack(pack)
-          data = data.pop if data.size == 1
-        end
-        data
-      end
-    end
-    
-    def _write data, pack = nil
-      data = [*data].pack(pack) if pack
-      @data[@pos,0] = data
-      @pos += data.length
-    end
-
-    def extract
-      begin
-        cur_data, cur_pos = @data.clone, @pos
-        yield self
-      rescue Overflow
-        @data, @pos = cur_data, cur_pos
-        nil
-      end
-    end
-  end
-end
-
-if $0 =~ /bacon/ or $0 == __FILE__
-  require 'bacon'
-  Bacon.summary_on_exit
-  include Mongo
-
-  describe Buffer do
-    before do
-      @buf = Buffer.new
-    end
-
-    should 'have contents' do
-      @buf.contents.should == ''
-    end
-
-    should 'initialize with data' do
-      @buf = Buffer.new('abc')
-      @buf.contents.should == 'abc'
-    end
-
-    should 'append raw data' do
-      @buf << 'abc'
-      @buf << 'def'
-      @buf.contents.should == 'abcdef'
-    end
-
-    should 'append other buffers' do
-      @buf << Buffer.new('abc')
-      @buf.data.should == 'abc'
-    end
-
-    should 'have a position' do
-      @buf.pos.should == 0
-    end
-
-    should 'have a length' do
-      @buf.length.should == 0
-      @buf << 'abc'
-      @buf.length.should == 3
-    end
-
-    should 'know the end' do
-      @buf.empty?.should == true
-    end
-
-    should 'read and write data' do
-      @buf._write('abc')
-      @buf.rewind
-      @buf._read(2).should == 'ab'
-      @buf._read(1).should == 'c'
-    end
-
-    should 'raise on overflow' do
-      lambda{ @buf._read(1) }.should.raise Buffer::Overflow
-    end
-
-    should 'raise on invalid types' do
-      lambda{ @buf.read(:junk) }.should.raise Buffer::InvalidType
-      lambda{ @buf.write(:junk, 1) }.should.raise Buffer::InvalidType
-    end
-  
-    { :byte => 0b10101010,
-      :short => 100,
-      :int => 65536,
-      :double => 123.456,
-      :long => 100_000_000,
-      :longlong => 666_555_444_333_222_111,
-      :cstring => 'hello',
-    }.each do |type, value|
-
-      should "read and write a #{type}" do
-        @buf.write(type, value)
-        @buf.rewind
-        @buf.read(type).should == value
-        @buf.should.be.empty
-      end
-
-    end
-    
-    should "read and write multiple times" do
-      arr = [ :byte, 0b10101010, :short, 100 ]
-      @buf.write(*arr)
-      @buf.rewind
-      @buf.read(arr.shift).should == arr.shift
-      @buf.read(arr.shift).should == arr.shift
-    end
-    
-    [
-      { :num => 1                                      },
-      { :symbol => :abc                                },
-      { :object => {}                                  },
-      { :array => [1, 2, 3]                            },
-      { :string => 'abcdefg'                           },
-      { :oid => { :_id => '51d9ca7053a2012be4ecd660' } },
-      { :ref => { :_ns => 'namespace',
-                  :_id => '51d9ca7053a2012be4ecd660' } },
-      { :boolean => true                               },
-      { :time => Time.at(Time.now.to_i)                },
-      { :null => nil                                   },
-      { :regex => /^.*?def/im                          }
-    ]. each do |bson|
-
-      should "read and write bson with #{bson.keys.first}s" do
-        @buf.write(:bson, bson)
-        @buf.rewind
-        @buf.read(:bson).should == bson
-        @buf.should.be.empty
-      end
-
-    end
-
-    should 'do transactional reads with #extract' do
-      @buf.write :byte, 8
-      orig = @buf.to_s
-
-      @buf.rewind
-      @buf.extract do |b|
-        b.read :byte
-        b.read :short
-      end
-
-      @buf.pos.should == 0
-      @buf.data.should == orig
-    end
-  end
-end

data/spec/buffer_spec.rb

@@ -1,123 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include EMMongo
-
-describe Buffer do
-  before do
-    @buf = Buffer.new
-  end
-
-  it 'should have contents' do
-    @buf.contents.should == ''
-  end
-
-  it 'should initialize with data' do
-    @buf = Buffer.new('abc')
-    @buf.contents.should == 'abc'
-  end
-
-  it 'should append raw data' do
-    @buf << 'abc'
-    @buf << 'def'
-    @buf.contents.should == 'abcdef'
-  end
-
-  it 'should append other buffers' do
-    @buf << Buffer.new('abc')
-    @buf.data.should == 'abc'
-  end
-
-  it 'should have a position' do
-    @buf.pos.should == 0
-  end
-
-  it 'should have a length' do
-    @buf.length.should == 0
-    @buf << 'abc'
-    @buf.length.should == 3
-  end
-
-  it 'should know the end' do
-    @buf.empty?.should == true
-  end
-
-  it 'should read and write data' do
-    @buf._write('abc')
-    @buf.rewind
-    @buf._read(2).should == 'ab'
-    @buf._read(1).should == 'c'
-  end
-
-  it 'should raise on overflow' do
-    lambda{ @buf._read(1) }.should { raise Buffer::Overflow }
-  end
-
-  it 'should raise on invalid types' do
-    lambda{ @buf.read(:junk) }.should { raise Buffer::InvalidType }
-    lambda{ @buf.write(:junk, 1) }.should { raise Buffer::InvalidType }
-  end
-
-  { :byte => 0b10101010,
-    :short => 100,
-    :int => 65536,
-    :double => 123.456,
-    :long => 100_000_000,
-    :longlong => 666_555_444_333_222_111,
-    :cstring => 'hello',
-  }.each do |type, value|
-
-    it "should read and write a #{type}" do
-      @buf.write(type, value)
-      @buf.rewind
-      @buf.read(type).should == value
-      #@buf.should.be.empty
-    end
-
-  end
-  
-  it "should read and write multiple times" do
-    arr = [ :byte, 0b10101010, :short, 100 ]
-    @buf.write(*arr)
-    @buf.rewind
-    @buf.read(arr.shift).should == arr.shift
-    @buf.read(arr.shift).should == arr.shift
-  end
-  
-  [
-    { :num => 1                                      },
-    { :symbol => :abc                                },
-    { :object => {}                                  },
-    { :array => [1, 2, 3]                            },
-    { :string => 'abcdefg'                           },
-    { :oid => { :_id => '51d9ca7053a2012be4ecd660' } },
-    { :ref => { :_ns => 'namespace',
-                :_id => '51d9ca7053a2012be4ecd660' } },
-    { :boolean => true                               },
-    { :time => Time.at(Time.now.to_i)                },
-    { :null => nil                                   },
-    { :regex => /^.*?def/im                          }
-  ]. each do |bson|
-
-    it "should read and write bson with #{bson.keys.first}s" do
-      @buf.write(:bson, bson)
-      @buf.rewind
-      @buf.read(:bson).should == bson
-      #@buf.should.be.empty
-    end
-
-  end
-
-  it 'should do transactional reads with #extract' do
-    @buf.write :byte, 8
-    orig = @buf.to_s
-
-    @buf.rewind
-    @buf.extract do |b|
-      b.read :byte
-      b.read :short
-    end
-
-    @buf.pos.should == 0
-    @buf.data.should == orig
-  end
-end