Method validate! has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

      def validate!
        if !@tag_sets.all? { |set| set.empty? } && !tags_allowed?
          raise Error::InvalidServerPreference.new(Error::InvalidServerPreference::NO_TAG_SUPPORT)
        elsif @max_staleness && !max_staleness_allowed?
          raise Error::InvalidServerPreference.new(Error::InvalidServerPreference::NO_MAX_STALENESS_SUPPORT)

• Read up
  Read up

Method add_read_preference_legacy has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

      def add_read_preference_legacy(sel, connection)
        if read && (
          connection.description.mongos? || connection.description.load_balancer?
        ) && read_pref = read.to_mongos
          # If the read preference contains only mode and mode is secondary

• Read up
  Read up

Method parse_password! has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def parse_password!(string)
      if (string && pwd = string.partition(AUTH_USER_PWD_DELIM)[2])
        if pwd.length > 0
          raise_invalid_error!(UNESCAPED_USER_PWD) if pwd =~ UNSAFE
          pwd_decoded = decode(pwd)

• Read up
  Read up

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

Open

      def initialize(replies, connection_description = nil, connection_global_id = nil)
        if replies
          if replies.is_a?(Array)
            if replies.length != 1
              raise ArgumentError, "Only one (or zero) reply is supported, given #{replies.length}"

• Read up
  Read up

Method to_document has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

        def to_document
          BSON::Document.new.tap do |bson|
            bson[:aws] = @aws.to_document if @aws
            bson[:azure] = @azure.to_document if @azure
            bson[:gcp] = @gcp.to_document if @gcp

• Read up
  Read up

Method initialize has a Cognitive Complexity of 10 (exceeds 5 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,

• Read up
  Read up

Method each has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def each
          # If the caching cursor is closed and was not fully iterated,
          # the documents we have in it are not the complete result set and
          # we have no way of completing that iteration.
          # Therefore, discard that cursor and start iteration again.

Method get_records has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def get_records(hostname, srv_service_name=nil, srv_max_hosts=nil)
        query_name = record_prefix(srv_service_name) + hostname
        resources = @resolver.getresources(query_name, Resolv::DNS::Resource::IN::SRV)

        # Collect all of the records into a Result object, raising an error

Method insert_one has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def insert_one(document, opts = {})
      QueryCache.clear_namespace(namespace)

      client.with_session(opts) do |session|
        write_concern = if opts[:write_concern]

Method update_options has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def update_options(new_options)
      old_options = @options

      new_options = self.class.canonicalize_ruby_options(new_options || {})

Method close has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def close(options = nil)
        return if closed?

        options ||= {}

Method stale_primary? has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def stale_primary?
      if updated_desc.max_wire_version >= 17
        if updated_desc.election_id.nil? && !topology.max_election_id.nil?
          return true
        end

Method count has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def count(opts = {})
          opts = @options.merge(opts) unless Mongo.broken_view_options
          cmd = { :count => collection.name, :query => filter }
          cmd[:skip] = opts[:skip] if opts[:skip]
          cmd[:hint] = opts[:hint] if opts[:hint]

Method initialize has 8 arguments (exceeds 4 allowed). Consider refactoring.

Open

        def initialize(command_name, database_name, address,
          request_id, operation_id, message, failure, duration,
          started_event:, server_connection_id: nil, service_id: nil

Method execute_operation has 8 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def execute_operation(name, values, connection, context, operation_id, result_combiner, session, txn_num = nil)

Method split_execute has 8 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def split_execute(name, values, connection, context, operation_id, result_combiner, session, txn_num)

Method check has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

      def check
        @lock.synchronize do
          if @connection && @connection.pid != Process.pid
            log_warn("Detected PID change - Mongo client should have been reconnected (old pid #{@connection.pid}, new pid #{Process.pid}")
            @connection.disconnect!

• Read up
  Read up

Method update_options has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def update_options(new_options)
      old_options = @options

      new_options = self.class.canonicalize_ruby_options(new_options || {})

• Read up
  Read up

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

Open

      def initialize(options)
        @database = options[:database] || Database::ADMIN
        @auth_source = options[:auth_source] || self.class.default_auth_source(options)
        @name = options[:user]
        @password = options[:password] || options[:pwd]

• Read up
  Read up

Method unknown! has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def unknown!(options = {})
      pool = pool_internal

      if load_balancer?
        # When the client is in load-balanced topology, servers (the one and

• Read up
  Read up