mongodb-mongo 0.8 → 0.9

data/README.rdoc

@@ -324,6 +324,13 @@ Adrian Madrid, aemadrid@gmail.com
 Aman Gupta, aman@tmm1.net
 * Collection#save
 
+Jon Crosby, jon@joncrosby.me
+* Some code clean-up
+
+John Nunemaker, http://railstips.org
+* Collection#create_index takes symbols as well as strings
+* Fix for Collection#save
+
 = License
 
  Copyright 2008-2009 10gen Inc.

data/lib/mongo/collection.rb

@@ -76,7 +76,7 @@ module XGen
         # Save an updated +object+ to the collection, or insert it if it doesn't exist already.
         def save(object)
           if id = object[:_id] || object['_id']
-            modify({:_id => id}, object)
+            repsert({:_id => id}, object)
           else
             insert(object)
           end
@@ -171,10 +171,11 @@ function () {
             key[keys[i]] = obj[keys[i]];
         }
 
-        var aggObj = map[key];
+        var aggObj = map.get(key);
         if (aggObj == null) {
             var newObj = Object.extend({}, key);
-            aggObj = map[key] = Object.extend(newObj, initial);
+            aggObj = Object.extend(newObj, initial);
+            map.put(key, aggObj);
         }
         reduce_function(obj, aggObj);
     }
@@ -190,14 +191,10 @@ EOS
                                    }))["result"]
         end
 
-        # Return an array of hashes, one for each index. Each hash contains:
-        #
-        # :name :: Index name
-        #
-        # :keys :: Hash whose keys are the names of the fields that make up
-        #          the key and values are integers.
-        #
-        # :ns :: Namespace; same as this collection's name.
+        # Get information on the indexes for the collection +collection_name+.
+        # Returns a hash where the keys are index names (as returned by
+        # Collection#create_index and the values are lists of [key, direction]
+        # pairs specifying the index (as passed to Collection#create_index).
         def index_information
           @db.index_information(@name)
         end

data/lib/mongo/db.rb

@@ -390,6 +390,7 @@ module XGen
           oh[:query] = selector || {}
           doc = db_command(oh)
           return doc['n'].to_i if ok?(doc)
+          return 0 if doc['errmsg'] == "ns missing"
           raise "Error with count command: #{doc.inspect}"
         end
 
@@ -425,31 +426,18 @@ module XGen
           raise "Error with drop_index command: #{doc.inspect}" unless ok?(doc)
         end
 
-        # Return an array of hashes, one for each index on +collection_name+.
-        # Normally called by Collection#index_information. Each hash contains:
-        #
-        # :name :: Index name
-        #
-        # :keys :: Hash whose keys are the names of the fields that make up
-        #          the key and values are integers.
-        #
-        # :ns :: Namespace; same as +collection_name+.
+        # Get information on the indexes for the collection +collection_name+.
+        # Normally called by Collection#index_information. Returns a hash where
+        # the keys are index names (as returned by Collection#create_index and
+        # the values are lists of [key, direction] pairs specifying the index
+        # (as passed to Collection#create_index).
         def index_information(collection_name)
           sel = {:ns => full_coll_name(collection_name)}
