mongo 2.18.2 → 2.19.3

data/lib/mongo/uri/options_mapper.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 # Copyright (C) 2020 MongoDB Inc.
 #
@@ -102,11 +102,7 @@ module Mongo
             uri_options
           end
 
-          if key == 'readConcernLevel'
-            value = value.to_sym
-          end
-
-          #value = apply_transform(key, value, strategy[:type])
+          value = apply_transform(key, value, strategy[:type])
           # Sometimes the value here would be nil, for example if we are processing
           # read preference tags or auth mechanism properties and all of the
           # data within is invalid. Ignore such options.
@@ -119,7 +115,6 @@ module Mongo
           end
         end
 
-        #p uri_options
         uri_options
       end
 
@@ -138,8 +133,51 @@ module Mongo
             v = opts[spec[:name]]
           end
           unless v.nil?
-            if spec[:type]
-              v = send("revert_#{spec[:type]}", v)
+            if type = spec[:type]
+              v = send("revert_#{type}", v)
+            end
+            canonical_key = URI_OPTION_CANONICAL_NAMES[uri_key]
+            unless canonical_key
+              raise ArgumentError, "Option #{uri_key} is not known"
+            end
+            rv[canonical_key] = v
+          end
+        end
+        # For options that default to true, remove the value if it is true.
+        %w(retryReads retryWrites).each do |k|
+          if rv[k]
+            rv.delete(k)
+          end
+        end
+        # Remove auth source when it is $external for mechanisms that default
+        # (or require) that auth source.
+        if %w(MONGODB-AWS).include?(rv['authMechanism']) && rv['authSource'] == '$external'
+          rv.delete('authSource')
+        end
+        # ssl and tls are aliases, remove ssl ones
+        rv.delete('ssl')
+        # TODO remove authSource if it is the same as the database,
+        # requires this method to know the database specified in the client.
+        rv
+      end
+
+      # Converts Ruby options provided to their representation in a URI string.
+      #
+      # @param [ Hash ] opts Ruby options to convert.
+      #
+      # @return [ Hash ] URI string hash.
+      def ruby_to_string(opts)
+        rv = {}
+        URI_OPTION_MAP.each do |uri_key, spec|
+          if spec[:group]
+            v = opts[spec[:group]]
+            v = v && v[spec[:name]]
+          else
+            v = opts[spec[:name]]
+          end
+          unless v.nil?
+            if type = spec[:type]
+              v = send("stringify_#{type}", v)
             end
             canonical_key = URI_OPTION_CANONICAL_NAMES[uri_key]
             unless canonical_key
@@ -171,9 +209,9 @@ module Mongo
       # Applies URI value transformation by either using the default cast
       # or a transformation appropriate for the given type.
       #
-      # @param key [String] URI option name.
-      # @param value [String] The value to be transformed.
-      # @param type [Symbol] The transform method.
+      # @param [ String ] key URI option name.
+      # @param [ String ] value The value to be transformed.
+      # @param [ Symbol ] type The transform method.
       def apply_transform(key, value, type)
         if type
           send("convert_#{type}", key, value)
@@ -190,9 +228,9 @@ module Mongo
       # Specifically required to append an additional tag set
       # to the array of tag sets without overwriting the original.
       #
-      # @param target [Hash] The destination.
-      # @param value [Object] The value to be merged.
-      # @param name [Symbol] The name of the option.
+      # @param [ Hash ] target The destination.
+      # @param [ Object ] value The value to be merged.
+      # @param [ Symbol ] name The name of the option.
       def merge_uri_option(target, value, name)
         if target.key?(name)
           if REPEATABLE_OPTIONS.include?(name)
@@ -214,11 +252,11 @@ module Mongo
 
       # Simple internal dsl to register a MongoDB URI option in the URI_OPTION_MAP.
       #
-      # @param uri_key [String] The MongoDB URI option to register.
-      # @param name [Symbol] The name of the option in the driver.
-      # @param extra [Hash] Extra options.
-      #   * :group [Symbol] Nested hash where option will go.
-      #   * :type [Symbol] Name of function to transform value.
+      # @param [ String ] uri_key The MongoDB URI option to register.
+      # @param [ Symbol ] name The name of the option in the driver.
+      # @param [ Hash ] extra Extra options.
+      #   * :group [ Symbol ] Nested hash where option will go.
+      #   * :type [ Symbol ] Name of function to transform value.
       def self.uri_option(uri_key, name, **extra)
         URI_OPTION_MAP[uri_key.downcase] = { name: name }.update(extra)
         URI_OPTION_CANONICAL_NAMES[uri_key.downcase] = uri_key
