rubocop 1.86.1 → 1.87.0

data/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb

@@ -5,8 +5,10 @@ module RuboCop
     module Layout
       # Enforces empty line after guard clause.
       #
-      # This cop allows `# :nocov:` directive after guard clause because
-      # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+      # This cop allows a SimpleCov directive comment after guard clause because
+      # SimpleCov excludes code from the coverage report by wrapping it in such directives.
+      # Both the legacy `# :nocov:` comment and the newer `# simplecov:disable` /
+      # `# simplecov:enable` comments are recognized:
       #
       # [source,ruby]
       # ----
@@ -16,6 +18,13 @@ module RuboCop
       #   # :nocov:
       #   bar
       # end
+      #
+      # def foo
+      #   # simplecov:disable
+      #   return if condition
+      #   # simplecov:enable
+      #   bar
+      # end
       # ----
       #
       # Refer to SimpleCov's documentation for more details:
@@ -58,7 +67,7 @@ module RuboCop
 
         MSG = 'Add empty line after guard clause.'
         END_OF_HEREDOC_LINE = 1
-        SIMPLE_DIRECTIVE_COMMENT_PATTERN = /\A# *:nocov:\z/.freeze
+        SIMPLECOV_COMMENT_PATTERN = /\A#\s*(?::nocov:|simplecov\s*:\s*(?:disable|enable)\b)/.freeze
 
         # @!method guard_clause_branch?(node)
         def_node_matcher :guard_clause_branch?, <<~PATTERN
@@ -213,10 +222,10 @@ module RuboCop
           parent.begin_type? && same_line?(node, node.right_sibling)
         end
 
-        # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+        # SimpleCov excludes code from the coverage report by wrapping it in directive comments:
         # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
         def simplecov_directive_comment?(comment)
-          SIMPLE_DIRECTIVE_COMMENT_PATTERN.match?(comment.text)
+          SIMPLECOV_COMMENT_PATTERN.match?(comment.text)
         end
       end
     end

data/lib/rubocop/cop/layout/end_alignment.rb

@@ -19,10 +19,10 @@ module RuboCop
       #
       # This `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
       # by default. On the other hand, `Layout/BeginEndAlignment` cop aligns with
-      # `EnforcedStyleAlignWith: start_of_line` by default due to `||= begin` tends
+      # `EnforcedStyleAlignWith: start_of_line` by default because `||= begin` tends
       # to align with the start of the line. `Layout/DefEndAlignment` cop also aligns with
       # `EnforcedStyleAlignWith: start_of_line` by default.
-      # These style can be configured by each cop.
+      # These styles can be configured by each cop.
       #
       # @example EnforcedStyleAlignWith: keyword (default)
       #   # bad

data/lib/rubocop/cop/layout/indentation_width.rb

@@ -473,8 +473,12 @@ module RuboCop
         end
 
         def block_body_indentation_base(node, end_loc)
-          if style == :relative_to_receiver && dot_on_new_line?(node)
+          return end_loc unless style == :relative_to_receiver
+
+          if dot_on_new_line?(node)
             node.send_node.loc.dot
+          elsif selector_on_new_line?(node)
+            node.send_node.loc.selector
           else
             end_loc
           end
@@ -487,6 +491,14 @@ module RuboCop
           receiver = send_node.receiver
           receiver && receiver.last_line < send_node.loc.dot.line
         end
+
+        def selector_on_new_line?(node)
+          send_node = node.send_node
+          return false unless send_node.loc?(:dot) && send_node.loc?(:selector)
+
+          receiver = send_node.receiver
+          receiver && receiver.last_line < send_node.loc.selector.line
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb

@@ -124,7 +124,7 @@ module RuboCop
         def single_line_ignoring_receiver?(node)
           return false unless node.loc.begin && node.loc.end
 
-          node.loc.begin.line == node.loc.end.line
+          same_line?(node.loc.begin, node.loc.end)
         end
       end
     end

data/lib/rubocop/cop/layout/multiline_method_call_indentation.rb

