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

Open

      def build_message
        errors = @result['writeErrors']
        return nil unless errors

        fragment = ""

• Read up
  Read up

Method find_one_and_delete has 35 lines of code (exceeds 25 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

Method parallel_scan has 35 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def parallel_scan(cursor_count, options = {})
          if options[:session]
            # The session would be overwritten by the one in +options+ later.
            session = client.send(:get_session, @options)
          else

Method deserialize has 35 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def self.deserialize(io,
        max_message_size = MAX_MESSAGE_SIZE,
        expected_response_to = nil,
        options = {}
      )

Method execute has 35 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def execute
      operation_id = Monitoring.next_operation_id
      result_combiner = ResultCombiner.new
      operations = op_combiner.combine
      validate_requests!

Method server_version_gte? has 34 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def server_version_gte?(version)
        required_wv = case version
          when '7.0'
            21
          when '6.0'

Method do_check_in has 34 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def do_check_in(connection)
        # When a connection is interrupted it is checked back into the pool
        # and closed. The operation that was using the connection before it was
        # interrupted will attempt to check it back into the pool, and we
        # should ignore it since its already been closed and removed from the pool.

Method run_sdam_flow has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def run_sdam_flow(previous_desc, updated_desc, options = {})
      if load_balanced?
        if updated_desc.config.empty?
          unless options[:keep_connection_pool]
            servers_list.each do |server|

Method handshake! has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def handshake!(speculative_auth_doc: nil)
        unless socket
          raise Error::InternalDriverError, "Cannot handshake because there is no usable socket (for #{address})"
        end

Method initialize has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

          def initialize(opts)
            @opts = opts
            return if empty?

            if opts[:access_token]

Method delete_one has 32 lines of code (exceeds 25 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

Method publish_heartbeat has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def publish_heartbeat(server, awaited: false)
      if monitoring?
        started_event = Event::ServerHeartbeatStarted.new(
          server.address, awaited: awaited)
        started(SERVER_HEARTBEAT, started_event)

Method initialize has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def initialize(kms_providers, kms_tls_options, options={})
        # FFI::AutoPointer uses a custom release strategy to automatically free
        # the pointer once this object goes out of scope
        @mongocrypt = FFI::AutoPointer.new(
          Binding.mongocrypt_new,

Method create_and_add_connection has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

      def create_and_add_connection
        connection = nil

        @lock.synchronize do
          if !closed? && @ready &&

• Read up
  Read up

Method do_clear has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

      def do_clear(options = nil)
        check_invariants

        service_id = options && options[:service_id]

• Read up
  Read up

Method close_available_connections has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

      def close_available_connections(service_id)
        if @server.load_balancer? && service_id
          loop do
            conn = @available_connections.detect do |conn|
              conn.service_id == service_id &&

• Read up
  Read up

Method validate_read! has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    def validate_read!(option, opts)
      if option == :read && opts.has_key?(:read)
        read = opts[:read]
        # We could check if read is a Hash, but this would fail
        # for custom classes implementing key access ([]).

• Read up
  Read up

Method deliver has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

      def deliver(message, context, options = {})
        if Lint.enabled? && !@socket
          raise Error::LintError, "Trying to deliver a message over a disconnected connection (to #{address})"
        end
        buffer = serialize(message, context)

• Read up
  Read up

Method suppress_read_write_concern! has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    def suppress_read_write_concern!(command)
      command.tap do |c|
        next unless in_transaction?

        c.delete(:readConcern) unless starting_transaction?

• Read up
  Read up

Method collections_info_spec has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

      def collections_info_spec(session, options = {})
        { selector: {
            listCollections: 1,
            cursor: batch_size ? { batchSize: batch_size } : {} },
          db_name: @database.name,

• Read up
  Read up