rubocop 1.71.1 → 1.92.0

data/lib/rubocop/config_store.rb

@@ -25,13 +25,18 @@ module RuboCop
       @validated = true
     end
 
+    def apply_options!(options)
+      self.options_config = options[:config] if options[:config]
+      force_default_config! if options[:force_default_config]
+    end
+
     def options_config=(options_config)
       loaded_config = ConfigLoader.load_file(options_config)
       @options_config = ConfigLoader.merge_with_default(loaded_config, options_config)
     end
 
     def force_default_config!
-      @options_config = ConfigLoader.default_configuration
+      @options_config = ConfigLoader.apply_default_overrides(ConfigLoader.default_configuration)
     end
 
     def unvalidated
@@ -44,7 +49,7 @@ module RuboCop
     end
 
     def for_pwd
-      for_dir(Dir.pwd)
+      for_dir(PathUtil.pwd)
     end
 
     # If type (file/dir) is known beforehand,

data/lib/rubocop/config_validator.rb

@@ -3,23 +3,25 @@
 module RuboCop
   # Handles validation of configuration, for example cop names, parameter
   # names, and Ruby versions.
-  # rubocop:disable Metrics/ClassLength
+  # rubocop:disable-next Metrics/ClassLength
   class ConfigValidator
     extend SimpleForwardable
 
     # @api private
     COMMON_PARAMS = %w[Exclude Include Severity inherit_mode AutoCorrect StyleGuide Details
-                       Enabled].freeze
+                       Enabled Reference References Safe SafeAutoCorrect].freeze
     # @api private
-    INTERNAL_PARAMS = %w[Description StyleGuide
+    INTERNAL_PARAMS = %w[Description StyleGuide Preview
                          VersionAdded VersionChanged VersionRemoved
-                         Reference Safe SafeAutoCorrect].freeze
+                         Reference References Safe SafeAutoCorrect].freeze
     # @api private
     NEW_COPS_VALUES = %w[pending disable enable].freeze
+    # @api private
+    NEW_COPS_VERSION_PATTERN = /\A\d+(\.\d+)*\z/.freeze
 
     # @api private
-    CONFIG_CHECK_KEYS = %w[Enabled Safe SafeAutoCorrect AutoCorrect].to_set.freeze
-    CONFIG_CHECK_DEPARTMENTS = %w[pending override_department].freeze
+    CONFIG_CHECK_KEYS = %w[Enabled Safe SafeAutoCorrect AutoCorrect References].to_set.freeze
+    CONFIG_CHECK_DEPARTMENTS = %w[pending preview override_department].freeze
     CONFIG_CHECK_AUTOCORRECTS = %w[always contextual disabled].freeze
     private_constant :CONFIG_CHECK_KEYS, :CONFIG_CHECK_DEPARTMENTS
 
@@ -46,7 +48,7 @@ module RuboCop
 
       check_obsoletions
       alert_about_unrecognized_cops(invalid_cop_names)
-      validate_new_cops_parameter
+      validate_all_cops_parameters
       validate_parameter_names(valid_cop_names)
       validate_enforced_styles(valid_cop_names)
       validate_syntax_cop
@@ -118,6 +120,7 @@ module RuboCop
       invalid_cop_names.each do |name|
         # There could be a custom cop with this name. If so, don't warn
         next if Cop::Registry.global.contains_cop_matching?([name])
+        next if ConfigObsoletion.deprecated_cop_name?(name)
 
         # Special case for inherit_mode, which is a directive that we keep in
         # the configuration (even though it's not a cop), because it's easier
@@ -163,16 +166,74 @@ module RuboCop
     end
 
     def validate_new_cops_parameter
+      validate_all_cops_new_cops_parameter
+      validate_department_new_cops_parameters
+    end
+
+    def validate_all_cops_parameters
+      validate_new_cops_parameter
+      validate_fail_level_parameter
+      validate_preview_parameter
+    end
+
+    def validate_fail_level_parameter
+      fail_level = @config.for_all_cops['FailLevel']
+      return if fail_level.nil? || Cop::Severity::NAMES.include?(fail_level.to_sym)
+
+      message = "invalid #{fail_level} for `FailLevel` found in #{smart_loaded_path}\n" \
+                "Valid choices are: #{Cop::Severity::NAMES.join(', ')}"
+
+      raise ValidationError, message
+    end
+
+    def validate_preview_parameter
+      preview = @config.for_all_cops['Preview']
+      return if [nil, true, false].include?(preview)
+
+      message = "invalid #{preview} for `Preview` found in #{smart_loaded_path}\n" \
+                'Valid choices are: true, false'
+
+      raise ValidationError, message
+    end
+
+    def validate_all_cops_new_cops_parameter
       new_cop_parameter = @config.for_all_cops['NewCops']
       return if new_cop_parameter.nil? || NEW_COPS_VALUES.include?(new_cop_parameter)
 
