Method selector has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

          module_function def selector(spec, connection)
            if spec[:collation] && !connection.features.collation_enabled?
              raise Error::UnsupportedCollation
            end

• Read up
  Read up

Method aggregate_write_errors has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

        def aggregate_write_errors(count)
          return unless @replies
          @replies.reduce(nil) do |errors, reply|
            if write_errors = reply.documents.first['writeErrors']
              wes = write_errors.collect do |we|

• Read up
  Read up

Method initialize has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def initialize(user, used_mechanism: nil, message: nil,
        server: nil, code: nil
      )
        @code = code

• Read up
  Read up

Method delete_many has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

        def delete_many(opts = {})
          with_session(opts) do |session|
            write_concern = if opts[:write_concern]
              WriteConcern.get(opts[:write_concern])
            else

• Read up
  Read up

Method initialize has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def initialize(options)
        options = Options::Mapper.transform_keys_to_symbols(options)
        options = Options::Mapper.transform_values_to_strings(options).freeze

        if options[:w]

• Read up
  Read up

Method build_message has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def build_message(connection, context)
        if self.session != context.session
          if self.session
            raise Error::InternalDriverError, "Operation session #{self.session.inspect} does not match context session #{context.session.inspect}"
          else

• Read up
  Read up

Method reject! has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def reject!
        if block_given?
          n_keys = keys.size
          keys.each do |key|
            delete(key) if yield(key, self[key])

• Read up
  Read up

Method find_one_and_delete has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

        def find_one_and_delete(opts = {})
          with_session(opts) do |session|
            write_concern = if opts[:write_concern]
              WriteConcern.get(opts[:write_concern])
            else

• Read up
  Read up

Method legacy_write_with_retry has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def legacy_write_with_retry(server = nil, context:)
        session = context.session

        # This is the pre-session retry logic, and is not subject to
        # current retryable write specifications.

• Read up
  Read up

Method delete_one has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

        def delete_one(opts = {})
          with_session(opts) do |session|
            write_concern = if opts[:write_concern]
              WriteConcern.get(opts[:write_concern])
            else

• Read up
  Read up

Method modern_write_with_retry has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def modern_write_with_retry(session, server, context, &block)
        txn_num = nil
        connection_succeeded = false
        
        server.with_connection(connection_global_id: context.connection_global_id) do |connection|

• Read up
  Read up

Method commit_changes has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    def commit_changes
      # The application-visible sequence of events should be as follows:
      #
      # 1. Description change for the server which we are processing;
      # 2. Topology change, if any;

• Read up
  Read up

Method process has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    def process(result)
      unless implicit?
        set_operation_time(result)
        if cluster_time_doc = result.cluster_time
          advance_cluster_time(cluster_time_doc)

• Read up
  Read up

Method update_one has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def update_one(documents, connection, context, operation_id, session, txn_num)

Method initialize has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

        def initialize(kms_providers)
          if kms_providers.nil?
            raise ArgumentError.new("KMS providers options must not be nil")
          end
          if kms_providers.key?(:aws)

• Read up
  Read up

Method transform_server_api has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    module_function def transform_server_api(server_api)
      {}.tap do |doc|
        if version = server_api[:version]
          doc['apiVersion'] = version
        end

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                unless key.to_s.start_with?("$")
                  if Mongo.validate_update_replace
                    raise Error::InvalidUpdateDocument.new(key: key)
                  else
                    Error::InvalidUpdateDocument.warn(Logger.logger, key)

Method update_many has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def update_many(documents, connection, context, operation_id, session, txn_num)

Method insert_one has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def insert_one(documents, connection, context, operation_id, session, txn_num)

Method delete_one has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def delete_one(documents, connection, context, operation_id, session, txn_num)