moped 1.3.2 → 1.4.0

data/lib/moped/bson/object_id.rb

@@ -6,83 +6,262 @@ module Moped
     class ObjectId
       include Comparable
 
-      class << self
-        def from_string(string)
-          raise Errors::InvalidObjectId.new(string) unless legal?(string)
-          from_data [string].pack("H*")
-        end
-
-        def from_time(time)
-          from_data [time.to_i].pack("Nx8")
-        end
-
-        def legal?(str)
-          /\A\h{24}\Z/ === str.to_s
-        end
-
-        def from_data(data)
-          id = allocate
-          id.send(:data=, data)
-          id
-        end
+      # Serialize the object id to its raw bytes.
+      #
+      # @example Serialize the object id.
+      #   object_id.__bson_dump__("", "_id")
+      #
+      # @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::OBJECT_ID
+        io << key.to_bson_cstring
+        io << data
       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)
         return to_str === other.to_str if other.respond_to?(:to_str)
         super
       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::ObjectId === other && data == other.data
+      end
+      alias :eql? :==
+
+      # Compare this object with another object, used in sorting.
+      #
+      # @example Compare the two objects.
+      #   object <=> other
+      #
+      # @param [ Object ] other The object to compare to.
+      #
+      # @return [ Integer ] The result of the comparison.
+      #
+      # @since 1.0.0
+      def <=>(other)
+        data <=> other.data
+      end
+
+      # Get the raw data (bytes) for the object id.
+      #
+      # @example Get the raw data.
+      #   object_id.data
+      #
+      # @return [ String ] The raw bytes.
+      #
+      # @since 1.0.0
       def data
         # If @data is defined, then we know we've been loaded in some
         # non-standard way, so we attempt to repair the data.
         repair! @data if defined? @data
-
         @raw_data ||= @@generator.next
       end
 
-      def ==(other)
-        BSON::ObjectId === other && data == other.data
-      end
-      alias eql? ==
-
-      def <=>(other)
-        data <=> other.data
+      # Return the UTC time at which this ObjectId was generated. This may
+      # be used instread of a created_at timestamp since this information
+      # is always encoded in the object id.
+      #
+      # @example Get the generation time.
+      #   object_id.generation_time
+      #
+      # @return [ Time ] The time the id was generated.
+      #
+      # @since 1.0.0
+      def generation_time
+        Time.at(data.unpack("N")[0]).utc
       end
 
+      # 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.hash
       end
 
-      def to_s
-        data.unpack("H*")[0]
-      end
-      alias :to_str :to_s
-
+      # Gets the string inspection for the object.
+      #
+      # @example Get the string inspection.
+      #   object.inspect
+      #
+      # @return [ String ] The inspection.
+      #
+      # @since 1.0.0
       def inspect
         to_s.inspect
       end
 
+      # Dump the object for use in a marshal dump.
+      #
+      # @example Dump the object.
+      #   object.marshal_dump
+      #
+      # @return [ String ] The dumped object.
+      #
+      # @since 1.0.0
+      def marshal_dump
+        data
+      end
+
+      # Load the object from the marshal dump.
+      #
+      # @example Load the object.
+      #   object.marshal_load("")
+      #
+      # @param [ String ] data The raw data.
+      #
+      # @since 1.0.0
+      def marshal_load(data)
+        self.data = data
+      end
+
+      # Convert the object to a JSON string.
+      #
+      # @example Convert to a JSON string.
+      #   obejct.to_json
+      #
+      # @return [ String ] The object as JSON.
+      #
+      # @since 1.0.0
       def to_json(*args)
         "{\"$oid\": \"#{to_s}\"}"
       end
 
