mongo 2.1.2 → 2.2.0.rc0

data/lib/mongo/options/mapper.rb

@@ -42,6 +42,28 @@ module Mongo
         end
       end
 
+      # Transforms the provided options to a new set of options given the
+      # provided mapping. Expects BSON::Documents in and out so no explicit
+      # string conversion needs to happen.
+      #
+      # @example Transform the options.
+      #   Mapper.transform_documents({ name: 1 }, { :name => :nombre })
+      #
+      # @param [ BSON::Document ] options The options to transform
+      # @param [ BSON::Document ] mappings The key mappings.
+      # @param [ BSON::Document ] document The output document.
+      #
+      # @return [ BSON::Document ] The transformed options.
+      #
+      # @since 2.0.0
+      def transform_documents(options, mappings, document = BSON::Document.new)
+        options.reduce(document) do |transformed, (key, value)|
+          name = mappings[key]
+          transformed[name] = value if name && !value.nil?
+          transformed
+        end
+      end
+
       # Coverts all the keys of the options to strings.
       #
       # @example Convert all option keys to strings.

data/lib/mongo/protocol/bit_vector.rb

@@ -40,15 +40,15 @@ module Mongo
         def serialize(buffer, value)
           bits = 0
           value.each { |flag| bits |= @masks[flag] }
-          buffer << [bits].pack(INT32_PACK)
+          buffer.put_int32(bits)
         end
 
         # Deserializes vector by decoding the symbol according to its mask
         #
         # @param io [IO] Stream containing the vector to be deserialized
         # @return [Array<Symbol>] Flags contained in the vector
-        def deserialize(io)
-          vector = io.read(4).unpack(INT32_PACK).first
+        def deserialize(buffer)
+          vector = buffer.get_int32
           flags = []
           @masks.each do |flag, mask|
             flags << flag if mask & vector != 0

data/lib/mongo/protocol/delete.rb

@@ -99,6 +99,16 @@ module Mongo
       # @since 2.1.0
       class Upconverter
 
+        # The delete command constant.
+        #
+        # @since 2.2.0
+        DELETE = 'delete'.freeze
+
+        # The deletes command constant.
+        #
+        # @since 2.2.0
+        DELETES = 'deletes'.freeze
+
         # @return [ String ] collection The name of the collection.
         attr_reader :collection
 
@@ -132,11 +142,11 @@ module Mongo
         #
         # @since 2.1.0
         def command
-          BSON::Document.new(
-            delete: collection,
-            deletes: [ BSON::Document.new(q: filter, limit: limit) ],
-            ordered: true
-          )
+          document = BSON::Document.new
+          document.store(DELETE, collection)
+          document.store(DELETES, [ BSON::Document.new(Message::Q => filter, Message::LIMIT => limit) ])
+          document.store(Message::ORDERED, true)
+          document
         end
 
         private

data/lib/mongo/protocol/get_more.rb

@@ -104,6 +104,11 @@ module Mongo
       # @since 2.1.0
       class Upconverter
 
+        # The get more constant.
+        #
+        # @since 2.2.0
+        GET_MORE = 'getMore'.freeze
+
         # @return [ String ] collection The name of the collection.
         attr_reader :collection
 
@@ -139,11 +144,11 @@ module Mongo
         #
         # @since 2.1.0
         def command
-          BSON::Document.new(
-            getMore: cursor_id,
-            batchSize: number_to_return,
-            collection: collection
-          )
+          document = BSON::Document.new
+          document.store(GET_MORE, cursor_id)
+          document.store(Message::BATCH_SIZE, number_to_return)
+          document.store(Message::COLLECTION, collection)
+          document
         end
       end
     end

data/lib/mongo/protocol/insert.rb

@@ -114,11 +114,6 @@ module Mongo
         # @since 2.1.0
         DOCUMENTS = 'documents'.freeze
 
-        # Ordered field constant.
-        #
-        # @since 2.1.0
-        ORDERED = 'ordered'.freeze
-
         # Write concern field constant.
         #
         # @since 2.1.0
@@ -161,7 +156,7 @@ module Mongo
           document = BSON::Document.new
           document.store(INSERT, collection)
           document.store(DOCUMENTS, documents)
-          document.store(ORDERED, options.fetch(:ordered, true))
+          document.store(Message::ORDERED, options.fetch(:ordered, true))
           document.merge!(WRITE_CONCERN => options[:write_concern].options) if options[:write_concern]
           document
         end

data/lib/mongo/protocol/kill_cursors.rb

@@ -82,6 +82,16 @@ module Mongo
       # @since 2.1.0
       class Upconverter
 
+        # The kill cursors constant.
+        #
+        # @since 2.2.0
+        KILL_CURSORS = 'killCursors'.freeze
+
+        # The cursors constant.
+        #
+        # @since 2.2.0
+        CURSORS = 'cursors'.freeze
+
         # @return [ String ] collection The name of the collection.
         attr_reader :collection
 
@@ -111,7 +121,10 @@ module Mongo
         #
         # @since 2.1.0
         def command