@@ -158,7 +158,7 @@ module RuboCop
           @base = find_hash_pair_alignment_base(node)
           return false if !@base && inside_multiline_chain_arg?(node)
 
-          @base ||= lhs.source_range
+          @base ||= first_dot_alignment_base(node, rhs) || lhs.source_range
           return if aligned_with_first_line_dot?(node, rhs)
 
           calculate_column_delta_offense(rhs, @base.column)
@@ -172,6 +172,31 @@ module RuboCop
           first_call.loc.dot.join(first_call.loc.selector)
         end
 
+        def first_dot_alignment_base(node, rhs)
+          return unless rhs.source.start_with?('.', '&.')
+
+          first_call = first_call_has_a_dot(node)
+          dot = first_call.loc.dot
+          return unless dot
+          return if first_call == node
+
+          after_block_base = after_multiline_block_base(first_call, node)
+          return after_block_base if after_block_base
+
+          return unless same_line?(dot, first_call.receiver.source_range)
+
+          dot.join(first_call.loc.selector)
+        end
+
+        def after_multiline_block_base(first_call, node)
+          return unless first_call.block_node&.multiline?
+
+          after_block = first_call.block_node.parent
+          return unless after_block&.call_type? && after_block.loc?(:dot) && after_block != node
+
+          after_block.loc.dot.join(after_block.loc.selector)
+        end
+
         def inside_multiline_chain_arg?(node)
           enclosing_call = find_enclosing_chain_call(node)
           return false unless enclosing_call

data/lib/rubocop/cop/layout/redundant_line_break.rb

@@ -114,7 +114,9 @@ module RuboCop
 
         def other_cop_takes_precedence?(node)
           single_line_block_chain_enabled? && any_descendant?(node, :any_block) do |block_node|
-            block_node.parent.send_type? && block_node.parent.loc.dot && block_node.single_line?
+            next unless (parent = block_node.parent)
+
+            parent.call_type? && parent.loc.dot && block_node.single_line?
           end
         end
 

data/lib/rubocop/cop/layout/space_before_brackets.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Layout
       # Checks for space between the name of a receiver and a left
-      # brackets.
+      # bracket.
       #
       # @example
       #

data/lib/rubocop/cop/lint/ambiguous_block_association.rb

@@ -7,7 +7,7 @@ module RuboCop
       # when param passed without parentheses.
       #
       # This cop can customize allowed methods with `AllowedMethods`.
-      # By default, there are no methods to allowed.
+      # By default, there are no allowed methods.
       #
       # @example
       #

data/lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for overwriting an exception with an exception result by use ``rescue =>``.
+      # Checks for overwriting an exception with an exception result by using ``rescue =>``.
       #
       # You intended to write as `rescue StandardError`.
       # However, you have written `rescue => StandardError`.

data/lib/rubocop/cop/lint/constant_reassignment.rb

@@ -12,8 +12,13 @@ module RuboCop
       # class/module keyword definitions. It detects reassignment when a constant
       # is first defined one way and then redefined using the `NAME = value` syntax.
       #
-      # The cop cannot catch all offenses, like, for example, when a constant
-      # is reassigned in another file, or when using metaprogramming (`Module#const_set`).
+      # The cop cannot catch all offenses, like, for example, when using metaprogramming
+      # (`Module#const_set`).
+      #
+      # By default the cop also cannot detect reassignment across files.
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed,
+      # the cop additionally consults the project-wide index and reports reassignments
+      # whose previous definition lives in another file.
       #
       # The cop only takes into account constants assigned in a "simple" way: directly
       # inside class/module definition, or within another constant. Other type of assignments
@@ -74,7 +79,10 @@ module RuboCop
       #   end
       #
       class ConstantReassignment < Base
+        include ProjectIndexHelp
+
         MSG = 'Constant `%<constant>s` is already assigned in this namespace.'
