em-mongo 0.1.1

data/lib/em-mongo.rb

@@ -0,0 +1,30 @@
+require 'eventmachine'
+require 'pp'
+
+begin
+  require 'securerandom'
+rescue LoadError
+  require 'uuid'
+end
+
+module EM::Mongo
+  VERSION = '0.0.1'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::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 
+    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/lib/em-mongo/buffer.rb

@@ -0,0 +1,414 @@
+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/lib/em-mongo/collection.rb

@@ -0,0 +1,46 @@
+module EM::Mongo
+  class Collection
+    attr_accessor :connection
+
+    def initialize(db, ns, connection = nil)
+      @db = db || "db"
+      @ns = ns || "ns"
+      @name = [@db,@ns].join('.')
+      @connection = connection || EM::Mongo::Connection.new
+    end
+
+    def find(selector={}, opts={}, &blk)
+      raise "find requires a block" if not block_given?
+
+      skip  = opts.delete(:skip) || 0
+      limit = opts.delete(:limit) || 0
+
+      @connection.find(@name, skip, limit, selector, &blk)
+    end
+
+    def first(selector={}, opts={}, &blk)
+      opts[:limit] = 1
+      find(selector, opts) do |res|
+        yield res.first
+      end
+    end
+
+    def insert(obj)
+      obj[:_id] ||= EM::Mongo::Util.unique_id 
+      @connection.insert(@name, obj)
+      obj
+    end
+
+    def remove(obj = {})
+      @connection.delete(@name, obj)
+      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

@@ -0,0 +1,209 @@
+module EM::Mongo
+  DEFAULT_IP   = "127.0.0.1"
+  DEFAULT_PORT = 27017
+  DEFAULT_DB   = "db"
+  DEFAULT_NS   = "ns"
+
+  module EMConnection
+    class Error < Exception; 
+      class ConnectionNotBound
+      end
+    end
+    
+    include EM::Deferrable
+
+    RESERVED    = 0
+    OP_REPLY    = 1
+    OP_MSG      = 1000
+    OP_UPDATE   = 2001
+    OP_INSERT   = 2002
+    OP_QUERY    = 2004
+    OP_DELETE   = 2006
+
+    attr_reader :connection
+
+    def responses_pending?
+      @responses.size >= 1
+    end
+
+    def connected?
+      @is_connected
+    end
+
+    # RMongo interface
+    def collection(db = DEFAULT_DB, ns = DEFAULT_NS)
+      raise "Not connected" if not connected?
+      EM::Mongo::Collection.new(db, ns, self)
+    end
+
+    # MongoDB Commands
+
+    def send_command(id, *args, &blk)
+      request_id = @request_id += 1
+
+      callback {
+        buf  = Buffer.new
+        buf.write :int, request_id,
+                  :int, response = 0,
+                  :int, operation = id
+
+        buf.write *args
+        send_data [ buf.size + 4 ].pack('i') # header length first
+        send_data buf.data
+      }
+
+      @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)
+    end
+
+    def delete(collection_name, selector)
+      send_command(OP_DELETE, :int,      RESERVED,
+                              :cstring,  collection_name,
+                              :int,      RESERVED,
+                              :bson,     selector)
+    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)
+    end
+
+
+    # EM hooks
+    def initialize(options={})
+      @request_id = 0
+      @responses = {}
+      @is_connected = false
+      @host = options[:host] || DEFAULT_IP
+      @port = options[:port] || DEFAULT_PORT
+
+      @on_close = proc{
+        raise Error, "could not connect to server #{@host}:#{@port}"
+      }
+      timeout options[:timeout] if options[:timeout]
+      errback{ @on_close.call }
+    end
+
+    def self.connect(host = DEFAULT_IP, port = DEFAUL_PORT, timeout = nil)
+      opt = {:host => host, :port => port, :timeout => timeout}
+      EM.connect(host, port, self, opt)
+    end
+
+    def connection_completed
+      log 'connected'
+      @buf = Buffer.new
+      @is_connected = true
+      @on_close = proc{
+      }
+      succeed
+    end
+
+    def receive_data data
+      log "receive_data: #{data.size}"#, data
+
+      @buf << data
+
+      until @buf.empty?
+        size = @buf._peek(0, 4, 'I')
+
+        break unless @buf.size >= size-4
+
+        size, id, response, operation = @buf.read(:int, :int, :int, :int)
+        reserved, cursor, start, num = @buf.read(:int, :longlong, :int, :int)
+
+        results = (1..num).map do
+          @buf.read(:bson)
+        end
+
+        if cb = @responses.delete(response)
+          cb.call(results)
+        end
+        close_connection if @close_pending and @responses.size == 0
+      end
+    end
+
+    def send_data data
+      log "send_data:#{data.size}"#, data
+      super data
+    end
+
+    def unbind
+      log "unbind"
+      @is_connected = false
+      @on_close.call unless $!
+    end
+
+    def close
+      log "close"
+      @on_close = proc{ yield if block_given? }
+      if @responses.empty?
+        close_connection
+      else
+        @close_pending = true
+      end
+    end
+
+    private
+
+    def log *args
+      return
+      pp args
+      puts
+    end
+
+  end
+end
+
+# Make EM::Mongo look like mongo-ruby-driver
+module EM::Mongo
+  class Database
+    def initialize(name = DEFAULT_DB, connection = nil)
+      @db_name = name
+      @em_connection = connection || EM::Mongo::Connection.new
+      @collection = nil
+    end
+
+    def collection(name = DEFAULT_NS)
+      @collection = EM::Mongo::Collection.new(@db_name, name, @em_connection)
+    end
+
+    def close
+      @em_connection.close
+    end
+  end
+  class Connection
+    def initialize(host = DEFAULT_IP, port = DEFAULT_PORT, timeout = nil)
+      @em_connection = EMConnection.connect(host, port, timeout) 
+      @db = {}
+      self
+    end
+    
+    def db(name = DEFAULT_DB)
+      @db[name] = EM::Mongo::Database.new(name, @em_connection)
+    end
+
+    def collection(db = DEFAULT_DB, ns = DEFAULT_NS)
+      @em_connection.collection(db, ns)
+    end
+
+    def close
+      @em_connection.close
+    end
+
+    def connected?
+      @em_connection.connected?
+    end
+
+  end
+end

