mongodb-mongo 0.12 → 0.13

data/lib/mongo/message/update_message.rb

@@ -17,21 +17,17 @@
 require 'mongo/message/message'
 require 'mongo/message/opcodes'
 
-module XGen
-  module Mongo
-    module Driver
+module Mongo
 
-      class UpdateMessage < Message
+  class UpdateMessage < Message
 
-        def initialize(db_name, collection_name, sel, obj, repsert)
-          super(OP_UPDATE)
-          write_int(0)
-          write_string("#{db_name}.#{collection_name}")
-          write_int(repsert ? 1 : 0) # 1 if a repsert operation (upsert)
-          write_doc(sel)
-          write_doc(obj)
-        end
-      end
+    def initialize(db_name, collection_name, sel, obj, repsert)
+      super(OP_UPDATE)
+      write_int(0)
+      write_string("#{db_name}.#{collection_name}")
+      write_int(repsert ? 1 : 0) # 1 if a repsert operation (upsert)
+      write_doc(sel)
+      write_doc(obj)
     end
   end
 end

data/lib/mongo/query.rb

@@ -18,102 +18,98 @@ require 'mongo/collection'
 require 'mongo/message'
 require 'mongo/types/code'
 
-module XGen
-  module Mongo
-    module Driver
+module Mongo
 
-      # A query against a collection. A query's selector is a hash. See the
-      # Mongo documentation for query details.
-      class Query
+  # A query against a collection. A query's selector is a hash. See the
+  # Mongo documentation for query details.
+  class Query
 
-        attr_accessor :number_to_skip, :number_to_return, :order_by, :snapshot
-        # If true, $explain will be set in QueryMessage that uses this query.
-        attr_accessor :explain
-        # Either +nil+ or a hash (preferably an OrderedHash).
-        attr_accessor :hint
-        attr_reader :selector   # writer defined below
+    attr_accessor :number_to_skip, :number_to_return, :order_by, :snapshot
+    # If true, $explain will be set in QueryMessage that uses this query.
+    attr_accessor :explain
+    # Either +nil+ or a hash (preferably an OrderedHash).
+    attr_accessor :hint
+    attr_reader :selector   # writer defined below
 
-        # sel :: A hash describing the query. See the Mongo docs for details.
-        #
-        # return_fields :: If not +nil+, a single field name or an array of
-        #                  field names. Only those fields will be returned.
-        #                  (Called :fields in calls to Collection#find.)
-        #
-        # number_to_skip :: Number of records to skip before returning
-        #                   records. (Called :offset in calls to
-        #                   Collection#find.) Default is 0.
-        #
-        # number_to_return :: Max number of records to return. (Called :limit
-        #                     in calls to Collection#find.) Default is 0 (all
-        #                     records).
-        #
-        # order_by :: If not +nil+, specifies record sort order. May be a
-        #             String, Hash, OrderedHash, or Array. If a string, the
-        #             results will be ordered by that field in ascending
-        #             order. If an array, it should be an array of field names
-        #             which will all be sorted in ascending order. If a hash,
-        #             it may be either a regular Hash or an OrderedHash. The
-        #             keys should be field names, and the values should be 1
-        #             (ascending) or -1 (descending). Note that if it is a
-        #             regular Hash then sorting by more than one field
-        #             probably will not be what you intend because key order
-        #             is not preserved. (order_by is called :sort in calls to
-        #             Collection#find.)
-        #
-        # hint :: If not +nil+, specifies query hint fields. Must be either
-        #                +nil+ or a hash (preferably an OrderedHash). See
-        #                Collection#hint.
-        def initialize(sel={}, return_fields=nil, number_to_skip=0, number_to_return=0, order_by=nil, hint=nil, snapshot=nil)
-          @number_to_skip, @number_to_return, @order_by, @hint, @snapshot =
-            number_to_skip, number_to_return, order_by, hint, snapshot
-          @explain = nil
-          self.selector = sel
-          self.fields = return_fields
-        end
-
-        # Set query selector hash. If sel is Code/string, it will be used as a
-        # $where clause. (See Mongo docs for details.)
-        def selector=(sel)
-          @selector = case sel
-                      when nil
-                        {}
-                      when Code
-                        {"$where" => sel}
-                      when String
-                        {"$where" => Code.new(sel)}
-                      when Hash
-                        sel
-                      end
-        end
+    # sel :: A hash describing the query. See the Mongo docs for details.
+    #
+    # return_fields :: If not +nil+, a single field name or an array of
+    #                  field names. Only those fields will be returned.
+    #                  (Called :fields in calls to Collection#find.)
+    #
+    # number_to_skip :: Number of records to skip before returning
+    #                   records. (Called :offset in calls to
+    #                   Collection#find.) Default is 0.
+    #
+    # number_to_return :: Max number of records to return. (Called :limit
+    #                     in calls to Collection#find.) Default is 0 (all
+    #                     records).
+    #
+    # order_by :: If not +nil+, specifies record sort order. May be a
+    #             String, Hash, OrderedHash, or Array. If a string, the
+    #             results will be ordered by that field in ascending
+    #             order. If an array, it should be an array of field names
+    #             which will all be sorted in ascending order. If a hash,
+    #             it may be either a regular Hash or an OrderedHash. The
+    #             keys should be field names, and the values should be 1
+    #             (ascending) or -1 (descending). Note that if it is a
+    #             regular Hash then sorting by more than one field
+    #             probably will not be what you intend because key order
+    #             is not preserved. (order_by is called :sort in calls to
+    #             Collection#find.)
+    #
+    # hint :: If not +nil+, specifies query hint fields. Must be either
+    #                +nil+ or a hash (preferably an OrderedHash). See
+    #                Collection#hint.
+    def initialize(sel={}, return_fields=nil, number_to_skip=0, number_to_return=0, order_by=nil, hint=nil, snapshot=nil)
+      @number_to_skip, @number_to_return, @order_by, @hint, @snapshot =
+        number_to_skip, number_to_return, order_by, hint, snapshot
+      @explain = nil
+      self.selector = sel
+      self.fields = return_fields
+    end
 