+        CROSS_FILE_MSG = 'Constant `%<constant>s` is already assigned in `%<path>s`.'
 
         RESTRICT_ON_SEND = %i[remove_const].freeze
 
@@ -101,9 +109,14 @@ module RuboCop
           return unless simple_assignment?(node)
 
           name = fully_qualified_constant_name(node)
-          return constant_definitions[name] = :casgn unless constant_definitions.key?(name)
 
-          add_offense(node, message: format(MSG, constant: constant_display_name(node)))
+          if constant_definitions.key?(name)
+            add_offense(node, message: format(MSG, constant: constant_display_name(node)))
+            return
+          end
+
+          constant_definitions[name] = :casgn
+          report_cross_file_collision(node, name, constant_display_name(node))
         end
 
         def on_send(node)
@@ -192,6 +205,25 @@ module RuboCop
         def constant_definitions
           @constant_definitions ||= {}
         end
+
+        def report_cross_file_collision(node, fully_qualified_name, display_name)
+          return unless project_index
+          return unless (declaration = project_index[fully_qualified_name.delete_prefix('::')])
+          return unless (prior = prior_definition_in_other_file(declaration))
+
+          msg = format(CROSS_FILE_MSG, constant: display_name, path: prior.location.to_file_path)
+
+          add_offense(node, message: msg)
+        end
+
+        def prior_definition_in_other_file(declaration)
+          current = processed_source.file_path
+
+          declaration.definitions.find do |definition|
+            other = definition.location.to_file_path
+            !File.identical?(other, current)
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/constant_resolution.rb

@@ -13,12 +13,12 @@ module RuboCop
       #
       # Large projects will over time end up with one or two constant names that
       # are problematic because of a conflict with a library or just internally
-      # using the same name a namespace and a class. To avoid too many unnecessary
-      # offenses, Enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
+      # using the same name for a namespace and a class. To avoid too many unnecessary
+      # offenses, enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
       #
-      # NOTE: `Style/RedundantConstantBase` cop is disabled if this cop is enabled to prevent
-      # conflicting rules. Because it respects user configurations that want to enable
-      # this cop which is disabled by default.
+      # NOTE: `Style/RedundantConstantBase` cop is disabled if this cop is enabled,
+      # to prevent conflicting rules. This is because it respects user configurations
+      # that want to enable this cop which is disabled by default.
       #
       # @example
       #   # By default checks every constant

data/lib/rubocop/cop/lint/deprecated_constants.rb

@@ -14,7 +14,7 @@ module RuboCop
       #       Alternative: 'alternative_value'
       #       DeprecatedVersion: 'deprecated_version'
       #
-      # By default, `NIL`, `TRUE`, `FALSE`, `Net::HTTPServerException, `Random::DEFAULT`,
+      # By default, `NIL`, `TRUE`, `FALSE`, `Net::HTTPServerException`, `Random::DEFAULT`,
       # `Struct::Group`, and `Struct::Passwd` are configured.
       #
       # @example

data/lib/rubocop/cop/lint/erb_new_arguments.rb

@@ -23,7 +23,7 @@ module RuboCop
       # `ERB.new` with non-keyword arguments is deprecated since ERB 2.2.0.
       # Use `:trim_mode` and `:eoutvar` keyword arguments to `ERB.new`.
       # This cop identifies places where `ERB.new(str, trim_mode, eoutvar)` can
-      # be replaced by `ERB.new(str, :trim_mode: trim_mode, eoutvar: eoutvar)`.
+      # be replaced by `ERB.new(str, trim_mode: trim_mode, eoutvar: eoutvar)`.
       #
       # @example
       #   # Target codes supports Ruby 2.6 and higher only

data/lib/rubocop/cop/lint/missing_cop_enable_directive.rb

@@ -6,7 +6,7 @@ module RuboCop
     module Lint
       # Checks that there is an `# rubocop:enable ...` statement
       # after a `# rubocop:disable ...` statement. This will prevent leaving