-          BSON::Document.new(killCursors: collection, cursors: cursor_ids)
+          document = BSON::Document.new
+          document.store(KILL_CURSORS, collection)
+          document.store(CURSORS, cursor_ids)
+          document
         end
       end
     end

data/lib/mongo/protocol/message.rb

@@ -42,6 +42,31 @@ module Mongo
     class Message
       include Serializers
 
+      # The batch size constant.
+      #
+      # @since 2.2.0
+      BATCH_SIZE = 'batchSize'.freeze
+
+      # The collection constant.
+      #
+      # @since 2.2.0
+      COLLECTION = 'collection'.freeze
+
+      # The limit constant.
+      #
+      # @since 2.2.0
+      LIMIT = 'limit'.freeze
+
+      # The ordered constant.
+      #
+      # @since 2.2.0
+      ORDERED = 'ordered'.freeze
+
+      # The q constant.
+      #
+      # @since 2.2.0
+      Q = 'q'.freeze
+
       # Returns the request id for the message
       #
       # @return [Fixnum] The request id for this message
@@ -64,13 +89,11 @@ module Mongo
       #
       # @param buffer [String] buffer where the message should be inserted
       # @return [String] buffer containing the serialized message
-      def serialize(buffer = ''.force_encoding('BINARY'), max_bson_size = nil)
-        start = buffer.bytesize
+      def serialize(buffer = BSON::ByteBuffer.new, max_bson_size = nil)
+        start = buffer.length
         serialize_header(buffer)
         serialize_fields(buffer, max_bson_size)
-        length = buffer.bytesize - start
-        buffer[start, 4] = Int32.serialize('', length)
-        buffer
+        buffer.replace_int32(start, buffer.length - start)
       end
 
       alias_method :to_s, :serialize
@@ -80,13 +103,14 @@ module Mongo
       # @param io [IO] Stream containing a message
       # @return [Message] Instance of a Message class
       def self.deserialize(io)
-        deserialize_header(io)
+        length = deserialize_header(BSON::ByteBuffer.new(io.read(16))).first
+        buffer = BSON::ByteBuffer.new(io.read(length - 16))
         message = allocate
         fields.each do |field|
           if field[:multi]
-            deserialize_array(message, io, field)
+            deserialize_array(message, buffer, field)
           else
-            deserialize_field(message, io, field)
+            deserialize_field(message, buffer, field)
           end
         end
         message

data/lib/mongo/protocol/serializers.rb

@@ -50,7 +50,7 @@ module Mongo
         # @param value [String] Header value to be serialized.
         # @return [String] Buffer with serialized value.
         def self.serialize(buffer, value)
-          buffer << value.pack(HEADER_PACK)
+          buffer.put_bytes(value.pack(HEADER_PACK))
         end
 
         # Deserializes the header value from the IO stream
@@ -58,8 +58,8 @@ module Mongo
         # @param io [IO] IO stream containing the message header.
         # @return [Array<Fixnum>] Array consisting of the deserialized
         #   length, request id, response id, and op code.
-        def self.deserialize(io)
-          io.read(16).unpack(HEADER_PACK)
+        def self.deserialize(buffer)
+          buffer.get_bytes(16).unpack(HEADER_PACK)
         end
       end
 
@@ -74,8 +74,7 @@ module Mongo
         # @param value [String] The string to be serialized.
         # @return [String] Buffer with serialized value.
         def self.serialize(buffer, value)
-          buffer << value.force_encoding(BSON::BINARY)
-          buffer << NULL
+          buffer.put_cstring(value)
         end
       end
 
@@ -90,7 +89,7 @@ module Mongo
         # @param value [Fixnum] Ignored value.
         # @return [String] Buffer with serialized value.
         def self.serialize(buffer, value)
-          buffer << [ZERO].pack(INT32_PACK)
+          buffer.put_int32(ZERO)
         end
       end
 
@@ -105,15 +104,15 @@ module Mongo
         # @param value [Fixnum] 32-bit integer to be serialized.
         # @return [String] Buffer with serialized value.
         def self.serialize(buffer, value)
-          buffer << [value].pack(INT32_PACK)
+          buffer.put_int32(value)
         end
 
         # Deserializes a 32-bit Fixnum from the IO stream
         #
         # @param io [IO] IO stream containing the 32-bit integer
         # @return [Fixnum] Deserialized Int32
-        def self.deserialize(io)
-          io.read(4).unpack(INT32_PACK).first
+        def self.deserialize(buffer)
+          buffer.get_int32
         end
       end
 
@@ -128,15 +127,15 @@ module Mongo
         # @param value [Fixnum] 64-bit integer to be serialized.
         # @return [String] Buffer with serialized value.
         def self.serialize(buffer, value)
-          buffer << [value].pack(INT64_PACK)
+          buffer.put_int64(value)
         end
 
         # Deserializes a 64-bit Fixnum from the IO stream
         #
         # @param io [IO] IO stream containing the 64-bit integer.
         # @return [Fixnum] Deserialized Int64.
-        def self.deserialize(io)
-          io.read(8).unpack(INT64_PACK).first
+        def self.deserialize(buffer)
+          buffer.get_int64
         end
       end
 