-        # Set fields to return. If +val+ is +nil+ or empty, all fields will be
-        # returned.
-        def fields=(val)
-          @fields = val
-          @fields = nil if @fields && @fields.empty?
-        end
+    # Set query selector hash. If sel is Code/string, it will be used as a
+    # $where clause. (See Mongo docs for details.)
+    def selector=(sel)
+      @selector = case sel
+                  when nil
+                    {}
+                  when Code
+                    {"$where" => sel}
+                  when String
+                    {"$where" => Code.new(sel)}
+                  when Hash
+                    sel
+                  end
+    end
 
-        def fields
-          case @fields
-          when String
-            {@fields => 1}
-          when Array
-            if @fields.length == 0
-              nil
-            else
-              h = {}
-              @fields.each { |field| h[field] = 1 }
-              h
-            end
-          else                  # nil, anything else
-            nil
-          end
-        end
+    # Set fields to return. If +val+ is +nil+ or empty, all fields will be
+    # returned.
+    def fields=(val)
+      @fields = val
+      @fields = nil if @fields && @fields.empty?
+    end
 
-        def contains_special_fields
-          (@order_by != nil && @order_by.length > 0) || @explain || @hint || @snapshot
+    def fields
+      case @fields
+      when String
+        {@fields => 1}
+      when Array
+        if @fields.length == 0
+          nil
+        else
+          h = {}
+          @fields.each { |field| h[field] = 1 }
+          h
         end
+      else                  # nil, anything else
+        nil
       end
     end
+
+    def contains_special_fields
+      (@order_by != nil && @order_by.length > 0) || @explain || @hint || @snapshot
+    end
   end
 end

data/lib/mongo/types/binary.rb

@@ -16,27 +16,23 @@
 
 require 'mongo/util/byte_buffer'
 
-module XGen
-  module Mongo
-    module Driver
+module Mongo
 
-      # An array of binary bytes with a Mongo subtype value.
-      class Binary < ByteBuffer
+  # An array of binary bytes with a Mongo subtype value.
+  class Binary < ByteBuffer
 
-        SUBTYPE_BYTES = 0x02
-        SUBTYPE_UUID = 0x03
-        SUBTYPE_MD5 = 0x05
-        SUBTYPE_USER_DEFINED = 0x80
+    SUBTYPE_BYTES = 0x02
+    SUBTYPE_UUID = 0x03
+    SUBTYPE_MD5 = 0x05
+    SUBTYPE_USER_DEFINED = 0x80
 
