File cache.rb has 559 lines of code (exceeds 250 allowed). Consider refactoring.

Open

require "zlib"
require "active_support/core_ext/array/extract_options"
require "active_support/core_ext/enumerable"
require "active_support/core_ext/module/attribute_accessors"
require "active_support/core_ext/numeric/bytes"

Class Store has 44 methods (exceeds 20 allowed). Consider refactoring.

Open

    class Store
      cattr_accessor :logger, instance_writer: true
      cattr_accessor :raise_on_invalid_cache_expiration_time, default: false

      attr_reader :silence, :options

Method fetch has a Cognitive Complexity of 34 (exceeds 5 allowed). Consider refactoring.

Open

      def fetch(name, options = nil, &block)
        if block_given?
          options = merged_options(options)
          key = normalize_key(name, options)

• Read up
  Read up

Method read has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring.

Open

      def read(name, options = nil)
        options = merged_options(options)
        key     = normalize_key(name, options)
        version = normalize_version(name, options)

• Read up
  Read up

Method retrieve_pool_options has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

          def retrieve_pool_options(options)
            if options.key?(:pool)
              pool_options = options.delete(:pool)
            elsif options.key?(:pool_size) || options.key?(:pool_timeout)
              pool_options = {}

• Read up
  Read up

Method merged_options has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

        def merged_options(call_options)
          if call_options
            call_options = normalize_options(call_options)
            if call_options.key?(:expires_in) && call_options.key?(:expires_at)
              raise ArgumentError, "Either :expires_in or :expires_at can be supplied, but not both"

• Read up
  Read up

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

Open

          def retrieve_pool_options(options)
            if options.key?(:pool)
              pool_options = options.delete(:pool)
            elsif options.key?(:pool_size) || options.key?(:pool_timeout)
              pool_options = {}

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

Open

      def fetch(name, options = nil, &block)
        if block_given?
          options = merged_options(options)
          key = normalize_key(name, options)

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

Open

      def initialize(options = nil)
        @options = options ? validate_options(normalize_options(options)) : {}

        @options[:compress] = true unless @options.key?(:compress)
        @options[:compress_threshold] ||= DEFAULT_COMPRESS_LIMIT

• Read up
  Read up

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

Open

      def read(name, options = nil)
        options = merged_options(options)
        key     = normalize_key(name, options)
        version = normalize_version(name, options)

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

Open

        def _instrument(operation, multi: false, options: nil, **payload, &block)
          if logger && logger.debug? && !silence?
            debug_key =
              if multi
                ": #{payload[:key].size} key(s) specified"

• 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

Avoid deeply nested control flow statements.

Open

                  rescue DeserializationError
                    entry = nil

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

Open

        def read_multi_entries(names, **options)
          names.each_with_object({}) do |name, results|
            key   = normalize_key(name, options)
            entry = read_entry(key, **options)

• Read up
  Read up

Method key_matcher has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

        def key_matcher(pattern, options) # :doc:
          prefix = options[:namespace].is_a?(Proc) ? options[:namespace].call : options[:namespace]
          if prefix
            source = pattern.source
            if source.start_with?("^")

• Read up
  Read up

Method expanded_key has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

        def expanded_key(key)
          return key.cache_key.to_s if key.respond_to?(:cache_key)

          case key
          when Array

• Read up
  Read up