-      message = "invalid #{new_cop_parameter} for `NewCops` found in" \
+      message = "invalid #{new_cop_parameter} for `NewCops` found in " \
                 "#{smart_loaded_path}\n" \
                 "Valid choices are: #{NEW_COPS_VALUES.join(', ')}"
 
       raise ValidationError, message
     end
 
+    def validate_department_new_cops_parameters
+      @config.each do |name, section|
+        value = new_cops_value_for_department(name, section)
+        next if value.nil? || NEW_COPS_VALUES.include?(value) || new_cops_version_value?(value)
+
+        raise ValidationError,
+              "invalid #{value} for `NewCops` found in #{smart_loaded_path}\n" \
+              "Valid choices for a department are: #{NEW_COPS_VALUES.join(', ')}, " \
+              "or a version string like '1.50'"
+      end
+    end
+
+    def new_cops_value_for_department(name, section)
+      return nil if name == 'AllCops' || !section.is_a?(Hash)
+      return nil unless Cop::Registry.global.department?(name)
+
+      section['NewCops']
+    end
+
+    def new_cops_version_value?(value)
+      case value
+      when Float, Integer then true
+      when String then NEW_COPS_VERSION_PATTERN.match?(value)
+      else false
+      end
+    end
+
     def validate_parameter_shape(valid_cop_names)
       valid_cop_names.each do |name|
         if @config[name].nil?
@@ -206,6 +267,9 @@ module RuboCop
 
       @config[cop_name].each_key do |param|
         next if COMMON_PARAMS.include?(param) || default_config.key?(param)
+        # Departments shipped as top-level sections in an extension's default configuration accept
+        # `NewCops`, like any other department.
+        next if param == 'NewCops' && Cop::Registry.global.department?(cop_name)
 
         supported_params = default_config.keys - INTERNAL_PARAMS
 
@@ -259,8 +323,7 @@ module RuboCop
       end
     end
 
