mongo 2.22.0 → 2.24.0

data/lib/mongo/bulk_write/transformable.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2015-2020 MongoDB Inc.
 #
@@ -17,48 +16,46 @@
 
 module Mongo
   class BulkWrite
-
     # Defines behavior around transformations.
     #
     # @api private
     #
     # @since 2.1.0
     module Transformable
-
       # The delete many model constant.
       #
       # @since 2.1.0
-      DELETE_MANY = :delete_many.freeze
+      DELETE_MANY = :delete_many
 
       # The delete one model constant.
       #
       # @since 2.1.0
-      DELETE_ONE = :delete_one.freeze
+      DELETE_ONE = :delete_one
 
       # The insert one model constant.
       #
       # @since 2.1.0
-      INSERT_ONE = :insert_one.freeze
+      INSERT_ONE = :insert_one
 
       # The replace one model constant.
       #
       # @since 2.1.0
-      REPLACE_ONE = :replace_one.freeze
+      REPLACE_ONE = :replace_one
 
       # The update many model constant.
       #
       # @since 2.1.0
-      UPDATE_MANY = :update_many.freeze
+      UPDATE_MANY = :update_many
 
       # The update one model constant.
       #
       # @since 2.1.0
-      UPDATE_ONE = :update_one.freeze
+      UPDATE_ONE = :update_one
 
       # Proc to transform delete many ops.
       #
       # @since 2.1.0