-      # Return the UTC time at which this ObjectId was generated. This may
-      # be used instread of a created_at timestamp since this information
-      # is always encoded in the object id.
-      def generation_time
-        Time.at(data.unpack("N")[0]).utc
+      # 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.unpack("H*")[0].force_encoding(UTF8_ENCODING)
+      end
+      alias :to_str :to_s
+
+      private
+
+      # Private interface for setting the internal data for an object id.
+      def data=(data)
+        @raw_data = data
+      end
+
+      # Attempts to repair ObjectId data marshalled in previous formats.
+      #
+      # The first check covers an ObjectId generated by the mongo-ruby-driver.
+      #
+      # The second check covers an ObjectId generated by moped before a custom
+      # marshal strategy was added.
+      def repair!(data)
+        if data.is_a?(Array) && data.size == 12
+          self.data = data.pack("C*")
+        elsif data.is_a?(String) && data.size == 12
+          self.data = data
+        else
+          raise TypeError, "Could not convert #{data.inspect} into an ObjectId"
+        end
       end
 
       class << self
+
         def __bson_load__(io)
           from_data(io.read(12))
         end
-      end
 
-      def __bson_dump__(io, key)
-        io << Types::OBJECT_ID
-        io << key.to_bson_cstring
-        io << data
+        # Create a new object id from a string.
+        #
+        # @example Create an object id from the string.
+        #   Moped::BSON::ObjectId.from_string(id)
+        #
+        # @param [ String ] string The string to create from.
+        #
+        # @return [ ObjectId ] The new object id.
+        #
+        # @since 1.0.0
+        def from_string(string)
+          raise Errors::InvalidObjectId.new(string) unless legal?(string)
+          from_data [string].pack("H*")
+        end
+
+        # Create a new object id from a time.
+        #
+        # @example Create an object id from a time.
+        #   Moped::BSON::ObjectId.from_id(time)
+        #
+        # @example Create an object id from a time, ensuring uniqueness.
+        #   Moped::BSON::ObjectId.from_id(time, unique: true)
+        #
+        # @param [ Time ] time The time to generate from.
+        # @param [ Hash ] options The options.
+        #
+        # @option options [ true, false ] :unique Whether the id should be
+        #   unique.
+        #
+        # @return [ ObjectId ] The new object id.
+        #
+        # @since 1.0.0
+        def from_time(time, options = nil)
+          unique = (options || {})[:unique]
+          from_data(unique ? @@generator.next(time.to_i) : [ time.to_i ].pack("Nx8"))
+        end
+
+        # Determine if the string is a legal object id.
+        #
+        # @example Is the string a legal object id?
+        #   Moped::BSON::ObjectId.legal?(string)
+        #
+        # @param [ String ] The string to test.
+        #
+        # @return [ true, false ] If the string is legal.
+        #
+        # @since 1.0.0
+        def legal?(string)
+          /\A\h{24}\Z/ === string.to_s
+        end
+
+        # Create a new object id from some raw data.
+        #
+        # @example Create an object id from raw data.
+        #   Moped::BSON::ObjectId.from_data(data)
+        #
+        # @param [ String ] data The raw bytes.
+        #
+        # @return [ ObjectId ] The new object id.
+        #
+        # @since 1.0.0
+        def from_data(data)
+          id = allocate
+          id.send(:data=, data)
+          id
+        end
       end
 
       # @api private
@@ -98,7 +277,7 @@ module Moped
 
         # Return object id data based on the current time, incrementing the
         # object id counter.
-        def next
+        def next(time = nil)
           @mutex.lock
           begin
             counter = @counter = (@counter + 1) % 0xFFFFFF
@@ -106,7 +285,7 @@ module Moped
             @mutex.unlock rescue nil
           end
 
-          generate(Time.new.to_i, counter)
+          generate(time || Time.new.to_i, counter)
         end
 
         # Generate object id data for a given time using the provided +counter+.
@@ -117,39 +296,6 @@ module Moped
       end
 
       @@generator = Generator.new
-
-      # @private
-      def marshal_dump
-        data
-      end
-
-      # @private
-      def marshal_load(data)
-        self.data = data
-      end
-
-      private
-
-      # Attempts to repair ObjectId data marshalled in previous formats.
-      #
-      # The first check covers an ObjectId generated by the mongo-ruby-driver.
-      #
-      # The second check covers an ObjectId generated by moped before a custom
-      # marshal strategy was added.
-      def repair!(data)
-        if data.is_a?(Array) && data.size == 12
-          self.data = data.pack("C*")
-        elsif data.is_a?(String) && data.size == 12
-          self.data = data
-        else
-          raise TypeError, "Could not convert #{data.inspect} into an ObjectId"
-        end
-      end
-
-      # Private interface for setting the internal data for an object id.
-      def data=(data)
-        @raw_data = data
-      end
     end
   end
 end