@@ -151,9 +150,9 @@ module Mongo
         # @param value [Hash] Document to serialize as BSON.
         # @return [String] Buffer with serialized value.
         def self.serialize(buffer, value, max_bson_size = nil)
-          start_size = buffer.size
+          start_size = buffer.length
           value.to_bson(buffer)
-          if max_bson_size && buffer.size - start_size > max_bson_size
+          if max_bson_size && buffer.length - start_size > max_bson_size
             raise Error::MaxBSONSize.new(max_bson_size)
           end
         end
@@ -162,8 +161,8 @@ module Mongo
         #
         # @param io [IO] IO stream containing the BSON encoded document.
         # @return [Hash] The decoded BSON document.
-        def self.deserialize(io)
-          BSON::Document.from_bson(io)
+        def self.deserialize(buffer)
+          BSON::Document.from_bson(buffer)
         end
 
         # Whether there can be a size limit on this type after serialization.

data/lib/mongo/protocol/update.rb

@@ -116,6 +116,31 @@ module Mongo
       # @since 2.1.0
       class Upconverter
 
+        # The multi constant.
+        #
+        # @since 2.2.0
+        MULTI = 'multi'.freeze
+
+        # The u constant.
+        #
+        # @since 2.2.0
+        U = 'u'.freeze
+
+        # The update constant.
+        #
+        # @since 2.2.0
+        UPDATE = 'update'.freeze
+
+        # The updates constant.
+        #
+        # @since 2.2.0
+        UPDATES = 'updates'.freeze
+
+        # The upsert constant.
+        #
+        # @since 2.2.0
+        UPSERT = 'upsert'.freeze
+
         # @return [ String ] collection The name of the collection.
         attr_reader :collection
 
@@ -160,18 +185,16 @@ module Mongo
         #
         # @since 2.1.0
         def command
-          BSON::Document.new(
-            update: collection,
-            ordered: true,
-            updates: [
-              BSON::Document.new(
-                q: filter,
-                u: update,
-                multi: flags.include?(:multi_update),
-                upsert: flags.include?(:upsert),
-              )
-            ]
-          )
+          document = BSON::Document.new
+          updates = BSON::Document.new
+          updates.store(Message::Q, filter)
+          updates.store(U, update)
+          updates.store(MULTI, flags.include?(:multi_update))
+          updates.store(UPSERT, flags.include?(:upsert))
+          document.store(UPDATE, collection)
+          document.store(Message::ORDERED, true)
+          document.store(UPDATES, [ updates ])
+          document
         end
       end
     end

data/lib/mongo/server/connectable.rb

@@ -103,7 +103,9 @@ module Mongo
       end
 
       def read
-        ensure_connected{ |socket| Protocol::Reply.deserialize(socket) }
+        ensure_connected do |socket|
+          Protocol::Reply.deserialize(socket)
+        end
       end
     end
   end

data/lib/mongo/server/connection.rb

@@ -36,7 +36,7 @@ module Mongo
       # The ping message as raw bytes.
       #
       # @since 2.1.0
-      PING_BYTES = PING_MESSAGE.serialize.freeze
+      PING_BYTES = PING_MESSAGE.serialize.to_s.freeze
 
       # @return [ Mongo::Auth::CR, Mongo::Auth::X509, Mongo::Auth:LDAP, Mongo::Auth::SCRAM ]
       #   authenticator The authentication strategy.
@@ -188,17 +188,17 @@ module Mongo
         end
       end
 
-      def write(messages, buffer = ''.force_encoding(BSON::BINARY))
+      def write(messages, buffer = BSON::ByteBuffer.new)
         start_size = 0
         messages.each do |message|
           message.serialize(buffer, max_bson_object_size)
           if max_message_size &&
-            (buffer.size - start_size) > max_message_size
+            (buffer.length - start_size) > max_message_size
             raise Error::MaxMessageSize.new(max_message_size)
-            start_size = buffer.size
+            start_size = buffer.length
           end
         end
-        ensure_connected{ |socket| socket.write(buffer) }
+        ensure_connected{ |socket| socket.write(buffer.to_s) }
       end
     end
   end

data/lib/mongo/server/description.rb

@@ -142,7 +142,7 @@ module Mongo
       # Fields to exclude when comparing two descriptions.
       #
       # @since 2.0.6
-      EXCLUDE_FOR_COMPARISON = [ LOCAL_TIME, ELECTION_ID ]
+      EXCLUDE_FOR_COMPARISON = [ LOCAL_TIME, ELECTION_ID ].freeze
 
       # @return [ Address ] address The server's address.
       attr_reader :address
@@ -553,11 +553,17 @@ module Mongo
       def ==(other)
         return false if self.class != other.class
         return true if config == other.config
+        compare_config(other)
+      end
+      alias_method :eql?, :==
+
+      private
+
+      def compare_config(other)
         !config.keys.empty? && config.keys.all? do |k|
           config[k] == other.config[k] || EXCLUDE_FOR_COMPARISON.include?(k)
         end
       end
-      alias_method :eql?, :==
     end
   end
 end