data/spec/buffer_spec.rb

@@ -0,0 +1,123 @@
+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

data/spec/collection_spec.rb

@@ -0,0 +1,142 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe EMMongo::Collection do
+  include EM::SpecHelper
+
+  before(:all) do
+    @numbers = { 
+      1 => 'one',
+      2 => 'two',
+      3 => 'three',
+      4 => 'four',
+      5 => 'five',
+      6 => 'six',
+      7 => 'seven',
+      8 => 'eight',
+      9 => 'nine'
+    }
+  end
+
+  after(:all) do
+  end
+
+  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
+      EM::Spec::Mongo.close
+    end
+  end
+
+  it 'should find an object' do
+    EM::Spec::Mongo.collection do |collection|
+      collection.insert(:hello => 'world') 
+      r = collection.find({:hello => "world"},{}) do |res|
+        res.size.should >= 1
+        res[0][:hello].should == "world"
+        EM::Spec::Mongo.close
+      end
+    end
+  end
+
+  it 'should find all objects' do
+    EM::Spec::Mongo.collection do |collection|
+      collection.insert(:one => 'one')
+      collection.insert(:two => 'two')
+      collection.find do |res|
+        res.size.should >= 2
+        EM::Spec::Mongo.close
+      end
+    end
+  end
+
+  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|
+        res.size.should == 0
+        EM::Spec::Mongo.close
+      end
+    end
+  end
+
+  it 'should remove all objects' do
+    EM::Spec::Mongo.collection do |collection|
+      collection.insert(:one => 'one')
+      collection.insert(:two => 'two')
+      collection.remove
+      collection.find do |res|
+        res.size.should == 0
+        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
+      }
+      obj = collection.insert(obj)
+      collection.find(:_id => obj[:_id]) do |ret|
+        ret.should == [ obj ]
+        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'}
+      })
+
+      collection.first('address.city' => 'Mountain View') do |res|
+        res[:name].should == 'Google'
+        EM::Spec::Mongo.close
+      end
+    end
+  end
+
+  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)
+      end
+
+      collection.find({:num => {'$in' => [1,3,5]}}) do |res|
+        res.size.should == 3
+        res.map{|r| r[:num] }.sort.should == [1,3,5]
+        EM::Spec::Mongo.close
+      end
+    end
+  end
+
+  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)
+      end
+
+      collection.find({:num => {'$gt' => 3}}) do |res|
+        res.size.should == 6
+        res.map{|r| r[:num] }.sort.should == [4,5,6,7,8,9]
+        EM::Spec::Mongo.close
+      end
+    end
+  end
+
+end

data/spec/connection_spec.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe EMMongo::Connection do
+  include EM::SpecHelper
+
+  it 'should connect' do
+    em do
+      connection = EMMongo::Connection.new
+      EM.next_tick do
+        connection.connected?.should == true
+        done
+      end
+    end    
+  end
+  
+  it 'should close' do
+    em do
+      connection = EMMongo::Connection.new
+      EM.next_tick do
+        connection.connected?.should == true
+        connection.close
+      end
+      EM.add_timer(1) do
+        EM.next_tick do
+          connection.connected?.should == false
+          done
+        end
+      end
+    end 
+  end
+
+  # 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
+      EM::Spec::Mongo.close
+    end 
+  end
+
+  it 'should instantiate a Databse' do
+    EM::Spec::Mongo.connection do |connection|
+      db1 = connection.db
+      db1.is_a?(Database).should == true
+      db2 = connection.db('db2')
+      db2.is_a?(Database).should == true
+      db2.should_not == db1
+      EM::Spec::Mongo.close
+    end 
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/../lib/em-mongo'
+
+#$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
+
+require "em-spec/rspec"
+
+module EM
+  module Spec
+    module Mongo
+      extend EM::SpecHelper 
+
+      @@clean_collection_up = nil
+
+      def self.close
+        @@clean_collection_up.call if @@clean_collection_up
+        done
+      end
+    
+      def self.collection
+        self.database do |database|
+          database.collection.remove
+          yield database.collection
+        end
+      end
+
+      def self.database
+        self.connection do |connection|
+          yield connection.db
+        end
+      end
+
+      def self.connection
+        em do
+          connection = EMMongo::Connection.new
+          EM.next_tick do
+            yield connection
+          end
+        end
+      end
+
+    end
+  end
+end
+

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: em-mongo
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- tmm1, bcg
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-03 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 12
+        - 10
+        version: 0.12.10
+  type: :runtime
+  version_requirements: *id001
+description: em-mongo
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/em-mongo/buffer.rb
+- lib/em-mongo/collection.rb
+- lib/em-mongo/connection.rb
+- lib/em-mongo.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: em-mongo based on rmongo
+test_files: 
+- spec/buffer_spec.rb
+- spec/collection_spec.rb
+- spec/connection_spec.rb
+- spec/spec_helper.rb