-      # cop disables on wide ranges of code, that latter contributors to
+      # cop disables on wide ranges of code, that later contributors to
       # a file wouldn't be aware of.
       #
       # You can set `MaximumRangeSize` to define the maximum number of

data/lib/rubocop/cop/lint/multiple_comparison.rb

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Lint
       # In math and Python, we can use `x < y < z` style comparison to compare
-      # multiple value. However, we can't use the comparison in Ruby. However,
-      # the comparison is not syntax error. This cop checks the bad usage of
+      # multiple values. However, we can't use the comparison in Ruby. However,
+      # the comparison is not a syntax error. This cop checks the bad usage of
       # comparison operators.
       #
       # @example

data/lib/rubocop/cop/lint/non_deterministic_require_order.rb

@@ -12,7 +12,7 @@ module RuboCop
       # always sort the list.
       #
       # `Dir.glob` and `Dir[]` sort globbed results by default in Ruby 3.0.
-      # So all bad cases are acceptable when Ruby 3.0 or higher are used.
+      # So all bad cases are acceptable when Ruby 3.0 or higher is used.
       #
       # NOTE: This cop will be deprecated and removed when supporting only Ruby 3.0 and higher.
       #

data/lib/rubocop/cop/lint/number_conversion.rb

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Lint
-      # Warns the usage of unsafe number conversions. Unsafe
-      # number conversion can cause unexpected error if auto type conversion
-      # fails. Cop prefer parsing with number class instead.
+      # Warns against the usage of unsafe number conversions. Unsafe
+      # number conversion can cause an unexpected error if auto type conversion
+      # fails. The cop prefers parsing with a number class instead.
       #
       # Conversion with `Integer`, `Float`, etc. will raise an `ArgumentError`
       # if given input that is not numeric (eg. an empty string), whereas
@@ -14,10 +14,10 @@ module RuboCop
       # always correct to raise if a value is not numeric.
       #
       # NOTE: Some values cannot be converted properly using one of the `Kernel`
-      # method (for instance, `Time` and `DateTime` values are allowed by this
+      # methods (for instance, `Time` and `DateTime` values are allowed by this
       # cop by default). Similarly, Rails' duration methods do not work well
       # with `Integer()` and can be allowed with `AllowedMethods`. By default,
-      # there are no methods to allowed.
+      # there are no allowed methods.
       #
       # @safety
       #   Autocorrection is unsafe because it is not guaranteed that the

data/lib/rubocop/cop/lint/numbered_parameter_assignment.rb

@@ -16,7 +16,7 @@ module RuboCop
       #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
       #   -e:1: _1 is reserved for numbered parameter
       #
-      # NOTE: The parametered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10`
+      # NOTE: The numbered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10`
       # as well to prevent confusion.
       #
       # @example

data/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb

@@ -63,19 +63,9 @@ module RuboCop
         end
 
         def spaces_before_left_parenthesis(node)