@@ -247,6 +285,7 @@ module Mongo
       uri_option 'maxStalenessSeconds', :max_staleness, group: :read, type: :max_staleness
 
       # Pool options
+      uri_option 'maxConnecting', :max_connecting, type: :integer
       uri_option 'minPoolSize', :min_pool_size, type: :integer
       uri_option 'maxPoolSize', :max_pool_size, type: :integer
       uri_option 'waitQueueTimeoutMS', :wait_queue_timeout, type: :ms
@@ -290,14 +329,14 @@ module Mongo
       # Returns true for 'true', false for 'false', otherwise nil.
       #
       # @param [ String ] name Name of the URI option being processed.
-      # @param value [ String ] URI option value.
+      # @param [ String | true | false ] value URI option value.
       #
       # @return [ true | false | nil ] Converted value.
       def convert_bool(name, value)
         case value
-        when "true", 'TRUE'
+        when true, "true", 'TRUE'
           true
-        when "false", 'FALSE'
+        when false, "false", 'FALSE'
           false
         else
           log_warn("invalid boolean option for #{name}: #{value}")
@@ -305,31 +344,64 @@ module Mongo
         end
       end
 
+      # Reverts a boolean type.
+      #
+      # @param [ true | false | nil ] value The boolean to revert.
+      #
+      # @return [ true | false | nil ] The passed value.
       def revert_bool(value)
         value
       end
 
+      # Stringifies a boolean type.
+      #
+      # @param [ true | false | nil ] value The boolean.
+      #
+      # @return [ String | nil ] The string.
+      def stringify_bool(value)
+        revert_bool(value)&.to_s
+      end
+
       # Converts the value into a boolean and returns it wrapped in an array.
       #
-      # @param name [ String ] Name of the URI option being processed.
-      # @param value [ String ] URI option value.
+      # @param [ String ] name Name of the URI option being processed.
+      # @param [ String ] value URI option value.
       #
-      # @return [ Array<true | false> ] The boolean value parsed and wraped
+      # @return [ Array<true | false> | nil ] The boolean value parsed and wraped
       #   in an array.
       def convert_repeated_bool(name, value)
         [convert_bool(name, value)]
       end
 
+      # Reverts a repeated boolean type.
+      #
+      # @param [ Array<true | false> | true | false | nil ] value The repeated boolean to revert.
+      #
+      # @return [ Array<true | false> | true | false | nil ] The passed value.
       def revert_repeated_bool(value)
         value
       end
 
+      # Stringifies a repeated boolean type.
+      #
+      # @param [ Array<true | false> | nil ] value The repeated boolean.
+      #
+      # @return [ Array<true | false> | nil ] The string.
+      def stringify_repeated_bool(value)
+        rep = revert_repeated_bool(value)
+        if rep&.is_a?(Array)
+          rep.join(",")
+        else
+          rep
+        end
+      end
+
       # Parses a boolean value and returns its inverse.
       #
       # @param [ String ] name Name of the URI option being processed.
-      # @param value [ String ] The URI option value.
+      # @param [ String | true | false ] value The URI option value.
       #
-      # @return [ true | false | nil ] The inverse of the  boolean value parsed out, otherwise nil
+      # @return [ true | false | nil ] The inverse of the boolean value parsed out, otherwise nil
       #   (and a warning will be logged).
       def convert_inverse_bool(name, value)
         b = convert_bool(name, value)
@@ -341,20 +413,34 @@ module Mongo
         end
       end
 
+      # Reverts and inverts a boolean type.
+      #
+      # @param [ true | false | nil ] value The boolean to revert and invert.
+      #
+      # @return [ true | false | nil ] The inverted boolean.
       def revert_inverse_bool(value)
-        !value
+        value.nil? ? nil : !value
       end
 
-      # Converts +value+ into an integer.
+      # Inverts and stringifies a boolean.
+      #
+      # @param [ true | false | nil ] value The boolean.
+      #
+      # @return [ String | nil ] The string.
+      def stringify_inverse_bool(value)
+        revert_inverse_bool(value)&.to_s
+      end
+
+      # Converts +value+ into an integer. Only converts positive integers.
       #
       # If the value is not a valid integer, warns and returns nil.
       #
       # @param [ String ] name Name of the URI option being processed.
-      # @param value [ String ] URI option value.
+      # @param [ String | Integer ] value URI option value.
       #
       # @return [ nil | Integer ] Converted value.
       def convert_integer(name, value)
