moped 1.3.2 → 1.4.0

data/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Overview
 
+## 1.4.0
+
+* \#144 Moped now supports $maxScan options in queries. (Jonathan Hyman)
+
+        session[:bands].find(name: "Blur").max_scan(50)
+
+* \#143 Aggregation pipeline commands no longer force to read from
+  primary.
+
+* \#141 Timeouts on sockets are now set to the timeout level provided, as
+  well is active checks now happen before sending both reads and writes.
+
+* \#140 Nodes that were provided to Moped's session in intialization, that
+  were removed from the replica set but still alive and accepting
+  connections will no longer be in the list of available nodes.
+
+* \#138 Aggregation pipeline now supports array or splat args. (Gosha Arinich)
+
+* \#137 `IOError` exceptions during connection go through reconnect
+  process properly. (Peter Kieltyka)
+
+* \#120 Return UTF-8 strings when calling `ObjectId#to_s`.
+
+* \#41 `Moped::BSON::ObjectId.from_time` now accepts a `unique` option to
+  ensure the generated id is unique.
+
+        Moped::BSON::ObjectId.from_time(time, unique: true)
+
+* mongoid/mongoid\#2738 Ensure that delete operations don't include
+  special selectors, like $query.
+
+* mongoid/mongoid\#2713 Allow collections that have names that start with
+  "system" to be returned by `Database#collection_names`.
+
+* mongoid/mongoid\#2452 A boolean can now be passed to count to determine
+  if the skip and limit options should be included in the value.
+
+        session[:bands].find(name: "Blur").skip(10).limit(5).count(true)
+
 ## 1.3.2
 
 ### Resolved Issues

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2012 Bernerd Schaefer
+Copyright (c) 2011-2013 Bernerd Schaefer, Durran Jordan
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -25,7 +25,7 @@ the Moped section: [mongoid.org](http://mongoid.org/en/moped/)
 License
 -------
 
-Copyright (c) 2011-2012 Bernerd Schaefer
+Copyright (c) 2011-2013 Bernerd Schaefer, Durran Jordan
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/moped/bson.rb

@@ -1,12 +1,11 @@
+# encoding: utf-8
 require "moped/bson/extensions"
-
 require "moped/bson/binary"
 require "moped/bson/code"
 require "moped/bson/object_id"
 require "moped/bson/max_key"
 require "moped/bson/min_key"
 require "moped/bson/timestamp"
-
 require "moped/bson/document"
 require "moped/bson/types"
 
@@ -14,6 +13,7 @@ module Moped
 
   # The module for Moped's BSON implementation.
   module BSON
+
     EOD = NULL_BYTE = "\u0000".freeze
 
     INT32_PACK = 'l'.freeze
@@ -22,8 +22,8 @@ module Moped
 
     START_LENGTH = [0].pack(INT32_PACK).freeze
 
-    BINARY_ENCODING = Encoding.find 'binary'
-    UTF8_ENCODING   = Encoding.find 'utf-8'
+    BINARY_ENCODING = Encoding.find("binary")
+    UTF8_ENCODING   = Encoding.find("utf-8")
 
     class << self
 

data/lib/moped/bson/binary.rb

@@ -1,5 +1,7 @@
 module Moped
   module BSON
+
+    # Represents binary data in the BSON specification.
     class Binary
 
       SUBTYPE_MAP = {
@@ -9,39 +11,21 @@ module Moped
         uuid:     "\x03",
         md5:      "\x05",
         user:     "\x80"
-      }
-
-      attr_reader :data, :type
-
-      def initialize(type, data)
-        @type = type
-        @data = data
-      end
+      }.freeze
 
-      class << self
-        def __bson_load__(io)
-          length, = io.read(4).unpack(INT32_PACK)
-          type = SUBTYPE_MAP.invert[io.read(1)]
+      SUBTYPE_TYPES = SUBTYPE_MAP.invert.freeze
 
-          if type == :old
-            length -= 4
-            io.read(4)
-          end
-
-          data = io.read length
-          new(type, data)
-        end
-      end
-
-      def ==(other)
-        BSON::Binary === other && data == other.data && type == other.type
-      end
-      alias eql? ==
-
-      def hash
-        [data, type].hash
-      end
+      attr_reader :data, :type
 