-          query(Collection.new(self, SYSTEM_INDEX_COLLECTION), Query.new(sel)).collect { |row|
-            h = {:name => row['name']}
-            raise "Name of index on return from db was nil. Coll = #{full_coll_name(collection_name)}" unless h[:name]
-
-            h[:keys] = row['key']
-            raise "Keys for index on return from db was nil. Coll = #{full_coll_name(collection_name)}" unless h[:keys]
-
-            h[:ns] = row['ns']
-            raise "Namespace for index on return from db was nil. Coll = #{full_coll_name(collection_name)}" unless h[:ns]
-            h[:ns].sub!(/.*\./, '')
-            raise "Error: ns != collection" unless h[:ns] == collection_name
-
-            h
+          info = {}
+          query(Collection.new(self, SYSTEM_INDEX_COLLECTION), Query.new(sel)).each { |index|
+            info[index['name']] = index['key'].to_a
           }
+          info
         end
 
         # Create a new index on +collection_name+. +field_or_spec+
@@ -460,10 +448,10 @@ module XGen
         # enforce a uniqueness constraint.
         def create_index(collection_name, field_or_spec, unique=false)
           field_h = OrderedHash.new
-          if field_or_spec.is_a? String
-            field_h[field_or_spec] = 1
+          if field_or_spec.is_a?(String) || field_or_spec.is_a?(Symbol)
+            field_h[field_or_spec.to_s] = 1
           else
-            field_or_spec.each { |f| field_h[f[0]] = f[1] }
+            field_or_spec.each { |f| field_h[f[0].to_s] = f[1] }
           end
           name = gen_index_name(field_h)
           sel = {
@@ -473,7 +461,7 @@ module XGen
             :unique => unique
           }
           @semaphore.synchronize {
-            send_to_db(InsertMessage.new(@name, SYSTEM_INDEX_COLLECTION, sel))
+            send_to_db(InsertMessage.new(@name, SYSTEM_INDEX_COLLECTION, false, sel))
           }
           name
         end
@@ -483,11 +471,13 @@ module XGen
         # possibly modified by @pk_factory.
         def insert_into_db(collection_name, objects)
           @semaphore.synchronize {
-            objects.collect { |o|
-              o = @pk_factory.create_pk(o) if @pk_factory
-              send_to_db(InsertMessage.new(@name, collection_name, o))
-              o
-            }
+            if @pk_factory
+              objects.collect! { |o|
+                @pk_factory.create_pk(o)
+              }
+            end
+            send_to_db(InsertMessage.new(@name, collection_name, true, *objects))
+            objects
           }
         end
 

data/lib/mongo/message/insert_message.rb

@@ -23,11 +23,11 @@ module XGen
 
       class InsertMessage < Message
 
-        def initialize(db_name, collection_name, *objs)
+        def initialize(db_name, collection_name, check_keys=true, *objs)
           super(OP_INSERT)
           write_int(0)
           write_string("#{db_name}.#{collection_name}")
-          objs.each { |o| write_doc(o) }
+          objs.each { |o| write_doc(o, check_keys) }
         end
       end
     end

data/lib/mongo/message/message.rb

@@ -36,7 +36,7 @@ module XGen
           @request_id = (@@class_req_id += 1)
           @response_id = 0
           @buf = ByteBuffer.new
-          
+
           @buf.put_int(16)      # holder for length
           @buf.put_int(@request_id)
           @buf.put_int(0)       # response_to
@@ -58,8 +58,8 @@ module XGen
           update_message_length
         end
 
-        def write_doc(hash)
-          @buf.put_array(BSON.new.serialize(hash).to_a)
+        def write_doc(hash, check_keys=false)
+          @buf.put_array(BSON.new.serialize(hash, check_keys).to_a)
           update_message_length
         end
 

data/lib/mongo/util/bson.rb

@@ -73,11 +73,11 @@ class BSON
 
   begin
     require 'mongo_ext/cbson'
-    def serialize(obj)
-      @buf = ByteBuffer.new(CBson.serialize(obj))
+    def serialize(obj, check_keys=false)
+      @buf = ByteBuffer.new(CBson.serialize(obj, check_keys))
     end
   rescue LoadError
-    def serialize(obj)
+    def serialize(obj, check_keys=false)
       raise "Document is null" unless obj
 
       @buf.rewind
@@ -86,12 +86,12 @@ class BSON
 
       # Write key/value pairs. Always write _id first if it exists.
       if obj.has_key? '_id'
-        serialize_key_value('_id', obj['_id'])
+        serialize_key_value('_id', obj['_id'], check_keys)
       elsif obj.has_key? :_id
-        serialize_key_value('_id', obj[:_id])
+        serialize_key_value('_id', obj[:_id], check_keys)
       end
 
-      obj.each {|k, v| serialize_key_value(k, v) unless k == '_id' || k == :_id }
+      obj.each {|k, v| serialize_key_value(k, v, check_keys) unless k == '_id' || k == :_id }
 
       serialize_eoo_element(@buf)
       @buf.put_int(@buf.size, 0)
@@ -99,38 +99,47 @@ class BSON
     end
   end
 
-  def serialize_key_value(k, v)
-      type = bson_type(v)
-      case type
-      when STRING, SYMBOL
-        serialize_string_element(@buf, k, v, type)
-      when NUMBER, NUMBER_INT
-        serialize_number_element(@buf, k, v, type)
-      when OBJECT
-        serialize_object_element(@buf, k, v)
-      when OID
-        serialize_oid_element(@buf, k, v)
-      when ARRAY
-        serialize_array_element(@buf, k, v)
-      when REGEX
-        serialize_regex_element(@buf, k, v)
-      when BOOLEAN
-        serialize_boolean_element(@buf, k, v)
-      when DATE
-        serialize_date_element(@buf, k, v)
-      when NULL
-        serialize_null_element(@buf, k)
-      when REF
-        serialize_dbref_element(@buf, k, v)
-      when BINARY
-        serialize_binary_element(@buf, k, v)
-      when UNDEFINED
-        serialize_undefined_element(@buf, k)
-      when CODE_W_SCOPE
-        serialize_code_w_scope(@buf, k, v)
-      else
-        raise "unhandled type #{type}"
+  def serialize_key_value(k, v, check_keys)
+    k = k.to_s
+    if check_keys
+      if k[0] == ?$
+        raise RuntimeError.new("key #{k} must not start with '$'")
+      end
+      if k.include? ?.
+        raise RuntimeError.new("key #{k} must not contain '.'")
       end
+    end
+    type = bson_type(v)
+    case type
+    when STRING, SYMBOL
+      serialize_string_element(@buf, k, v, type)
+    when NUMBER, NUMBER_INT
+      serialize_number_element(@buf, k, v, type)
+    when OBJECT
+      serialize_object_element(@buf, k, v, check_keys)
+    when OID
+      serialize_oid_element(@buf, k, v)
+    when ARRAY
+      serialize_array_element(@buf, k, v, check_keys)
+    when REGEX
+      serialize_regex_element(@buf, k, v)
+    when BOOLEAN
+      serialize_boolean_element(@buf, k, v)
+    when DATE
+      serialize_date_element(@buf, k, v)
+    when NULL
+      serialize_null_element(@buf, k)
+    when REF
+      serialize_dbref_element(@buf, k, v)
+    when BINARY
+      serialize_binary_element(@buf, k, v)
+    when UNDEFINED
+      serialize_undefined_element(@buf, k)
+    when CODE_W_SCOPE
+      serialize_code_w_scope(@buf, k, v)
+    else
+      raise "unhandled type #{type}"
+    end
   end
 
   begin
@@ -344,7 +353,7 @@ class BSON
     oh = OrderedHash.new
     oh['$ref'] = val.namespace
     oh['$id'] = val.object_id
-    serialize_object_element(buf, key, oh)
+    serialize_object_element(buf, key, oh, false)
   end
 
   def serialize_binary_element(buf, key, val)
@@ -391,24 +400,24 @@ class BSON
       buf.put_double(val)
     else
       if val > 2**32 / 2 - 1 or val < -2**32 / 2
-        raise RangeError.new "MongoDB can only handle 4-byte ints - try converting to a double before saving"
+        raise RangeError.new("MongoDB can only handle 4-byte ints - try converting to a double before saving")
       end
       buf.put_int(val)
     end
   end
 
-  def serialize_object_element(buf, key, val, opcode=OBJECT)
+  def serialize_object_element(buf, key, val, check_keys, opcode=OBJECT)
     buf.put(opcode)
     self.class.serialize_cstr(buf, key)
-    buf.put_array(BSON.new.serialize(val).to_a)
+    buf.put_array(BSON.new.serialize(val, check_keys).to_a)
   end
 
-  def serialize_array_element(buf, key, val)
+  def serialize_array_element(buf, key, val, check_keys)
     # Turn array into hash with integer indices as keys
     h = OrderedHash.new
     i = 0
     val.each { |v| h[i] = v; i += 1 }
-    serialize_object_element(buf, key, h, ARRAY)
+    serialize_object_element(buf, key, h, check_keys, ARRAY)
   end
 
   def serialize_regex_element(buf, key, val)

data/mongo-ruby-driver.gemspec

@@ -79,7 +79,7 @@ TEST_FILES = ['tests/mongo-qa/_common.rb',
 
 Gem::Specification.new do |s|
   s.name = 'mongo'
-  s.version = '0.8'
+  s.version = '0.9'
   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/tests/test_db_api.rb

@@ -56,6 +56,11 @@ class DBAPITest < Test::Unit::TestCase
     assert docs.detect { |row| row['b'] == 3 }
   end
 
+  def test_count_on_nonexisting
+    @@db.drop_collection('foo')
+    assert_equal 0, @@db.collection('foo').count()
+  end
+
   def test_find_simple
     @r2 = @@coll.insert('a' => 2)
     @r3 = @@coll.insert('b' => 3)
@@ -282,29 +287,55 @@ class DBAPITest < Test::Unit::TestCase
   end
 
   def test_index_information
+    assert_equal @@coll.index_information.length, 1
+
     name = @@db.create_index(@@coll.name, 'a')
-    list = @@db.index_information(@@coll.name)
-    assert_equal @@coll.index_information, list
-    assert_equal 2, list.length
-
-    info = list[1]
-    assert_equal name, 'a_1'
-    assert_equal name, info[:name]
-    assert_equal 1, info[:keys]['a']
+    info = @@db.index_information(@@coll.name)
+    assert_equal name, "a_1"
+    assert_equal @@coll.index_information, info
+    assert_equal 2, info.length
+
+    assert info.has_key?(name)
+    assert_equal info[name], [["a", ASCENDING]]
+  ensure
+    @@db.drop_index(@@coll.name, name)
+  end
+
+  def test_index_create_with_symbol
+    assert_equal @@coll.index_information.length, 1
+
+    name = @@db.create_index(@@coll.name, :a)
+    info = @@db.index_information(@@coll.name)
+    assert_equal name, "a_1"
+    assert_equal @@coll.index_information, info
+    assert_equal 2, info.length
+
+    assert info.has_key?(name)
+    assert_equal info[name], [["a", ASCENDING]]
   ensure
     @@db.drop_index(@@coll.name, name)
   end
 
   def test_multiple_index_cols
     name = @@db.create_index(@@coll.name, [['a', DESCENDING], ['b', ASCENDING], ['c', DESCENDING]])
-    list = @@db.index_information(@@coll.name)
-    assert_equal 2, list.length
+    info = @@db.index_information(@@coll.name)
+    assert_equal 2, info.length
+
+    assert_equal name, 'a_-1_b_1_c_-1'
+    assert info.has_key?(name)
+    assert_equal [['a', DESCENDING], ['b', ASCENDING], ['c', DESCENDING]], info[name]
+  ensure
+    @@db.drop_index(@@coll.name, name)
+  end
+
+  def test_multiple_index_cols_with_symbols
+    name = @@db.create_index(@@coll.name, [[:a, DESCENDING], [:b, ASCENDING], [:c, DESCENDING]])
+    info = @@db.index_information(@@coll.name)
+    assert_equal 2, info.length
 
-    info = list[1]
     assert_equal name, 'a_-1_b_1_c_-1'
-    assert_equal name, info[:name]
-    keys = info[:keys].keys
-    assert_equal ['a', 'b', 'c'], keys.sort
+    assert info.has_key?(name)
+    assert_equal [['a', DESCENDING], ['b', ASCENDING], ['c', DESCENDING]], info[name]
   ensure
     @@db.drop_index(@@coll.name, name)
   end
@@ -327,8 +358,25 @@ class DBAPITest < Test::Unit::TestCase
     test.insert("hello" => "mike")
     test.insert("hello" => "world")
     assert @@db.error?
+  end
+
+  def test_index_on_subfield
+    @@db.drop_collection("blah")
+    test = @@db.collection("blah")
+
+    test.insert("hello" => {"a" => 4, "b" => 5})
+    test.insert("hello" => {"a" => 7, "b" => 2})
+    test.insert("hello" => {"a" => 4, "b" => 10})
+    assert !@@db.error?
 
     @@db.drop_collection("blah")
+    test = @@db.collection("blah")
+    test.create_index("hello.a", unique=true)
+
+    test.insert("hello" => {"a" => 4, "b" => 5})
+    test.insert("hello" => {"a" => 7, "b" => 2})
+    test.insert("hello" => {"a" => 4, "b" => 10})
+    assert @@db.error?
   end
 
   def test_array
@@ -585,6 +633,58 @@ class DBAPITest < Test::Unit::TestCase
     assert_equal 2, @@coll.count
   end
 
+  def test_save_with_object_that_has_id_but_does_not_actually_exist_in_collection
+    @@coll.clear
+
+    a = {'_id' => '1', 'hello' => 'world'}
+    @@coll.save(a)
+    assert_equal(1, @@coll.count)
+    assert_equal("world", @@coll.find_first()["hello"])
+
+    a["hello"] = "mike"
+    @@coll.save(a)
+    assert_equal(1, @@coll.count)
+    assert_equal("mike", @@coll.find_first()["hello"])
+  end
+
+  def test_invalid_key_names
+    @@coll.clear
+
+    @@coll.insert({"hello" => "world"})
+    @@coll.insert({"hello" => {"hello" => "world"}})
+
+    assert_raise RuntimeError do
+      @@coll.insert({"$hello" => "world"})
+    end
+    assert_raise RuntimeError do
+      @@coll.insert({"hello" => {"$hello" => "world"}})
+    end
+
+    @@coll.insert({"he$llo" => "world"})
+    @@coll.insert({"hello" => {"hell$o" => "world"}})
+
+    assert_raise RuntimeError do
+      @@coll.insert({".hello" => "world"})
+    end
+    assert_raise RuntimeError do
+      @@coll.insert({"hello" => {".hello" => "world"}})
+    end
+    assert_raise RuntimeError do
+      @@coll.insert({"hello." => "world"})
+    end
+    assert_raise RuntimeError do
+      @@coll.insert({"hello" => {"hello." => "world"}})
+    end
+    assert_raise RuntimeError do
+      @@coll.insert({"hel.lo" => "world"})
+    end
+    assert_raise RuntimeError do
+      @@coll.insert({"hello" => {"hel.lo" => "world"}})
+    end
+
+    @@coll.modify({"hello" => "world"}, {"$inc" => "hello"})
+  end
+
 # TODO this test fails with error message "Undefed Before end of object"
 # That is a database error. The undefined type may go away.
 

metadata

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