-        # One of the SUBTYPE_* constants. Default is SUBTYPE_BYTES.
-        attr_accessor :subtype
+    # One of the SUBTYPE_* constants. Default is SUBTYPE_BYTES.
+    attr_accessor :subtype
 
-        def initialize(initial_data=[], subtype=SUBTYPE_BYTES)
-          super(initial_data)
-          @subtype = subtype
-        end
-
-      end
+    def initialize(initial_data=[], subtype=SUBTYPE_BYTES)
+      super(initial_data)
+      @subtype = subtype
     end
+
   end
 end

data/lib/mongo/types/code.rb

@@ -14,21 +14,17 @@
 # limitations under the License.
 # ++
 
-module XGen
-  module Mongo
-    module Driver
+module Mongo
 
-      # JavaScript code to be evaluated by MongoDB
-      class Code < String
-        # Hash mapping identifiers to their values
-        attr_accessor :scope
+  # JavaScript code to be evaluated by MongoDB
+  class Code < String
+    # Hash mapping identifiers to their values
+    attr_accessor :scope
 
-        def initialize(code, scope={})
-          super(code)
-          @scope = scope
-        end
-
-      end
+    def initialize(code, scope={})
+      super(code)
+      @scope = scope
     end
+
   end
 end

data/lib/mongo/types/dbref.rb

@@ -14,24 +14,20 @@
 # limitations under the License.
 # ++
 
-module XGen
-  module Mongo
-    module Driver
+module Mongo
 
-      class DBRef
+  class DBRef
 
-        attr_reader :namespace, :object_id
+    attr_reader :namespace, :object_id
 
-        def initialize(namespace, object_id)
-          @namespace, @object_id =
-            namespace, object_id
-        end
-
-        def to_s
-          "ns: #{namespace}, id: #{object_id}"
-        end
+    def initialize(namespace, object_id)
+      @namespace, @object_id =
+        namespace, object_id
+    end
 
-      end
+    def to_s
+      "ns: #{namespace}, id: #{object_id}"
     end
+
   end
 end

data/lib/mongo/types/objectid.rb

@@ -17,121 +17,117 @@
 require 'mutex_m'
 require 'mongo/util/byte_buffer'
 
-module XGen
-  module Mongo
-    module Driver
-
-      # 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
-      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.
-        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
+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
+  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.
+    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
-          match = $1
-          str && str.length == len && match == str
-        end
+    def self.legal?(str)
+      len = BYTE_ORDER.length * 2
+      str =~ /([0-9a-f]+)/i
+      match = $1
+      str && str.length == len && match == str
+    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)
-        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)
+    end
 
-        def eql?(other)
-          @data == other.instance_variable_get("@data")
-        end
-        alias_method :==, :eql?
+    def eql?(other)
+      @data == other.instance_variable_get("@data")
+    end
+    alias_method :==, :eql?
 
-        def to_a
-          @data.dup
-        end
+    def to_a
+      @data.dup
+    end
 
-        def to_s
-          str = ' ' * 24
-          BYTE_ORDER.each_with_index { |string_position, data_index|
-            str[string_position * 2, 2] = '%02x' % @data[data_index]
-          }
-          str
-        end
+    def to_s
+      str = ' ' * 24
+      BYTE_ORDER.each_with_index { |string_position, data_index|
+        str[string_position * 2, 2] = '%02x' % @data[data_index]
+      }
+      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
-        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
+    end
 
-        # (Would normally be private, but isn't so we can test it.)
-        def index_for_time(t)
-          LOCK.mu_synchronize {
-            if t != @@index_time
-              @@index = 0
-              @@index_time = t
-            end
-            retval = @@index
-            @@index += 1
-            retval
-          }
+    # (Would normally be private, but isn't so we can test it.)
+    def index_for_time(t)
+      LOCK.mu_synchronize {
+        if t != @@index_time
+          @@index = 0
+          @@index_time = t
         end
-
-      end
+        retval = @@index
+        @@index += 1
+        retval
+      }
     end
+
   end
 end