mongodb-mongo 0.13 → 0.14

data/lib/mongo/collection.rb

@@ -314,10 +314,17 @@ module Mongo
         keys.each do |k|
           hash[k] = 1
         end
+
+        case reduce
+        when Code
+        else
+          reduce = Code.new(reduce)
+        end
+
         result = @db.db_command({"group" =>
                                   {
                                     "ns" => @name,
-                                    "$reduce" => Code.new(reduce),
+                                    "$reduce" => reduce,
                                     "key" => hash,
                                     "cond" => condition,
                                     "initial" => initial}})
@@ -327,6 +334,19 @@ module Mongo
           raise OperationFailure, "group command failed: #{result['errmsg']}"
         end
       end
+
+      case reduce
+      when Code
+        scope = reduce.scope
+      else
+        scope = {}
+      end
+      scope.merge!({
+                     "ns" => @name,
+                     "keys" => keys,
+                     "condition" => condition,
+                     "initial" => initial })
+
       group_function = <<EOS
 function () {
     var c = db[ns].find(condition);
@@ -352,13 +372,7 @@ function () {
     return {"result": map.values()};
 }
 EOS
-      return @db.eval(Code.new(group_function,
-                               {
-                                 "ns" => @name,
-                                 "keys" => keys,
-                                 "condition" => condition,
-                                 "initial" => initial
-                               }))["result"]
+      return @db.eval(Code.new(group_function, scope))["result"]
     end
 
     # Rename this collection.

data/lib/mongo/connection.rb

@@ -108,16 +108,6 @@ module Mongo
       database_info.keys
     end
 
-    # Not implemented.
-    def clone_database(from)
-      raise "not implemented"
-    end
-
-    # Not implemented.
-    def copy_database(from_host, from_db, to_db)
-      raise "not implemented"
-    end
-
     # Drops the database +name+.
     def drop_database(name)
       single_db_command(name, :dropDatabase => 1)

data/lib/mongo/cursor.rb

@@ -66,7 +66,8 @@ module Mongo
     # database error.
     def count
       command = OrderedHash["count", @collection.name,
-                            "query", @query.selector]
+                            "query", @query.selector,
+                            "fields", @query.fields()]
       response = @db.db_command(command)
       return response['n'].to_i if response['ok'] == 1
       return 0 if response['errmsg'] == "ns missing"

data/lib/mongo/db.rb

@@ -154,11 +154,11 @@ module Mongo
           is_master = master?
           @semaphore.lock if semaphore_is_locked
 
-          break if @slave_ok || is_master
+          @slave_ok || is_master
         rescue SocketError, SystemCallError, IOError => ex
           close if @socket
+          false
         end
-        @socket
       }
       raise "error: failed to connect to any given host:port" unless @socket
     end

data/lib/mongo/types/objectid.rb

@@ -15,61 +15,26 @@
 # ++
 
 require 'mutex_m'
-require 'mongo/util/byte_buffer'
+require 'socket'
+require 'digest/md5'
 
 module Mongo
 
-  # Implementation of the Babble OID. Object ids are not required by
-  # Mongo, but they make certain operations more efficient.
-  #
-  # The driver does not automatically assign ids to records that are
-  # inserted. (An upcoming feature will allow you to give an id "factory"
-  # to a database and/or a collection.)
-  #
-  #   12 bytes
-  #   ---
-  #    0 time
-  #    1
-  #    2
-  #    3
-  #    4 machine
-  #    5
-  #    6
-  #    7 pid
-  #    8
-  #    9 inc
-  #   10
-  #   11
+  # Representation of an ObjectId for Mongo.
   class ObjectID
-
-    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.
+    # This is the legacy byte ordering for Babble. Versions of the Ruby
+    # driver prior to 0.14 used this byte ordering when converting ObjectID
+    # instances to and from strings. If you have string representations of
+    # ObjectIDs using the legacy byte ordering make sure to use the
+    # to_s_legacy and from_string_legacy methods, or convert your strings
+    # with ObjectID#legacy_string_convert
     BYTE_ORDER = [7, 6, 5, 4, 3, 2, 1, 0, 11, 10, 9, 8]
 
     LOCK = Object.new
     LOCK.extend Mutex_m
 
-    @@index_time = Time.new.to_i
     @@index = 0
 
-    # Given a string representation of an ObjectID, return a new ObjectID
-    # with that value.
-    def self.from_string(str)
-      raise "illegal ObjectID format" unless legal?(str)
-      data = []
-      BYTE_ORDER.each_with_index { |string_position, data_index|
-        data[data_index] = str[string_position * 2, 2].to_i(16)
-      }
-      self.new(data)
-    end
-
     def self.legal?(str)
       len = BYTE_ORDER.length * 2
       str =~ /([0-9a-f]+)/i
@@ -78,9 +43,8 @@ module Mongo
     end
 
     # +data+ is an array of bytes. If nil, a new id will be generated.
-    # The time +t+ is only used for testing; leave it nil.
-    def initialize(data=nil, t=nil)
-      @data = data || generate_id(t)
+    def initialize(data=nil)
+      @data = data || generate
     end
 
     def eql?(other)