-        unless /\A\d+\z/ =~ value
+        if value.is_a?(String) && /\A\d+\z/ !~ value
           log_warn("#{value} is not a valid integer for #{name}")
           return nil
         end
@@ -362,78 +448,143 @@ module Mongo
         value.to_i
       end
 
+      # Reverts an integer.
+      #
+      # @param [ Integer | nil ] value The integer.
+      #
+      # @return [ Integer | nil ] The passed value.
       def revert_integer(value)
         value
       end
 
+      # Stringifies an integer.
+      #
+      # @param [ Integer | nil ] value The integer.
+      #
+      # @return [ String | nil ] The string.
+      def stringify_integer(value)
+        revert_integer(value)&.to_s
+      end
+
       # Ruby's convention is to provide timeouts in seconds, not milliseconds and
       # to use fractions where more precision is necessary. The connection string
       # options are always in MS so we provide an easy conversion type.
       #
       # @param [ String ] name Name of the URI option being processed.
-      # @param [ Integer ] value The millisecond value.
+      # @param [ String | Integer | Float ] value The millisecond value.
       #
       # @return [ Float ] The seconds value.
       #
       # @since 2.0.0
       def convert_ms(name, value)
-        unless /\A-?\d+(\.\d+)?\z/ =~ value
-          log_warn("Invalid ms value for #{name}: #{value}")
-          return nil
-        end
-
-        if value[0] == '-'
-          log_warn("#{name} cannot be a negative number")
-          return nil
+        case value
+        when String
+          if /\A-?\d+(\.\d+)?\z/ !~ value
+            log_warn("Invalid ms value for #{name}: #{value}")
+            return nil
+          end
+          if value.to_s[0] == '-'
+            log_warn("#{name} cannot be a negative number")
+            return nil
+          end
+        when Integer, Float
+          if value < 0
+            log_warn("#{name} cannot be a negative number")
+            return nil
+          end
+        else
+          raise ArgumentError, "Can only convert Strings, Integers, or Floats to ms. Given: #{value.class}"
         end
 
         value.to_f / 1000
       end
 
+      # Reverts an ms.
+      #
+      # @param [ Float ] value The float.
+      #
+      # @return [ Integer ] The number multiplied by 1000 as an integer.
       def revert_ms(value)
         (value * 1000).round
       end
 
+      # Stringifies an ms.
+      #
+      # @param [ Float ] value The float.
+      #
+      # @return [ String ] The string.
+      def stringify_ms(value)
+        revert_ms(value).to_s
+      end
+
       # Converts +value+ into a symbol.
       #
       # @param [ String ] name Name of the URI option being processed.
-      # @param value [ String ] URI option value.
+      # @param [ String | Symbol ] value URI option value.
       #
       # @return [ Symbol ] Converted value.
       def convert_symbol(name, value)
         value.to_sym
       end
 
+      # Reverts a symbol.
+      #
+      # @param [ Symbol ] value The symbol.
+      #
+      # @return [ String ] The passed value as a string.
       def revert_symbol(value)
         value.to_s
       end
+      alias :stringify_symbol :revert_symbol
 
       # Extract values from the string and put them into an array.
       #
       # @param [ String ] name Name of the URI option being processed.
       # @param [ String ] value The string to build an array from.
       #
-      # @return [ Array ] The array built from the string.
+      # @return [ Array<String> ] The array built from the string.
       def convert_array(name, value)
         value.split(',')
       end
 
+      # Reverts an array.
+      #
+      # @param [ Array<String> ] value An array of strings.
+      #
+      # @return [ Array<String> ] The passed value.
       def revert_array(value)
         value
       end
 
+      # Stringifies an array.
+      #
+      # @param [ Array<String> ] value An array of strings.
+      #
+      # @return [ String ] The array joined by commas.
+      def stringify_array(value)
+        value.join(',')
+      end
+
       # Authentication mechanism transformation.
       #
       # @param [ String ] name Name of the URI option being processed.
-      # @param value [String] The authentication mechanism.
+      # @param [ String ] value The authentication mechanism.
       #
-      # @return [Symbol] The transformed authentication mechanism.
+      # @return [ Symbol ] The transformed authentication mechanism.
       def convert_auth_mech(name, value)
-        (AUTH_MECH_MAP[value.upcase] || value).tap do |mech|
-          log_warn("#{value} is not a valid auth mechanism") unless mech
+        auth_mech = AUTH_MECH_MAP[value.upcase]
+        (auth_mech || value).tap do |mech|
+          log_warn("#{value} is not a valid auth mechanism") unless auth_mech
         end
       end
 
