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

Open

    def enqueue_all(event)
      info do
        jobs = event.payload[:jobs]
        adapter = event.payload[:adapter]
        enqueued_count = event.payload[:enqueued_count]

• Read up
  Read up

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

Open

          def index_name_for_remove(table_name, column_name, options)
            index_name = connection.index_name(table_name, column_name || options)

            unless connection.index_name_exists?(table_name, index_name)
              if options.key?(:name)

• Read up
  Read up

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

Open

        def create_table(table_name, **options)
          if connection.adapter_name == "PostgreSQL"
            if options[:id] == :uuid && !options.key?(:default)
              options[:default] = "uuid_generate_v4()"
            end

• Read up
  Read up

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

Open

      def fetch_multi(*names)
        raise ArgumentError, "Missing block: `Cache#fetch_multi` requires a block." unless block_given?
        return {} if names.empty?

        options = names.extract_options!

• Read up
  Read up

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

Open

        def change_column(table_name, column_name, type, **options)
          if connection.adapter_name == "PostgreSQL"
            super(table_name, column_name, type, **options.except(:default, :null, :comment))
            connection.change_column_default(table_name, column_name, options[:default]) if options.key?(:default)
            connection.change_column_null(table_name, column_name, options[:null], options[:default]) if options.key?(:null)

• Read up
  Read up

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

Open

        def write_serialized_entry(key, payload, raw: false, unless_exist: false, expires_in: nil, race_condition_ttl: nil, pipeline: nil, **options)
          # If race condition TTL is in use, ensure that cache entries
          # stick around a bit longer after they would have expired
          # so we can purposefully serve stale entries.
          if race_condition_ttl && expires_in && expires_in > 0 && !raw

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                  if attribute == "id"
                    value.id_value
                  else
                    value.public_send(attribute)
                  end

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

Open

      def dump_compressed(entry, threshold)
        return @serializer.dump_compressed(entry, threshold) if @legacy_serializer

        # If value is a string with a supported encoding, use it as the payload
        # instead of passing it through the serializer.

• Read up
  Read up

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

Open

      def assert_difference(expression, *args, &block)
        expressions =
          if expression.is_a?(Hash)
            message = args[0]
            expression

• Read up
  Read up

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

Open

        def read_multi_entries(names, **options)
          keys_to_names = names.index_by { |name| normalize_key(name, options) }

          raw_values = begin
            @data.with { |c| c.get_multi(keys_to_names.keys) }

• Read up
  Read up

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

Open

    def append_features(base) # :nodoc:
      if base.instance_variable_defined?(:@_dependencies)
        base.instance_variable_get(:@_dependencies) << self
        false
      else

• Read up
  Read up

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

Open

      def execute_callstack_for_multiparameter_attributes(callstack)
        errors = []
        callstack.each do |name, values_with_empty_parameters|
          if values_with_empty_parameters.each_value.all?(NilClass)
            values = nil

• Read up
  Read up

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

Open

    def prepended(base = nil, &block)
      if base.nil?
        if instance_variable_defined?(:@_prepended_block)
          if @_prepended_block.source_location != block.source_location
            raise MultiplePrependBlocks

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                  rescue DeserializationError
                    entry = nil

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

Open

    def parameterize(string, separator: "-", preserve_case: false, locale: nil)
      # Replace accented chars with their ASCII equivalents.
      parameterized_string = transliterate(string, locale: locale)

      # Turn unwanted chars into the separator.

• Read up
  Read up

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

Open

        def to_hash(hash = {})
          node_hash = {}

          # Insert node hash into parent hash correctly.
          case hash[name]

• Read up
  Read up

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

Open

        def configure(primary_key: nil, deterministic_key: nil, key_derivation_salt: nil, **properties) # :nodoc:
          config.primary_key = primary_key
          config.deterministic_key = deterministic_key
          config.key_derivation_salt = key_derivation_salt

• Read up
  Read up

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

Open

      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [], returning: nil)

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

Open

      def define_delegated_type_methods(role, types:, options:)
        primary_key = options[:primary_key] || "id"
        role_type = options[:foreign_type] || "#{role}_type"
        role_id   = options[:foreign_key] || "#{role}_id"

• Read up
  Read up

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

Open

          def reader_method(name, class_name, mapping, allow_nil, constructor)
            define_method(name) do
              if @aggregation_cache[name].nil? && (!allow_nil || mapping.any? { |key, _| !read_attribute(key).nil? })
                attrs = mapping.collect { |key, _| read_attribute(key) }
                object = constructor.respond_to?(:call) ?

• Read up
  Read up