@@ -92,7 +56,42 @@ module Mongo
       @data.dup
     end
 
+    # Given a string representation of an ObjectID, return a new ObjectID
+    # with that value.
+    def self.from_string(str)
+      raise "illegal ObjectID format" unless legal?(str)
+      data = []
+      12.times do |i|
+        data[i] = str[i * 2, 2].to_i(16)
+      end
+      self.new(data)
+    end
+
+    # Create a new ObjectID given a string representation of an ObjectID
+    # using the legacy byte ordering. This method may eventually be
+    # removed. If you are not sure that you need this method you should be
+    # using the regular from_string.
+    def self.from_string_legacy(str)
+      raise "illegal ObjectID format" unless legal?(str)
+      data = []
+      BYTE_ORDER.each_with_index { |string_position, data_index|
+        data[data_index] = str[string_position * 2, 2].to_i(16)
+      }
+      self.new(data)
+    end
+
     def to_s
+      str = ' ' * 24
+      12.times do |i|
+        str[i * 2, 2] = '%02x' % @data[i]
+      end
+      str
+    end
+
+    # Get a string representation of this ObjectID using the legacy byte
+    # ordering. This method may eventually be removed. If you are not sure
+    # that you need this method you should be using the regular to_s.
+    def to_s_legacy
       str = ' ' * 24
       BYTE_ORDER.each_with_index { |string_position, data_index|
         str[string_position * 2, 2] = '%02x' % @data[data_index]
@@ -100,34 +99,43 @@ module Mongo
       str
     end
 
-    # (Would normally be private, but isn't so we can test it.)
-    def generate_id(t=nil)
-      t ||= Time.new.to_i
-      buf = ByteBuffer.new
-      buf.put_int(t & 0xffffffff)
-      buf.put_array(MACHINE)
-      buf.put_array(PID)
-      i = index_for_time(t)
-      buf.put(i & 0xff)
-      buf.put((i >> 8) & 0xff)
-      buf.put((i >> 16) & 0xff)
-
-      buf.rewind
-      buf.to_a.dup
+    # Convert a string representation of an ObjectID using the legacy byte
+    # ordering to the proper byte ordering. This method may eventually be
+    # removed. If you are not sure that you need this method it is probably
+    # unnecessary.
+    def self.legacy_string_convert(str)
+      legacy = ' ' * 24
+      BYTE_ORDER.each_with_index do |legacy_pos, pos|
+        legacy[legacy_pos * 2, 2] = str[pos * 2, 2]
+      end
+      legacy
+    end
+
+    private
+
+    def generate
+      oid = ''
+
+      # 4 bytes current time
+      time = Time.new.to_i
+      oid += [time].pack("N")
+
+      # 3 bytes machine
+      oid += Digest::MD5.digest(Socket.gethostname)[0, 3]
+
+      # 2 bytes pid
+      oid += [Process.pid % 0xFFFF].pack("n")
+
+      # 3 bytes inc
+      oid += [get_inc].pack("N")[1, 3]
+
+      oid.unpack("C12")
     end
 
-    # (Would normally be private, but isn't so we can test it.)
-    def index_for_time(t)
+    def get_inc
       LOCK.mu_synchronize {
-        if t != @@index_time
-          @@index = 0
-          @@index_time = t
-        end
-        retval = @@index
-        @@index += 1
-        retval
+        @@index = (@@index + 1) % 0xFFFFFF
       }
     end
-
   end
 end

data/mongo-ruby-driver.gemspec

@@ -83,7 +83,7 @@ TEST_FILES = ['test/mongo-qa/_common.rb',
 
 Gem::Specification.new do |s|
   s.name = 'mongo'
-  s.version = '0.13'
+  s.version = '0.14'
   s.platform = Gem::Platform::RUBY
   s.summary = 'Ruby driver for the 10gen Mongo DB'
   s.description = 'A Ruby driver for the 10gen Mongo DB. For more information about Mongo, see http://www.mongodb.org.'

data/test/test_collection.rb

@@ -177,5 +177,44 @@ class TestCollection < Test::Unit::TestCase
     end
     assert c.closed?
   end
-end
 
+  def test_save_symbol_find_string
+    @@test.save(:foo => :mike)
+
+    assert_equal :mike, @@test.find_one(:foo => :mike)["foo"]
+    assert_equal :mike, @@test.find_one("foo" => :mike)["foo"]
+    assert_equal nil, @@test.find_one(:foo => "mike")
+    assert_equal nil, @@test.find_one("foo" => "mike")
+  end
+
+  def test_group_with_scope
+    @@test.save("a" => 1)
+    @@test.save("b" => 1)
+
+    reduce_function = "function (obj, prev) { prev.count += inc_value; }"
+
+    assert_equal 2, @@test.group([], {}, {"count" => 0},
+                                 Code.new(reduce_function,
+                                          {"inc_value" => 1}))[0]["count"]
+
+# TODO enable these tests when SERVER-262 is fixed
+
+#     assert_equal 2, @@test.group([], {}, {"count" => 0},
+#                                  Code.new(reduce_function,
+#                                           {"inc_value" => 1}), true)[0]["count"]
+
+    assert_equal 4, @@test.group([], {}, {"count" => 0},
+                                 Code.new(reduce_function,
+                                          {"inc_value" => 2}))[0]["count"]
+#     assert_equal 4, @@test.group([], {}, {"count" => 0},
+#                                  Code.new(reduce_function,
+#                                           {"inc_value" => 2}), true)[0]["count"]
+
+    assert_equal 1, @@test.group([], {}, {"count" => 0},
+                                 Code.new(reduce_function,
+                                          {"inc_value" => 0.5}))[0]["count"]
+#     assert_equal 1, @@test.group([], {}, {"count" => 0},
+#                                  Code.new(reduce_function,
+#                                           {"inc_value" => 0.5}), true)[0]["count"]
+  end
+end

data/test/test_cursor.rb

@@ -220,4 +220,14 @@ class CursorTest < Test::Unit::TestCase
     assert_equal(by_location,
                  @@db.db_command("cursorInfo" => 1)["byLocation_size"])
   end
+
+  def test_count_with_fields
+    @@coll.clear
+    @@coll.save("x" => 1)
+
+    @@coll.find({}, :fields => ["a"]).each do |doc|
+      fail "shouldn't have any results here"
+    end
+    assert_equal(0, @@coll.find({}, :fields => ["a"]).count())
+  end
 end

data/test/test_objectid.rb

@@ -7,41 +7,19 @@ class ObjectIDTest < Test::Unit::TestCase
   include Mongo
 
   def setup
-    @t = 42
-    @o = ObjectID.new(nil, @t)
-  end
-
-  def test_index_for_time
-    t = 99
-    assert_equal 0, @o.index_for_time(t)
-    assert_equal 1, @o.index_for_time(t)
-    assert_equal 2, @o.index_for_time(t)
-    t = 100
-    assert_equal 0, @o.index_for_time(t)
-  end
-
-  def test_time_bytes
-    a = @o.to_a
-    assert_equal @t, a[0]
-    3.times { |i| assert_equal 0, a[i+1] }
-
-    t = 43
-    o = ObjectID.new(nil, t)
-    a = o.to_a
-    assert_equal t, a[0]
-    3.times { |i| assert_equal 0, a[i+1] }
-    assert_equal 1, o.index_for_time(t) # 0 was used for o
+    @o = ObjectID.new()
   end
 
   def test_different
-    o2 = ObjectID.new(nil, @t)
-    assert @o.to_a != o2.to_a
+    a = ObjectID.new
+    b = ObjectID.new
+    assert_not_equal a.to_a, b.to_a
+    assert_not_equal a, b
   end
 
   def test_eql?
     o2 = ObjectID.new(@o.to_a)
-    assert @o.eql?(o2)
-    assert @o == o2
+    assert_equal @o, o2
   end
 
   def test_to_s
@@ -51,6 +29,15 @@ class ObjectIDTest < Test::Unit::TestCase
     assert_equal 24, $1.length
   end
 
+  def test_to_s_legacy
+    s = @o.to_s_legacy
+    assert_equal 24, s.length
+    s =~ /^([0-9a-f]+)$/
+    assert_equal 24, $1.length
+
+    assert_not_equal s, @o.to_s
+  end
+
   def test_save_and_restore
     host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
     port = ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT
@@ -73,6 +60,14 @@ class ObjectIDTest < Test::Unit::TestCase
     assert_equal @o.to_s, o2.to_s
   end
 
+  def test_from_string_legacy
+    hex_str = @o.to_s_legacy
+    o2 = ObjectID.from_string_legacy(hex_str)
+    assert_equal hex_str, o2.to_s_legacy
+    assert_equal @o, o2
+    assert_equal @o.to_s, o2.to_s
+  end
+
   def test_legal
     assert !ObjectID.legal?(nil)
     assert !ObjectID.legal?("fred")
@@ -84,7 +79,7 @@ class ObjectIDTest < Test::Unit::TestCase
   end
 
   def test_from_string_leading_zeroes
-    hex_str = '000000000000000000abcdef'
+    hex_str = '000000000000000000000000'
     o = ObjectID.from_string(hex_str)
     assert_equal hex_str, o.to_s
   end
@@ -92,7 +87,19 @@ class ObjectIDTest < Test::Unit::TestCase
   def test_byte_order
     hex_str = '000102030405060708090A0B'
     o = ObjectID.from_string(hex_str)
+    assert_equal [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b], o.to_a
+  end
+
+  def test_legacy_byte_order
+    hex_str = '000102030405060708090A0B'
+    o = ObjectID.from_string_legacy(hex_str)
     assert_equal [0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x0b, 0x0a, 0x09, 0x08], o.to_a
   end
 
+  def test_legacy_string_convert
+    l = @o.to_s_legacy
+    s = @o.to_s
+    assert_equal s, ObjectID.legacy_string_convert(l)
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mongodb-mongo
 version: !ruby/object:Gem::Version 
-  version: "0.13"
+  version: "0.14"
 platform: ruby
 authors: 
 - Jim Menard