+      # Dump the binary into it's raw bytes.
+      #
+      # @example Dump the binary to raw bytes.
+      #   binary.__bson_dump__(string, "data")
+      #
+      # @param [ String ] io The raw bytes to write to.
+      # @param [ String ] key The field name.
+      #
+      # @since 1.0.0
       def __bson_dump__(io, key)
         io << Types::BINARY
         io << key
@@ -59,13 +43,95 @@ module Moped
         end
       end
 
+      # Check equality on the object.
+      #
+      # @example Check equality.
+      #   object == other
+      #
+      # @param [ Object ] other The object to check against.
+      #
+      # @return [ true, false ] If the objects are equal.
+      #
+      # @since 1.0.0
+      def ==(other)
+        BSON::Binary === other && data == other.data && type == other.type
+      end
+      alias :eql? :==
+
+      # Gets the hash code for the object.
+      #
+      # @example Get the hash code.
+      #   object.hash
+      #
+      # @return [ Fixnum ] The hash code.
+      #
+      # @since 1.0.0
+      def hash
+        [data, type].hash
+      end
+
+      # Create the new binary type.
+      #
+      # @example Create the new binary.
+      #   Moped::BSON::Binary.new(:md5, data)
+      #
+      # @param [ Symbol ] type The type of data. Should be one of :generic,
+      #   :function, :old, :uuid, :md5, :user
+      # @param [ Object ] data The binary data.
+      #
+      # @since 1.0.0
+      def initialize(type, data)
+        @type = type
+        @data = data
+      end
+
+      # Gets the string inspection for the object.
+      #
+      # @example Get the string inspection.
+      #   object.inspect
+      #
+      # @return [ String ] The inspection.
+      #
+      # @since 1.0.0
       def inspect
         "#<#{self.class.name} type=#{type.inspect} length=#{data.bytesize}>"
       end
 
+      # Get the string representation of the object.
+      #
+      # @example Get the string representation.
+      #   object.to_s
+      #
+      # @return [ String ] The string representation.
+      #
+      # @since 1.0.0
       def to_s
         data.to_s
       end
+
+      class << self
+
+        # Load the BSON from the raw data to a binary.
+        #
+        # @example Load the raw data.
+        #   Moped::BSON::Binary.__bson_load__(data)
+        #
+        # @param [ String ] io The raw bytes of data.
+        #
+        # @return [ Binary ] The binary object.
+        #
+        # @since 1.0.0
+        def __bson_load__(io)
+          length, = io.read(4).unpack(INT32_PACK)
+          type = SUBTYPE_TYPES[io.read(1)]
+          if type == :old
+            length -= 4
+            io.read(4)
+          end
+          data = io.read(length)
+          new(type, data)
+        end
+      end
     end
   end
 end

data/lib/moped/bson/code.rb

@@ -1,56 +1,35 @@
 module Moped
   module BSON
+
+    # Object representation of a javascript expression.
     class Code
 
       attr_reader :code, :scope
 
-      def initialize(code, scope=nil)
-        @code = code
-        @scope = scope
-      end
-
-      def scoped?
-        !!scope
-      end
-
-      def ==(other)
-        BSON::Code === other && code == other.code && scope == other.scope
-      end
-      alias eql? ==
-
-      def hash
-        [code, scope].hash
-      end
-
-      class << self
-        def __bson_load__(io)
-          code = io.read(*io.read(4).unpack(INT32_PACK)).from_utf8_binary.chop!
-          new code
-        end
-      end
-
+      # Dump the code into it's raw bytes.
+      #
+      # @example Dump the code to raw bytes.
+      #   code.__bson_dump__(string, "expression")
+      #
+      # @param [ String ] io The raw bytes to write to.
+      # @param [ String ] key The field name.
+      #
+      # @since 1.0.0
       def __bson_dump__(io, key)
         if scoped?
           io << Types::CODE_WITH_SCOPE
           io << key.to_bson_cstring
-
           code_start = io.bytesize
-
           io << START_LENGTH
-
           data = code.to_utf8_binary
           io << [data.bytesize+1].pack(INT32_PACK)
           io << data
           io << NULL_BYTE
-
           scope.__bson_dump__(io)
-
           io[code_start, 4] = [io.bytesize - code_start].pack(INT32_PACK)
-
         else
           io << Types::CODE
           io << key.to_bson_cstring
-
           data = code.to_utf8_binary
           io << [data.bytesize+1].pack(INT32_PACK)
           io << data