+      # Reverts auth mechanism.
+      #
+      # @param [ Symbol ] value The auth mechanism.
+      #
+      # @return [ String ] The auth mechanism as a string.
+      #
+      # @raise [ ArgumentError ] if its an invalid auth mechanism.
       def revert_auth_mech(value)
         found = AUTH_MECH_MAP.detect do |k, v|
           v == value
@@ -445,12 +596,21 @@ module Mongo
         end
       end
 
+      # Stringifies auth mechanism.
+      #
+      # @param [ Symbol ] value The auth mechanism.
+      #
+      # @return [ String | nil ] The auth mechanism as a string.
+      def stringify_auth_mech(value)
+        revert_auth_mech(value) rescue nil
+      end
+
       # Auth mechanism properties extractor.
       #
       # @param [ String ] name Name of the URI option being processed.
-      # @param value [ String ] The auth mechanism properties string.
+      # @param [ String ] value The auth mechanism properties string.
       #
-      # @return [ Hash ] The auth mechanism properties hash.
+      # @return [ Hash | nil ] The auth mechanism properties hash.
       def convert_auth_mech_props(name, value)
         properties = hash_extractor('authMechanismProperties', value)
         if properties
@@ -463,62 +623,101 @@ module Mongo
         properties
       end
 
+      # Reverts auth mechanism properties.
+      #
+      # @param [ Hash | nil ] value The auth mech properties.
+      #
+      # @return [ Hash | nil ] The passed value.
       def revert_auth_mech_props(value)
         value
       end
 
+      # Stringifies auth mechanism properties.
+      #
+      # @param [ Hash | nil ] value The auth mech properties.
+      #
+      # @return [ String | nil ] The string.
+      def stringify_auth_mech_props(value)
+        return if value.nil?
+        value.map { |k, v| "#{k}:#{v}" }.join(',')
+      end
+
       # Parses the max staleness value, which must be either "0" or an integer
       # greater or equal to 90.
       #
       # @param [ String ] name Name of the URI option being processed.
-      # @param value [ String ] The max staleness string.
+      # @param [ String | Integer ] value The max staleness string.
       #
       # @return [ Integer | nil ] The max staleness integer parsed out if it is valid, otherwise nil
       #   (and a warning will be logged).
       def convert_max_staleness(name, value)
-        if /\A-?\d+\z/ =~ value
-          int = value.to_i
+        int = if value.is_a?(String) && /\A-?\d+\z/ =~ value
+          value.to_i
+        elsif value.is_a?(Integer)
+          value
+        end
 
-          if int == -1
-            int = nil
-          end
+        if int.nil?
+          log_warn("Invalid max staleness value: #{value}")
+          return nil
+        end
 
-          if int && (int >= 0 && int < 90 || int < 0)
-            log_warn("max staleness should be either 0 or greater than 90: #{value}")
-            int = nil
-          end
+        if int == -1
+          int = nil
+        end
 
-          return int
+        if int && (int > 0 && int < 90 || int < 0)
+          log_warn("max staleness should be either 0 or greater than 90: #{value}")
+          int = nil
         end
 
-        log_warn("Invalid max staleness value: #{value}")
-        nil
+        int
       end
 
+      # Reverts max staleness.
+      #
+      # @param [ Integer | nil ] value The max staleness.
+      #
+      # @return [ Integer | nil ] The passed value.
       def revert_max_staleness(value)
         value
       end
 
+      # Stringifies max staleness.
+      #
+      # @param [ Integer | nil ] value The max staleness.
+      #
+      # @return [ String | nil ] The string.
+      def stringify_max_staleness(value)
+        revert_max_staleness(value)&.to_s
+      end
+
       # Read preference mode transformation.
       #
       # @param [ String ] name Name of the URI option being processed.
-      # @param value [String] The read mode string value.
+      # @param [ String ] value The read mode string value.
       #
-      # @return [Symbol] The read mode symbol.
+      # @return [ Symbol | String ] The read mode.
       def convert_read_mode(name, value)
         READ_MODE_MAP[value.downcase] || value
       end
 
+      # Reverts read mode.
+      #
+      # @param [ Symbol | String ] value The read mode.
+      #
+      # @return [ String ] The read mode as a string.
       def revert_read_mode(value)
         value.to_s.gsub(/_(\w)/) { $1.upcase }
       end