-          receiver = node.receiver
-          receiver_length = if receiver
-                              receiver.source.length
-                            else
-                              0
-                            end
-          without_receiver = node.source[receiver_length..]
-
-          # Escape question mark if any.
-          method_regexp = Regexp.escape(node.method_name)
-
-          match = without_receiver.match(/^\s*&?\.?\s*#{method_regexp}(\s+)\(/)
-          match ? match.captures[0].length : 0
+          return 0 if node.parenthesized? || !node.first_argument.source.start_with?('(')
+
+          node.first_argument.source_range.begin_pos - node.loc.selector.end_pos
         end
 
         def space_range(expr, space_length)

data/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb

@@ -6,8 +6,8 @@ module RuboCop
       # Detects instances of rubocop:enable comments that can be
       # removed.
       #
-      # When comment enables all cops at once `rubocop:enable all`
-      # that cop checks whether any cop was actually enabled.
+      # When a comment enables all cops at once `rubocop:enable all`
+      # the cop checks whether any cop was actually enabled.
       #
       # @example
       #

data/lib/rubocop/cop/lint/redundant_type_conversion.rb

@@ -17,14 +17,14 @@ module RuboCop
       #   or with `String.new` or `String()`.
       # * `to_sym` when called on a symbol literal or interpolated symbol.
       # * `to_i` when called on an integer literal or with `Integer()`.
-      # * `to_f` when called on a float literal of with `Float()`.
+      # * `to_f` when called on a float literal or with `Float()`.
       # * `to_r` when called on a rational literal or with `Rational()`.
-      # * `to_c` when called on a complex literal of with `Complex()`.
+      # * `to_c` when called on a complex literal or with `Complex()`.
       # * `to_a` when called on an array literal, or with `Array.new`, `Array()` or `Array[]`.
       # * `to_h` when called on a hash literal, or with `Hash.new`, `Hash()` or `Hash[]`.
       # * `to_set` when called on `Set.new` or `Set[]`.
       #
-      # In all cases, chaining one same `to_*` conversion methods listed above is redundant.
+      # In all cases, chaining one of the same `to_*` conversion methods listed above is redundant.
       #
       # The cop can also register an offense for chaining conversion methods on methods that are
       # expected to return a specific type regardless of receiver (eg. `foo.inspect.to_s` and

data/lib/rubocop/cop/lint/require_relative_self_path.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for uses a file requiring itself with `require_relative`.
+      # Checks for a file requiring itself with `require_relative`.
       #
       # @example
       #
@@ -38,6 +38,8 @@ module RuboCop
         private
 
         def same_file?(file_path, required_feature)
+          return false unless File.extname(file_path) == '.rb'
+
           file_path == required_feature || remove_ext(file_path) == required_feature
         end
 

data/lib/rubocop/cop/lint/shadowed_exception.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for a rescued exception that get shadowed by a
+      # Checks for a rescued exception that gets shadowed by a
       # less specific exception being rescued before a more specific
       # exception is rescued.
       #

data/lib/rubocop/cop/lint/unescaped_bracket_in_regexp.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for Regexpes (both literals and via `Regexp.new` / `Regexp.compile`)
+      # Checks for Regexps (both literals and via `Regexp.new` / `Regexp.compile`)
       # that contain unescaped `]` characters.
       #
       # It emulates the following Ruby warning:

data/lib/rubocop/cop/lint/unreachable_code.rb

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Lint
       # Checks for unreachable code.
-      # The check are based on the presence of flow of control
-      # statement in non-final position in `begin` (implicit) blocks.
+      # The check is based on the presence of flow-of-control
+      # statements in non-final position in `begin` (implicit) blocks.
       #
       # @example
       #

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -40,8 +40,6 @@ module RuboCop
       class UselessAssignment < Base
         extend AutoCorrector
 
-        include RangeHelp
-
         MSG = 'Useless assignment to variable - `%<variable>s`.'
 
         def self.joining_forces
@@ -189,12 +187,9 @@ module RuboCop
         # rubocop:enable Metrics/AbcSize
 
         def remove_exception_assignment_part(corrector, node)
-          corrector.remove(
-            range_between(
-              (node.parent.children.first&.source_range || node.parent.location.keyword).end_pos,
-              node.source_range.end_pos
-            )
-          )
+          range = node.parent.children.first&.source_range || node.parent.location.keyword
+
+          corrector.remove(range.end.join(node.source_range.end))
         end
 
         def rename_variable_with_underscore(corrector, node)

data/lib/rubocop/cop/lint/useless_ruby2_keywords.rb

@@ -6,7 +6,7 @@ module RuboCop
       # Looks for `ruby2_keywords` calls for methods that do not need it.
       #
       # `ruby2_keywords` should only be called on methods that accept an argument splat
-      # (`\*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
+      # (`\*args`) but do not have explicit keyword arguments (`k:` or `k: true`) or
       # a keyword splat (`**kwargs`).
       #
       # @example

data/lib/rubocop/cop/lint/utils/nil_receiver_checker.rb

@@ -60,9 +60,7 @@ module RuboCop
               return true if _cant_be_nil?(node.expression, receiver)
             end
 
-            # Due to how `if/else` are implemented (`elsif` is a child of `if` or another `elsif`),
-            # using left_siblings will not work correctly for them.
-            if !else_branch?(node) || (node.if_type? && !node.elsif?)
+            if sequentially_reached?(node)
               node.left_siblings.reverse_each do |sibling|
                 next unless sibling.is_a?(AST::Node)
 
@@ -82,15 +80,17 @@ module RuboCop
             !NIL_METHODS.include?(method_name) && !@additional_nil_methods.include?(method_name)
           end
 
-          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
           def sole_condition_of_parent_if?(node)
             child = node
             parent = node.parent
 
             while parent
               if parent.if_type?
-                condition = parent.condition
-                return true if !child.equal?(condition) && non_nil_condition?(condition, node)
+                unless parent.unless?
+                  condition = parent.condition
+                  return true if !child.equal?(condition) && non_nil_condition?(condition, node)
+                end
 
                 parent = find_top_if(parent) if parent.elsif?
               elsif else_branch?(parent)
@@ -104,7 +104,7 @@ module RuboCop
 
             false
           end
-          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
           def non_nil_condition?(condition, node)
             return true if condition == node
@@ -112,6 +112,17 @@ module RuboCop
             condition.csend_type? && csend_root_receiver(condition) == node
           end
 
+          # Whether control reaches `node` by falling through its left siblings rather than by
+          # a non-sequential entry. A `resbody` is entered via an exception, the `ensure` branch
+          # runs even after a partway raise, and the `else` arm of an `if/elsif` chain is reached by
+          # branching (its `if/case` siblings are walked via parent recursion instead).
+          def sequentially_reached?(node)
+            return false if node.resbody_type?
+            return false if node.parent&.ensure_type? && node.parent.branch.equal?(node)
+
+            !else_branch?(node) || (node.if_type? && !node.elsif?)
+          end
+
           def else_branch?(node)
             node.parent&.if_type? && node.parent.else_branch == node
           end

data/lib/rubocop/cop/metrics/block_length.rb

@@ -17,7 +17,7 @@ module RuboCop
       #
       # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
       # for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns`
-      # instead. By default, there are no methods to allowed.
+      # instead. By default, there are no allowed methods.
       #
       # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
       #

data/lib/rubocop/cop/metrics/method_length.rb

@@ -15,7 +15,7 @@ module RuboCop
       # NOTE: The `ExcludedMethods` and `IgnoredMethods` configuration is
       # deprecated and only kept for backwards compatibility.
       # Please use `AllowedMethods` and `AllowedPatterns` instead.
-      # By default, there are no methods to allowed.
+      # By default, there are no allowed methods.
       #
       # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
       #

data/lib/rubocop/cop/metrics/utils/iterating_block.rb

@@ -43,7 +43,7 @@ module RuboCop
             end
           end
 
-          # Returns true iff name is a known iterating type (e.g. :each, :transform_values)
+          # Returns true only when name is a known iterating type (e.g. :each, :transform_values).
           def iterating_method?(name)
             KNOWN_ITERATING_METHODS.include? name
           end

data/lib/rubocop/cop/mixin/configurable_max.rb

@@ -13,11 +13,12 @@ module RuboCop
           `max=` is deprecated. Use `exclude_limit <ParameterName>` instead.
         WARNING
 
-        cfg = config_to_allow_offenses
-        cfg[:exclude_limit] ||= {}
-        current_max = cfg[:exclude_limit][max_parameter_name]
-        value = [current_max, value].max if current_max
-        cfg[:exclude_limit][max_parameter_name] = value
+        cop_dir = RuboCop::ExcludeLimit.cop_dir_for(self.class.badge.to_s)
+        return unless cop_dir
+
+        cop_dir.mkpath
+        filepath = cop_dir.join(max_parameter_name)
+        filepath.write("#{value}\n", mode: 'a')
       end
 
       def max_parameter_name