@@ -58,6 +37,76 @@ module Moped
         end
       end
 
+      # Check equality on the object.
+      #
+      # @example Check equality.
+      #   object == other
+      #
+      # @param [ Object ] other The object to check against.
+      #
+      # @return [ true, false ] If the objects are equal.
+      #
+      # @since 1.0.0
+      def ==(other)
+        BSON::Code === other && code == other.code && scope == other.scope
+      end
+      alias :eql? :==
+
+      # Gets the hash code for the object.
+      #
+      # @example Get the hash code.
+      #   object.hash
+      #
+      # @return [ Fixnum ] The hash code.
+      #
+      # @since 1.0.0
+      def hash
+        [code, scope].hash
+      end
+
+      # Create the new code type.
+      #
+      # @example Create the new code.
+      #   Moped::BSON::Code.new("this.value = param", param: "test")
+      #
+      # @param [ String ] code The javascript code.
+      # @param [ Object ] scope The scoped variables and values.
+      #
+      # @since 1.0.0
+      def initialize(code, scope = nil)
+        @code = code
+        @scope = scope
+      end
+
+      # Is the code scoped?
+      #
+      # @example Is the code scoped?
+      #   code.scoped?
+      #
+      # @return [ true, false ] If the code is scoped.
+      #
+      # @since 1.0.0
+      def scoped?
+        !!scope
+      end
+
+      class << self
+
+        # Load the BSON from the raw data to a code.
+        #
+        # @example Load the raw data.
+        #   Moped::BSON::Code.__bson_load__(data)
+        #
+        # @param [ String ] io The raw bytes of data.
+        #
+        # @return [ Code ] The code object.
+        #
+        # @since 1.0.0
+        def __bson_load__(io)
+          code = io.read(*io.read(4).unpack(INT32_PACK)).from_utf8_binary.chop!
+          new(code)
+        end
+      end
     end
   end
 end

data/lib/moped/bson/document.rb

@@ -1,12 +1,37 @@
 module Moped
   module BSON
+
+    # Represents an entire BSON document.
     class Document < Hash
+
       class << self
 
+        # Deserialize the raw bytes into a BSON document object.
+        #
+        # @example Deserialize the raw bytes.
+        #   Moped::BSON::Document.deserialize("")
+        #
+        # @param [ String ] io The raw bytes.
+        # @param [ Document ] document The document to load to.
+        #
+        # @return [ Document ] The document from the raw bytes.
+        #
+        # @since 1.0.0
         def deserialize(io, document = new)
           __bson_load__(io, document)
         end
 
+        # Serialize a document into raw bytes.
+        #
+        # @example Serialize the document.
+        #   Moped::BSON::Document.serialize(doc, "")
+        #
+        # @param [ Document ] document The document to serialize.
+        # @param [ String ] io The raw bytes to write to.
+        #
+        # @return [ String ] The raw serialized bytes.
+        #
+        # @since 1.0.0
         def serialize(document, io = "")
           document.__bson_dump__(io)
         end

data/lib/moped/bson/extensions/array.rb

@@ -1,46 +1,36 @@
 module Moped
   module BSON
-    # @private
     module Extensions
-      module Array
-
-        module ClassMethods
-          def __bson_load__(io, array = new)
-            # Swallow the first four (length) bytes
-            io.read 4
-
-            while (buf = io.readbyte) != 0
-              io.gets(NULL_BYTE)
-              array << Types::MAP[buf].__bson_load__(io)
-            end
 
-            array
-          end
-        end
+      module Array
 
         def __bson_dump__(io, key)
           io << Types::ARRAY
           io << key.to_bson_cstring
-
           start = io.bytesize
-
-          # write dummy length
-          io << START_LENGTH
-
+          io << START_LENGTH # write dummy length
           index, length = 0, self.length
-
           while index < length
             slice(index).__bson_dump__(io, index.to_s)
             index += 1
           end
-
           io << EOD
-
           stop = io.bytesize
           io[start, 4] = [stop - start].pack(INT32_PACK)
-
           io
         end
+
+        module ClassMethods
+
+          def __bson_load__(io, array = new)
+            io.read(4) # Swallow the first four (length) bytes
+            while (buf = io.readbyte) != 0
+              io.gets(NULL_BYTE)
+              array << Types::MAP[buf].__bson_load__(io)
+            end
+            array
+          end
+        end
       end
     end
   end