-      DELETE_MANY_TRANSFORM = ->(doc){
+      DELETE_MANY_TRANSFORM = lambda { |doc|
         {
           Operation::Q => doc[:filter],
           Operation::LIMIT => 0,
@@ -71,7 +68,7 @@ module Mongo
       # Proc to transform delete one ops.
       #
       # @since 2.1.0
-      DELETE_ONE_TRANSFORM = ->(doc){
+      DELETE_ONE_TRANSFORM = lambda { |doc|
         {
           Operation::Q => doc[:filter],
           Operation::LIMIT => 1,
@@ -84,14 +81,14 @@ module Mongo
       # Proc to transform insert one ops.
       #
       # @since 2.1.0
-      INSERT_ONE_TRANSFORM = ->(doc){
+      INSERT_ONE_TRANSFORM = lambda { |doc|
         doc
       }
 
-      # Proc to transfor replace one ops.
+      # Proc to transform replace one ops.
       #
       # @since 2.1.0
-      REPLACE_ONE_TRANSFORM = ->(doc){
+      REPLACE_ONE_TRANSFORM = lambda { |doc|
         {
           Operation::Q => doc[:filter],
           Operation::U => doc[:replacement],
@@ -106,7 +103,7 @@ module Mongo
       # Proc to transform update many ops.
       #
       # @since 2.1.0
-      UPDATE_MANY_TRANSFORM = ->(doc){
+      UPDATE_MANY_TRANSFORM = lambda { |doc|
         {
           Operation::Q => doc[:filter],
           Operation::U => doc[:update],
@@ -122,7 +119,7 @@ module Mongo
       # Proc to transform update one ops.
       #
       # @since 2.1.0
-      UPDATE_ONE_TRANSFORM = ->(doc){
+      UPDATE_ONE_TRANSFORM = lambda { |doc|
         {
           Operation::Q => doc[:filter],
           Operation::U => doc[:update],
@@ -140,11 +137,11 @@ module Mongo
       # @since 2.1.0
       MAPPERS = {
         DELETE_MANY => DELETE_MANY_TRANSFORM,
-        DELETE_ONE  => DELETE_ONE_TRANSFORM,
-        INSERT_ONE  => INSERT_ONE_TRANSFORM,
+        DELETE_ONE => DELETE_ONE_TRANSFORM,
+        INSERT_ONE => INSERT_ONE_TRANSFORM,
         REPLACE_ONE => REPLACE_ONE_TRANSFORM,
         UPDATE_MANY => UPDATE_MANY_TRANSFORM,
-        UPDATE_ONE  => UPDATE_ONE_TRANSFORM
+        UPDATE_ONE => UPDATE_ONE_TRANSFORM
       }.freeze
 
       private

data/lib/mongo/bulk_write/unordered_combiner.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2015-2020 MongoDB Inc.
 #
@@ -17,15 +16,14 @@
 
 module Mongo
   class BulkWrite
-
     # Combines groups of bulk write operations in no order.
     #
     # @api private
     #
     # @since 2.1.0
     class UnorderedCombiner
-      include Transformable
       include Validatable
+      include Transformable
       include Combineable
 
       # Combine the requests in order.

data/lib/mongo/bulk_write/validatable.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2015-2020 MongoDB Inc.
 #
@@ -17,14 +16,12 @@
 
 module Mongo
   class BulkWrite
-
     # Defines behavior around validations.
     #
     # @api private
     #
     # @since 2.1.0
     module Validatable
-
       # Validate the document.
       #
       # @api private
@@ -43,33 +40,29 @@ module Mongo
       def validate(name, document)
         validate_operation(name)
         validate_document(name, document)
-        if document.respond_to?(:keys) && (document[:collation] || document[Operation::COLLATION])
-          @has_collation = true
-        end
+        @has_collation = true if document.respond_to?(:keys) && (document[:collation] || document[Operation::COLLATION])
 
-        if document.respond_to?(:keys) && document[:array_filters]
-          @has_array_filters = true
-        end
+        @has_array_filters = true if document.respond_to?(:keys) && document[:array_filters]
 
-        if document.respond_to?(:keys) && document[:hint]
-          @has_hint = true
-        end
+        return unless document.respond_to?(:keys) && document[:hint]
+
+        @has_hint = true
       end
 
       private
 
       def validate_document(name, document)
-        if document.respond_to?(:keys) || document.respond_to?(:data)
-          document
-        else
+        unless document.respond_to?(:keys) || document.respond_to?(:data)
           raise Error::InvalidBulkOperation.new(name, document)
         end
+
+        document
       end
 
       def validate_operation(name)
-        unless Transformable::MAPPERS.key?(name)
-          raise Error::InvalidBulkOperationType.new(name)
-        end
+        return if Transformable::MAPPERS.key?(name)
+
+        raise Error::InvalidBulkOperationType.new(name)
       end
     end
   end

data/lib/mongo/bulk_write.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
@@ -67,7 +66,7 @@ module Mongo
           context = Operation::Context.new(
             client: client,
             session: session,
-            operation_timeouts: { operation_timeout_ms: op_timeout_ms(deadline) }
+            operation_timeouts: operation_timeouts(deadline)
           )
           if single_statement?(operation)
             write_concern = write_concern(session)
@@ -80,10 +79,11 @@ module Mongo
                 operation_id,
                 result_combiner,
                 session,
-                txn_num)
+                txn_num
+              )
             end
           else
-            nro_write_with_retry(write_concern, context: context) do |connection, txn_num, context|
+            nro_write_with_retry(write_concern, context: context) do |connection, _txn_num, context|
               execute_operation(
                 operation.keys.first,
                 operation.values.flatten,
@@ -91,7 +91,8 @@ module Mongo
                 context,
                 operation_id,
                 result_combiner,
-                session)
+                session
+              )
             end
           end
         end
@@ -129,9 +130,9 @@ module Mongo
       @collection = collection
       @requests = requests
       @options = options || {}
-      if @options[:timeout_ms] && @options[:timeout_ms] < 0
-        raise ArgumentError, "timeout_ms options must be non-negative integer"
-      end
+      return unless @options[:timeout_ms] && @options[:timeout_ms] < 0
+
+      raise ArgumentError, 'timeout_ms options must be non-negative integer'
     end
 
     # Is the bulk write ordered?
@@ -159,16 +160,18 @@ module Mongo
     #
     # @since 2.1.0
     def write_concern(session = nil)
-      @write_concern ||= options[:write_concern] ?
-        WriteConcern.get(options[:write_concern]) :
-        collection.write_concern_with_session(session)
+      @write_concern ||= if options[:write_concern]
+                           WriteConcern.get(options[:write_concern])
+                         else
+                           collection.write_concern_with_session(session)
+                         end
     end
 
     private
 
-    SINGLE_STATEMENT_OPS = [ :delete_one,
-                             :update_one,
-                             :insert_one ].freeze
+    SINGLE_STATEMENT_OPS = %i[delete_one
+                              update_one
+                              insert_one].freeze
 
     # @return [ Float | nil ] Deadline for the batch of operations, if set.
     def calculate_deadline
@@ -182,6 +185,22 @@ module Mongo
       end
     end
 
+    # Returns the operation_timeouts hash for creating an Operation::Context.
+    # Uses operation_timeout_ms when the timeout was explicitly set on the
+    # bulk write, or inherited_timeout_ms when it comes from the collection
+    # or client. This distinction is important inside transactions where
+    # operation_timeout_ms is not allowed (RUBY-3685).
+    def operation_timeouts(deadline)
+      timeout = op_timeout_ms(deadline)
+      return {} if timeout.nil?
+
+      if @options[:timeout_ms]
+        { operation_timeout_ms: timeout }
+      else
+        { inherited_timeout_ms: timeout }
+      end
+    end
+
     # @param [ Float | nil ] deadline Deadline for the batch of operations.
     #
     # @return [ Integer | nil ] Timeout in milliseconds for the next operation.
@@ -201,24 +220,22 @@ module Mongo
 
     def base_spec(operation_id, session)
       {
-        :db_name => database.name,
-        :coll_name => collection.name,
-        :write_concern => write_concern(session),
-        :ordered => ordered?,
-        :operation_id => operation_id,
-        :bypass_document_validation => !!options[:bypass_document_validation],
-        :max_time_ms => options[:max_time_ms],
-        :options => options,
-        :id_generator => client.options[:id_generator],
-        :session => session,
-        :comment => options[:comment],
-        :let => options[:let],
+        db_name: database.name,
+        coll_name: collection.name,
+        write_concern: write_concern(session),
+        ordered: ordered?,
+        operation_id: operation_id,
+        bypass_document_validation: !!options[:bypass_document_validation],
+        max_time_ms: options[:max_time_ms],
+        options: options,
+        id_generator: client.options[:id_generator],
+        session: session,
+        comment: options[:comment],
+        let: options[:let],
       }
     end
 
     def execute_operation(name, values, connection, context, operation_id, result_combiner, session, txn_num = nil)
-      validate_collation!(connection)
-      validate_array_filters!(connection)
       validate_hint!(connection)
 
       unpin_maybe(session, connection) do
@@ -234,15 +251,12 @@ module Mongo
           end
         end
       end
-    # With OP_MSG (3.6+ servers), the size of each section in the message
+    # The size of each section in the message
     # is independently capped at 16m and each bulk operation becomes
     # its own section. The size of the entire bulk write is limited to 48m.
-    # With OP_QUERY (pre-3.6 servers), the entire bulk write is sent as a
-    # single document and is thus subject to the 16m document size limit.
-    # This means the splits differ between pre-3.6 and 3.6+ servers, with
-    # 3.6+ servers being able to split less.
     rescue Error::MaxBSONSize, Error::MaxMessageSize => e
       raise e if values.size <= 1
+
       unpin_maybe(session, connection) do
         split_execute(name, values, connection, context, operation_id, result_combiner, session, txn_num)
       end
@@ -253,7 +267,8 @@ module Mongo
     end
 
     def split_execute(name, values, connection, context, operation_id, result_combiner, session, txn_num)
-      execute_operation(name, values.shift(values.size / 2), connection, context, operation_id, result_combiner, session, txn_num)
+      execute_operation(name, values.shift(values.size / 2), connection, context, operation_id, result_combiner,
+                        session, txn_num)
 
       txn_num = session.next_txn_num if txn_num && !session.in_transaction?
       execute_operation(name, values, connection, context, operation_id, result_combiner, session, txn_num)
@@ -262,68 +277,51 @@ module Mongo
     def delete_one(documents, connection, context, operation_id, session, txn_num)
       QueryCache.clear_namespace(collection.namespace)
 
-      spec = base_spec(operation_id, session).merge(:deletes => documents, :txn_num => txn_num)
+      spec = base_spec(operation_id, session).merge(deletes: documents, txn_num: txn_num)
       Operation::Delete.new(spec).bulk_execute(connection, context: context)
     end
 
-    def delete_many(documents, connection, context, operation_id, session, txn_num)
+    def delete_many(documents, connection, context, operation_id, session, _txn_num)
       QueryCache.clear_namespace(collection.namespace)
 
-      spec = base_spec(operation_id, session).merge(:deletes => documents)
+      spec = base_spec(operation_id, session).merge(deletes: documents)
       Operation::Delete.new(spec).bulk_execute(connection, context: context)
     end
 
     def insert_one(documents, connection, context, operation_id, session, txn_num)
       QueryCache.clear_namespace(collection.namespace)
 
-      spec = base_spec(operation_id, session).merge(:documents => documents, :txn_num => txn_num)
+      spec = base_spec(operation_id, session).merge(documents: documents, txn_num: txn_num)
       Operation::Insert.new(spec).bulk_execute(connection, context: context)
     end
 
     def update_one(documents, connection, context, operation_id, session, txn_num)
       QueryCache.clear_namespace(collection.namespace)
 
-      spec = base_spec(operation_id, session).merge(:updates => documents, :txn_num => txn_num)
+      spec = base_spec(operation_id, session).merge(updates: documents, txn_num: txn_num)
       Operation::Update.new(spec).bulk_execute(connection, context: context)
     end
-    alias :replace_one :update_one
+    alias replace_one update_one
 
-    def update_many(documents, connection, context, operation_id, session, txn_num)
+    def update_many(documents, connection, context, operation_id, session, _txn_num)
       QueryCache.clear_namespace(collection.namespace)
 
-      spec = base_spec(operation_id, session).merge(:updates => documents)
+      spec = base_spec(operation_id, session).merge(updates: documents)
       Operation::Update.new(spec).bulk_execute(connection, context: context)
     end
 
-    private
-
-    def validate_collation!(connection)
-      if op_combiner.has_collation? && !connection.features.collation_enabled?
-        raise Error::UnsupportedCollation.new
-      end
-    end
-
-    def validate_array_filters!(connection)
-      if op_combiner.has_array_filters? && !connection.features.array_filters_enabled?
-        raise Error::UnsupportedArrayFilters.new
-      end
-    end
-
     def validate_hint!(connection)
-      if op_combiner.has_hint?
-        if !can_hint?(connection) && write_concern && !write_concern.acknowledged?
-          raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
-        elsif !connection.features.update_delete_option_validation_enabled?
-          raise Error::UnsupportedOption.hint_error
-        end
-      end
+      return unless op_combiner.has_hint?
+      return unless !can_hint?(connection) && write_concern && !write_concern.acknowledged?
+
+      raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
     end
 
     # Loop through the requests and check if each operation is allowed to send
     # a hint for each operation on the given server version.
     #
-    # For the following operations, the client can send a hint for servers >= 4.2
-    # and for the rest, the client can only send it for 4.4+:
+    # For the following operations, the client can send a hint for all supported
+    # server versions, and for the rest, the client can only send it for 4.4+:
     #   - updateOne
     #   - updateMany
     #   - replaceOne
@@ -333,16 +331,11 @@ module Mongo
     # @return [ true | false ] Whether the request is able to send hints for
     #   the current server version.
     def can_hint?(connection)
-      gte_4_2 = connection.server.description.server_version_gte?('4.2')
       gte_4_4 = connection.server.description.server_version_gte?('4.4')
       op_combiner.requests.all? do |req|
         op = req.keys.first
         if req[op].keys.include?(:hint)
-          if [:update_one, :update_many, :replace_one].include?(op)
-            gte_4_2
-          else
-            gte_4_4
-          end
+          %i[update_one update_many replace_one].include?(op) || gte_4_4
         else
           true
         end
@@ -368,32 +361,24 @@ module Mongo
       @requests.each do |req|
         requests_empty = false
         if op = req.keys.first
-          if [:update_one, :update_many].include?(op)
-            if doc = maybe_first(req.dig(op, :update))
-              if key = doc.keys&.first
-                unless key.to_s.start_with?("$")
-                  if Mongo.validate_update_replace
-                    raise Error::InvalidUpdateDocument.new(key: key)
-                  else
-                    Error::InvalidUpdateDocument.warn(Logger.logger, key)
-                  end
-                end
-              end
+          if %i[update_one update_many].include?(op)
+            if (doc = maybe_first(req.dig(op, :update))) && (key = doc.keys&.first) && !key.to_s.start_with?('$')
+              raise Error::InvalidUpdateDocument.new(key: key) if Mongo.validate_update_replace
+
+              Error::InvalidUpdateDocument.warn(Logger.logger, key)
+
             end
           elsif op == :replace_one
-            if key = req.dig(op, :replacement)&.keys&.first
-              if key.to_s.start_with?("$")
-                if Mongo.validate_update_replace
-                  raise Error::InvalidReplacementDocument.new(key: key)
-                else
-                  Error::InvalidReplacementDocument.warn(Logger.logger, key)
-                end
-              end
+            if (key = req.dig(op, :replacement)&.keys&.first) && key.to_s.start_with?('$')
+              raise Error::InvalidReplacementDocument.new(key: key) if Mongo.validate_update_replace
+
+              Error::InvalidReplacementDocument.warn(Logger.logger, key)
+
             end
           end
         end
       end.tap do
-        raise ArgumentError, "Bulk write requests cannot be empty" if requests_empty
+        raise ArgumentError, 'Bulk write requests cannot be empty' if requests_empty
       end
     end
 

data/lib/mongo/caching_cursor.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2020 MongoDB Inc.
 #
@@ -16,13 +15,11 @@
 # limitations under the License.
 
 module Mongo
-
   # A Cursor that attempts to load documents from memory first before hitting
   # the database if the same query has already been executed.
   #
   # @api semiprivate
   class CachingCursor < Cursor
-
     # @return [ Array <BSON::Document> ] The cursor's cached documents.
     # @api private
     attr_reader :cached_docs
@@ -34,11 +31,9 @@ module Mongo
     #   cursor.each do |doc|
     #     # ...
     #   end
-    def each
+    def each(&block)
       if @cached_docs
-        @cached_docs.each do |doc|
-          yield doc
-        end
+        @cached_docs.each(&block)
 
         unless closed?
           # StopIteration raised by try_next ends this loop.