data/lib/moped/bson/timestamp.rb

@@ -1,15 +1,38 @@
 module Moped
   module BSON
+
+    # A time representation in BSON.
     class Timestamp < Struct.new(:seconds, :increment)
+
+      # Serialize the time to the stream.
+      #
+      # @example Serialize the time.
+      #   time.__bson_dump__("", "created_at")
+      #
+      # @param [ String ] io The raw bytes.
+      # @param [ String ] key The field name.
+      #
+      # @since 1.0.0
+      def __bson_dump__(io, key)
+        io << [17, key, increment, seconds].pack('cZ*l2')
+      end
+
       class << self
+
+        # Deserialize the timestamp to an object.
+        #
+        # @example Deserialize the time.
+        #   Moped::BSON::Timestamp.__bson_load__(string)
+        #
+        # @param [ String ] io The raw bytes.
+        #
+        # @return [ Timestamp ] The time.
+        #
+        # @since 1.0.0
         def __bson_load__(io)
           new(*io.read(8).unpack('l2').reverse)
         end
       end
-
-      def __bson_dump__(io, key)
-        io << [17, key, increment, seconds].pack('cZ*l2')
-      end
     end
   end
 end

data/lib/moped/bson/types.rb

@@ -1,20 +1,21 @@
 module Moped
   module BSON
 
-    # @private
+    # Various BSON type behaviour.
     module Types
+
       class CodeWithScope
+
         def self.__bson_load__(io)
           io.read 4 # swallow the length
-
           code = io.read(*io.read(4).unpack(INT32_PACK)).from_utf8_binary.chop!
           scope = BSON::Document.deserialize(io)
-
-          Code.new code, scope
+          Code.new(code, scope)
         end
       end
 
       class Integer64
+
         def self.__bson_load__(io)
           io.read(8).unpack(INT64_PACK)[0]
         end
@@ -61,7 +62,6 @@ module Moped
       MIN_KEY = 255.chr.freeze
 
       TRUE = 1.chr.freeze
-
     end
   end
 end

data/lib/moped/cluster.rb

@@ -100,6 +100,7 @@ module Moped
     def initialize(hosts, options)
       @seeds = hosts
       @nodes = hosts.map { |host| Node.new(host, options) }
+      @peers = []
 
       @options = {
         down_interval: 30,
@@ -135,7 +136,9 @@ module Moped
 
       # Now return all the nodes that are available and participating in the
       # replica set.
-      available.reject { |node| node.down? || (!opts[:include_arbiters] && node.arbiter?) }
+      available.reject do |node|
+        node.down? || !member?(node) || (!opts[:include_arbiters] && node.arbiter?)
+      end
     end
 
     # Refreshes information for each of the nodes provided. The node list
@@ -170,10 +173,11 @@ module Moped
             # This node is good, so add it to the list of nodes to return.
             refreshed_nodes << node unless refreshed_nodes.include?(node)
 
-            # Now refresh any newly discovered peer nodes.
-            (node.peers - @nodes).each(&refresh_node) if node.peers
+            # Now refresh any newly discovered peer nodes - this will also
+            # remove nodes that are not included in the peer list.
+            refresh_peers(node, &refresh_node)
           rescue Errors::ConnectionFailure
-            # We couldn't connect to the node, so don't do anything with it.
+            # We couldn't connect to the node.
           end
         end
       end
@@ -273,5 +277,18 @@ module Moped
     def initialize_copy(_)
       @nodes = @nodes.map(&:dup)
     end
+
+    def member?(node)
+      @peers.empty? || @peers.include?(node)
+    end
+
+    def refresh_peers(node, &block)
+      peers = node.peers
+      return if peers.empty?
+      peers.each do |node|
+        block.call(node) unless @nodes.include?(node)
+        @peers.push(node) unless peers.include?(node)
+      end
+    end
   end
 end