-    # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
-    def check_cop_config_value(hash, parent = nil)
+    def check_cop_config_value(hash, parent = nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       hash.each do |key, value|
         check_cop_config_value(value, key) if value.is_a?(Hash)
 
@@ -270,6 +333,8 @@ module RuboCop
           supposed_values = 'a boolean'
         elsif key == 'AutoCorrect' && !CONFIG_CHECK_AUTOCORRECTS.include?(value)
           supposed_values = '`always`, `contextual`, `disabled`, or a boolean'
+        elsif key == 'References'
+          supposed_values = 'an array of strings'
         else
           next
         end
@@ -277,7 +342,6 @@ module RuboCop
         raise ValidationError, param_error_message(parent, key, value, supposed_values)
       end
     end
-    # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
     # FIXME: Handling colors in exception messages like this is ugly.
     def param_error_message(parent, key, value, supposed_values)
@@ -286,5 +350,4 @@ module RuboCop
         "is supposed to be #{supposed_values} and #{Rainbow(value).yellow} is not."
     end
   end
-  # rubocop:enable Metrics/ClassLength
 end

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -12,6 +12,14 @@ module RuboCop
         autocorrect_requested? && disable_uncorrectable? && autocorrect_enabled?
       end
 
+      # Whether a correction exists but is skipped because it is unsafe in a
+      # safe autocorrect run, while `--disable-uncorrectable` asks for a todo
+      # comment on everything this run cannot correct.
+      def skipped_unsafe_correction_with_disable_uncorrectable?
+        autocorrect_requested? && disable_uncorrectable? &&
+          @options.fetch(:safe_autocorrect, false) && !safe_autocorrect?
+      end
+
       def autocorrect_requested?
         @options.fetch(:autocorrect, false)
       end
@@ -32,12 +40,9 @@ module RuboCop
         # allow turning off autocorrect on a cop by cop basis
         return true unless cop_config
 
-        # `false` is the same as `disabled` for backward compatibility.
-        return false if ['disabled', false].include?(cop_config['AutoCorrect'])
+        return false if disabled_autocorrect?
 
-        # When LSP is enabled, it is considered as editing source code,
-        # and autocorrection with `AutoCorrect: contextual` will not be performed.
-        return false if contextual_autocorrect? && LSP.enabled?
+        return false if contextual_autocorrect_held_back?
 
         # :safe_autocorrect is a derived option based on several command-line
         # arguments - see RuboCop::Options#add_autocorrection_options
@@ -48,9 +53,18 @@ module RuboCop
 
       private
 
+      # When LSP is enabled or the `--editor-mode` option is on, it is considered as editing
+      # source code, and autocorrection with `AutoCorrect: contextual` will not be performed.
+      # The `editing` option says the same without the rest of LSP mode, which
+      # is about showing offenses in an editor.
+      def contextual_autocorrect_held_back?
+        contextual_autocorrect? && (LSP.enabled? || @options.fetch(:editing, false))
+      end
+
       def disable_offense(offense_range)
         unbreakable_range = multiline_ranges(offense_range)&.find do |range|
-          range_overlaps_offense?(offense_range, range)
+          offense_range.overlaps?(range) &&
+            eol_comment_would_be_inside_literal?(offense_range, range)
         end
 
         if unbreakable_range
@@ -75,22 +89,28 @@ module RuboCop
       end
 
       def disable_offense_with_eol_or_surround_comment(range)
-        eol_comment = " # rubocop:todo #{cop_name}"
-        needed_line_length = (range.source_line + eol_comment).length
-
-        if needed_line_length <= max_line_length
-          disable_offense_at_end_of_line(range_of_first_line(range), eol_comment)
-        else
+        if line_with_eol_comment_too_long?(range)
           disable_offense_before_and_after(range_by_lines(range))
+        else
+          disable_offense_at_end_of_line(range_of_first_line(range))
         end
       end
 
-      def range_overlaps_offense?(offense_range, range)
-        offense_range.begin_pos > range.begin_pos && range.overlaps?(offense_range)
+      def eol_comment_would_be_inside_literal?(offense_range, literal_range)
+        return true if line_with_eol_comment_too_long?(offense_range)
+
+        offense_line = offense_range.line
+        offense_line >= literal_range.first_line && offense_line < literal_range.last_line
+      end
+
+      def line_with_eol_comment_too_long?(range)
+        return false unless max_line_length
+
+        (range.source_line + eol_comment).length > max_line_length
       end
 
       def surrounding_heredoc?(node)
-        node.type?(:str, :dstr, :xstr) && node.heredoc?
+        node.any_str_type? && node.heredoc?
       end
 
       def heredoc_range(node)
@@ -102,7 +122,7 @@ module RuboCop
       end
 
       def string_continuation?(node)
-        node.type?(:str, :dstr, :xstr) && node.source.match?(/\\\s*$/)
+        node.any_str_type? && node.source.match?(/\\\s*$/)
       end
 
       def multiline_string?(node)
@@ -129,13 +149,19 @@ module RuboCop
       end
 
       def max_line_length
+        return unless config.cop_enabled?('Layout/LineLength')
+
         config.for_cop('Layout/LineLength')['Max'] || 120
       end
 
-      def disable_offense_at_end_of_line(range, eol_comment)
+      def disable_offense_at_end_of_line(range)
         Corrector.new(range).insert_after(range, eol_comment)
       end
 
+      def eol_comment
+        " # rubocop:todo #{cop_name}"
+      end
+
       def disable_offense_before_and_after(range_by_lines)
         range_with_newline = range_by_lines.resize(range_by_lines.size + 1)
         leading_whitespace = range_by_lines.source_line[/^\s*/]

data/lib/rubocop/cop/badge.rb

@@ -45,13 +45,21 @@ module RuboCop
 
       def hash
         # Do hashing manually to reduce Array allocations.
-        department.hash ^ cop_name.hash # rubocop:disable Security/CompoundHash
+        department.hash ^ cop_name.hash # rubocop:disable Security/CompoundHash -- hashing manually avoids the Array allocation
       end
 
       def match?(other)
         cop_name == other.cop_name && (!qualified? || department == other.department)
       end
 
+      # Returns true if the badge's qualified name or the badge's department
+      # matches any of the given names.
+      def match_name?(given_names)
+        return false unless given_names
+
+        given_names.include?(to_s) || given_names.include?(department_name)
+      end
+
       def to_s
         @to_s ||= qualified? ? "#{department}/#{cop_name}" : cop_name
       end

data/lib/rubocop/cop/base.rb

@@ -41,6 +41,7 @@ module RuboCop
       include AutocorrectLogic
 
       attr_reader :config, :processed_source
+      attr_accessor :project_index
 
       # Reports of an investigation.
       # Immutable
@@ -48,7 +49,12 @@ module RuboCop
       InvestigationReport = Struct.new(:cop, :processed_source, :offenses, :corrector)
 
       # List of methods names to restrict calls for `on_send` / `on_csend`
-      RESTRICT_ON_SEND = Set[].freeze # rubocop:disable InternalAffairs/UselessRestrictOnSend
+      RESTRICT_ON_SEND = Set[].freeze # rubocop:disable InternalAffairs/UselessRestrictOnSend -- the base class default, which cops override
+
+      # Departments whose cops report above `convention` unless a cop says
+      # otherwise. The exceptions live in `config/default.yml` as an explicit
+      # `Severity`, such as the lint-like cops in `Bundler` and `Gemspec`.
+      DEPARTMENT_SEVERITIES = { Lint: :warning, Security: :warning, Metrics: :refactor }.freeze
 
       # List of cops that should not try to autocorrect at the same
       # time as this cop
@@ -126,6 +132,8 @@ module RuboCop
       # in the `on_new_investigation` callback.
       # If your cop does autocorrections, be aware that your instance may be called
       # multiple times with the same `processed_source.path` but different content.
+      # Note that under `--parallel` each worker process has its own cop
+      # instances, so state persists only within a worker's share of the files.
       def self.support_multiple_source?
         false
       end
@@ -207,13 +215,9 @@ module RuboCop
         severity = find_severity(range_to_pass, severity)
         message = find_message(range_to_pass, message)
 
-        status, corrector = enabled_line?(range.line) ? correct(range, &block) : :disabled
-
-        # Since this range may be generated from Ruby code embedded in some
-        # template file, we convert it to location info in the original file.
-        range = range_for_original(range)
+        status, corrector = enabled_lines?(range) ? correct(range, &block) : :disabled
 
-        current_offenses << Offense.new(severity, range, message, name, status, corrector)
+        current_offenses << new_offense(range, severity, message, status, corrector)
       end
 
       # This method should be overridden when a cop's behavior depends
@@ -261,10 +265,21 @@ module RuboCop
         @config.target_ruby_version
       end
 
-      # Returns a gems locked versions (i.e. from Gemfile.lock or gems.locked)
-      # @returns [Gem::Version | nil] The locked gem version, or nil if the gem is not present.
+      # Returns the version of a gem in the target, by default its locked version
+      # (i.e. from Gemfile.lock or gems.locked).
+      #
+      # The requirements declared with `requires_gem` are checked against the version
+      # this method returns, so an extension that lets users state the version of its
+      # gem in `AllCops` (e.g. `TargetFrameworkVersion`) can override it for that gem,
+      # returning a `Gem::Version`, and fall back to `super` for any other gem.
+      #
+      # @param [String] gem_name
+      # @return [Gem::Version, nil] The gem version, or nil if the gem is not present.
+      #
+      # @api public
       def target_gem_version(gem_name)
-        @config.gem_versions_in_target && @config.gem_versions_in_target[gem_name]
+        gem_versions = @config.gem_versions_in_target
+        gem_versions && gem_versions[gem_name]
       end
 
       def parser_engine
@@ -283,6 +298,13 @@ module RuboCop
         @config.string_literals_frozen_by_default?
       end
 
+      # Whether the user opted in to unstable behavior, with `--preview` or
+      # `AllCops: Preview`. Cops branch on this to ship a change that is not
+      # ready to be the default yet.
+      def preview?
+        @config.preview?(@options)
+      end
+
       def relevant_file?(file)
         return false unless target_satisfies_all_gem_version_requirements?
         return true unless @config.clusivity_config_for_badge?(self.class.badge)
@@ -306,7 +328,9 @@ module RuboCop
       def ready
         return self if self.class.support_multiple_source?
 
-        self.class.new(@config, @options)
+        self.class.new(@config, @options).tap do |fresh|
+          fresh.project_index = @project_index
+        end
       end
 
       ### Reserved for Cop::Cop
@@ -319,7 +343,7 @@ module RuboCop
 
       ### Reserved for Commissioner
 
-      # rubocop:disable Layout/ClassStructure
+      # rubocop:disable Layout/ClassStructure -- grouped under the Commissioner heading above
       # @api private
       def callbacks_needed
         self.class.callbacks_needed
@@ -328,12 +352,11 @@ module RuboCop
       # @api private
       def self.callbacks_needed
         @callbacks_needed ||= public_instance_methods.select do |m|
-          # OPTIMIZE: Check method existence first to make fewer `start_with?` calls.
-          # At the time of writing this comment, this excludes 98 of ~104 methods.
-          # `start_with?` with two string arguments instead of a regex is faster
-          # in this specific case as well.
-          !Base.method_defined?(m) && # exclude standard "callbacks" like 'on_begin_investigation'
-            m.start_with?('on_', 'after_')
+          # OPTIMIZE: `start_with?` with two string arguments instead of a regex
+          # is faster in this specific case.
+          m.start_with?('on_', 'after_') &&
+            # exclude standard "callbacks" like 'on_new_investigation' unless refined
+            instance_method(m).owner != Base
         end
       end
       # rubocop:enable Layout/ClassStructure
@@ -364,12 +387,40 @@ module RuboCop
         cop_config.fetch('AutoCorrect', 'always') == 'contextual'
       end
 
+      # @api private
+      def disabled_autocorrect?
+        # `false` is the same as `'disabled'` for backward compatibility.
+        ['disabled', false].include?(cop_config['AutoCorrect'])
+      end
+
       def inspect # :nodoc:
         "#<#{self.class.name}:#{object_id} @config=#{@config} @options=#{@options}>"
       end
 
       private
 
+      ### Reserved for Commissioner
+
+      private_class_method def self.restrict_on_send
+        @restrict_on_send ||= self::RESTRICT_ON_SEND.to_a.freeze
+      end
+
+      # @return [Offense]
+      def new_offense(range, severity, message, status, corrector)
+        justification = suppression_reason(range) if status == :disabled
+
+        # Since this range may be generated from Ruby code embedded in some
+        # template file, we convert it to location info in the original file.
+        # A cop configured with `AutoCorrect: false` reports no edits, since
+        # nothing that honors the configuration applies them. The corrector
+        # stays, so an editor can still offer it as a quick fix to choose.
+        corrections = [] if corrector && disabled_autocorrect?
+
+        Offense.new(severity, range_for_original(range), message, name, status, corrector,
+                    justification: justification, correction_safe: safe_autocorrect?,
+                    corrections: corrections)
+      end
+
       ### Reserved for Cop::Cop
 
       def callback_argument(range)
@@ -398,10 +449,6 @@ module RuboCop
         @current_offenses ||= []
       end
 
-      private_class_method def self.restrict_on_send
-        @restrict_on_send ||= self::RESTRICT_ON_SEND.to_a.freeze
-      end
-
       EMPTY_OFFENSES = [].freeze
       private_constant :EMPTY_OFFENSES
       # Called to complete an investigation
@@ -416,7 +463,10 @@ module RuboCop
       ### Actually private methods
 
       def reset_investigation
-        @currently_disabled_lines = @current_offenses = @processed_source = @current_corrector = nil
+        @currently_disabled_lines = nil
+        @current_offenses = nil
+        @processed_source = nil
+        @current_corrector = nil
       end
 
       # @return [Symbol, Corrector] offense status
@@ -438,7 +488,12 @@ module RuboCop
       def use_corrector(range, corrector)
         if autocorrect?
           attempt_correction(range, corrector)
-        elsif corrector && (always_autocorrect? || (contextual_autocorrect? && !LSP.enabled?))
+        elsif skipped_unsafe_correction_with_disable_uncorrectable?
+          # The unsafe correction will not run, so the offense is
+          # uncorrectable for this run and gets a todo comment.
+          attempt_correction(range, nil)
+        elsif corrector && (always_autocorrect? ||
+                            (contextual_autocorrect? && !contextual_autocorrect_held_back?))
           :uncorrected
         else
           :unsupported
@@ -492,8 +547,23 @@ module RuboCop
         patterns = cop_config[parameter]
         return default_result unless patterns
 
-        patterns = FilePatterns.from(patterns)
-        patterns.match?(config.path_relative_to_config(file)) || patterns.match?(file)
+        file_patterns = FilePatterns.from(patterns)
+        relative_file_path = config.path_relative_to_config(file)
+        return true if file_patterns.match?(relative_file_path)
+
+        if parameter == 'Include' && !relative_file_path.start_with?('..')
+          matches_absolute_include_pattern?(patterns, file)
+        else
+          file_patterns.match?(file)
+        end
+      end
+
+      def matches_absolute_include_pattern?(patterns, file)
+        absolute_file_path = absolute?(file) ? file : File.expand_path(file)
+        patterns.any? do |pattern|
+          (absolute?(pattern.to_s) || pattern.to_s.start_with?('..')) &&
+            match_path?(pattern, absolute_file_path)
+        end
       end
 
       def enabled_line?(line_number)
@@ -502,12 +572,36 @@ module RuboCop
         @processed_source.comment_config.cop_enabled_at_line?(self, line_number)
       end
 
+      # A multi-line offense is suppressed by a directive on any line of its
+      # range, not only its first line, matching the intuition that the
+      # directive is attached to the offending code.
+      def enabled_lines?(range)
+        return true if @options[:ignore_disable_comments] || !@processed_source
+
+        comment_config = @processed_source.comment_config
+        comment_config.cop_enabled_at_lines?(self, range.first_line, range.last_line)
+      end
+
+      # The `--` reason on the directive that suppresses offenses on this
+      # range, or `nil` when the directive carries none.
+      def suppression_reason(range)
+        covering = covering_disabled_range(range)
+        covering.directive.reason if covering.respond_to?(:directive)
+      end
+
+      def covering_disabled_range(range)
+        disabled_ranges = @processed_source.comment_config.cop_disabled_line_ranges[cop_name]
+        disabled_ranges&.find do |disabled_range|
+          disabled_range.end >= range.first_line && disabled_range.begin <= range.last_line
+        end
+      end
+
       def find_severity(_range, severity)
         custom_severity || severity || default_severity
       end
 
       def default_severity
-        self.class.lint? ? :warning : :convention
+        DEPARTMENT_SEVERITIES.fetch(self.class.department, :convention)
       end
 
       def custom_severity
@@ -524,22 +618,21 @@ module RuboCop
       end
 
       def range_for_original(range)
+        buffer = @current_original.buffer
+        return range if @current_offset.zero? && range.source_buffer.equal?(buffer)
+
         ::Parser::Source::Range.new(
-          @current_original.buffer,
+          buffer,
           range.begin_pos + @current_offset,
           range.end_pos + @current_offset
         )
       end
 
       def target_satisfies_all_gem_version_requirements?
-        self.class.gem_requirements.all? do |gem_name, version_req|
-          all_gem_versions_in_target = @config.gem_versions_in_target
-          next false unless all_gem_versions_in_target
-
-          gem_version_in_target = all_gem_versions_in_target[gem_name]
-          next false unless gem_version_in_target
+        self.class.gem_requirements.all? do |gem_name, version_requirement|
+          gem_version = target_gem_version(gem_name)
 
-          version_req.satisfied_by?(gem_version_in_target)
+          gem_version && version_requirement.satisfied_by?(gem_version)
         end
       end
     end

data/lib/rubocop/cop/bundler/gem_comment.rb

@@ -81,7 +81,6 @@ module RuboCop
       #   gem 'bar', '< 2.1'
       #
       class GemComment < Base
-        include DefNode
         include GemDeclaration
 
         MSG = 'Missing gem description comment.'
@@ -128,8 +127,8 @@ module RuboCop
         end
 
         def ignored_gem?(node)
-          ignored_gems = Array(cop_config['IgnoredGems'])
-          ignored_gems.include?(node.first_argument.value)
+          allowed_gems = Array(cop_config['AllowedGems'])
+          allowed_gems.include?(node.first_argument.value)
         end
 
         def checked_options_present?(node)
@@ -163,7 +162,9 @@ module RuboCop
         def gem_options(node)
           return [] unless node.last_argument&.hash_type?
 
-          node.last_argument.keys.map(&:value)
+          # Only literal keys carry an option name to check; a non-literal key
+          # (e.g. a variable or method call) has no `value` and must be skipped.
+          node.last_argument.keys.filter_map { |key| key.value if key.type?(:sym, :str) }
         end
       end
     end