+      alias :stringify_read_mode :revert_read_mode
 
       # Read preference tags transformation.
       #
       # @param [ String ] name Name of the URI option being processed.
-      # @param value [String] The string representing tag set.
+      # @param [ String ] value The string representing tag set.
       #
-      # @return [Array<Hash>] Array with tag set.
+      # @return [ Array<Hash> | nil ] Array with tag set.
       def convert_read_tags(name, value)
         converted = convert_read_set(name, value)
         if converted
@@ -528,16 +727,30 @@ module Mongo
         end
       end
 
+      # Reverts read tags.
+      #
+      # @param [ Array<Hash> | nil ] value The read tags.
+      #
+      # @return [ Array<Hash> | nil ] The passed value.
       def revert_read_tags(value)
         value
       end
 
+      # Stringifies read tags.
+      #
+      # @param [ Array<Hash> | nil ] value The read tags.
+      #
+      # @return [ String | nil ] The joined string of read tags.
+      def stringify_read_tags(value)
+        value&.map { |ar| ar.map { |k, v| "#{k}:#{v}" }.join(',') }
+      end
+
       # Read preference tag set extractor.
       #
       # @param [ String ] name Name of the URI option being processed.
-      # @param value [String] The tag set string.
+      # @param [ String ] value The tag set string.
       #
-      # @return [Hash] The tag set hash.
+      # @return [ Hash ] The tag set hash.
       def convert_read_set(name, value)
         hash_extractor('readPreferenceTags', value)
       end
@@ -549,7 +762,7 @@ module Mongo
       # Otherwise returns the string +value+ unchanged.
       #
       # @param [ String ] name Name of the URI option being processed.
-      # @param value [ String ] URI option value.
+      # @param [ String | Integer ] value URI option value.
       #
       # @return [ Integer | Symbol | String ] Converted value.
       def convert_w(name, value)
@@ -563,6 +776,11 @@ module Mongo
         end
       end
 
+      # Reverts write concern.
+      #
+      # @param [ Integer | Symbol | String ] value The write concern.
+      #
+      # @return [ Integer | String ] The write concern as a string.
       def revert_w(value)
         case value
         when Symbol
@@ -572,34 +790,59 @@ module Mongo
         end
       end
 
+      # Stringifies write concern.
+      #
+      # @param [ Integer | Symbol | String ] value The write concern.
+      #
+      # @return [ String ] The write concern as a string.
+      def stringify_w(value)
+        revert_w(value)&.to_s
+      end
+
       # Parses the zlib compression level.
       #
       # @param [ String ] name Name of the URI option being processed.
-      # @param value [ String ] The zlib compression level string.
+      # @param [ String | Integer ] value The zlib compression level string.
       #
       # @return [ Integer | nil ] The compression level value if it is between -1 and 9 (inclusive),
       #   otherwise nil (and a warning will be logged).
       def convert_zlib_compression_level(name, value)
-        if /\A-?\d+\z/ =~ value
-          i = value.to_i
-
-          if i >= -1 && i <= 9
-            return i
-          end
+        i = if value.is_a?(String) && /\A-?\d+\z/ =~ value
+          value.to_i
+        elsif value.is_a?(Integer)
+          value
         end
 
-        log_warn("#{value} is not a valid zlibCompressionLevel")
-        nil
+        if i && (i >= -1 && i <= 9)
+          i
+        else
+          log_warn("#{value} is not a valid zlibCompressionLevel")
+          nil
+        end
       end
 
+      # Reverts zlib compression level
+      #
+      # @param [ Integer | nil ] value The write concern.
+      #
+      # @return [ Integer | nil ] The passed value.
       def revert_zlib_compression_level(value)
         value
       end
 
+      # Stringifies zlib compression level
+      #
+      # @param [ Integer | nil ] value The write concern.
+      #
+      # @return [ String | nil ] The string.
+      def stringify_zlib_compression_level(value)
+        revert_zlib_compression_level(value)&.to_s
+      end
+
       # Extract values from the string and put them into a nested hash.
       #
       # @param [ String ] name Name of the URI option being processed.
-      # @param value [ String ] The string to build a hash from.
+      # @param [ String ] value The string to build a hash from.
       #
       # @return [ Hash ] The hash built from the string.
       def hash_extractor(name, value)
@@ -619,8 +862,6 @@ module Mongo
           h
         end
       end
-
     end
-
   end
 end

data/lib/mongo/uri/srv_protocol.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 # Copyright (C) 2017-2020 MongoDB Inc.
 #