rubocop 1.81.7 → 1.92.1

data/lib/rubocop/cop/correctors/parentheses_corrector.rb

@@ -13,8 +13,7 @@ module RuboCop
           buffer = node.source_range.source_buffer
           corrector.remove(range_with_surrounding_space(range: node.loc.begin, buffer: buffer,
                                                         side: :right, whitespace: true))
-          corrector.remove(range_with_surrounding_space(range: node.loc.end, buffer: buffer,
-                                                        side: :left))
+          remove_close_paren(corrector, node, buffer)
           handle_orphaned_comma(corrector, node)
 
           return unless ternary_condition?(node) && next_char_is_question_mark?(node)
@@ -22,8 +21,77 @@ module RuboCop
           corrector.insert_after(node.loc.end, ' ')
         end
 
+        def heredoc_strands_code_after_close_paren?(node)
+          return false unless heredoc_body_before_close_paren?(node)
+
+          after_paren = text_after_close_paren(node)
+
+          !after_paren.empty? && !after_paren.start_with?('.', '&.', ',')
+        end
+
         private
 
+        # When the line above `)` ends with a comment and a chained call follows `)`,
+        # crossing the newline would pull the chain into the comment. Preserve the newline.
+        # When a heredoc body comes before `)`, a chained call has to start on the line
+        # after the terminator instead, since the terminator must stay alone on its line.
+        def remove_close_paren(corrector, node, buffer)
+          if heredoc_above_close_paren_swallows_chain?(node)
+            range = range_with_surrounding_space(range: node.loc.end, buffer: buffer, side: :left)
+
+            corrector.replace(range, "\n")
+          else
+            newlines = !comment_above_close_paren_swallows_chain?(node, buffer)
+            range = range_with_surrounding_space(
+              range: node.loc.end, buffer: buffer, side: :left, newlines: newlines
+            )
+
+            corrector.remove(range)
+          end
+        end
+
+        def heredoc_above_close_paren_swallows_chain?(node)
+          return false unless heredoc_body_before_close_paren?(node)
+
+          text_after_close_paren(node).start_with?('.', '&.')
+        end
+
+        def heredoc_body_before_close_paren?(node)
+          return false unless (last_child = node.children.last)
+
+          close_paren_pos = node.loc.end.begin_pos
+
+          last_child.each_node(:any_str).any? do |str_node|
+            str_node.heredoc? && str_node.loc.heredoc_end.end_pos <= close_paren_pos
+          end
+        end
+
+        def text_after_close_paren(node)
+          close_paren = node.loc.end
+
+          close_paren.source_line[(close_paren.column + 1)..].to_s.lstrip
+        end
+
+        def comment_above_close_paren_swallows_chain?(node, buffer)
+          last_child = node.children.last
+          return false unless last_child
+
+          body_end = last_child.source_range.end_pos
+          close_paren_begin = node.loc.end.begin_pos
+          return false if body_end >= close_paren_begin
+
+          source_between = buffer.source[body_end...close_paren_begin]
+          return false unless source_between.match?(/#[^\n]*\n/)
+
+          chained_after_close_paren?(node)
+        end
+
+        def chained_after_close_paren?(node)
+          trimmed = text_after_close_paren(node)
+
+          !trimmed.empty? && !trimmed.start_with?('#')
+        end
+
         def ternary_condition?(node)
           node.parent&.if_type? && node.parent.ternary?
         end

data/lib/rubocop/cop/correctors/percent_literal_corrector.rb

@@ -97,8 +97,8 @@ module RuboCop
         if delimiters.first != delimiters.last
           # With different delimiters (eg. `[]`, `()`), if there are the same
           # number of each, escaping is not necessary
-          delimiter_counts = delimiters.each_with_object({}) do |delimiter, counts|
-            counts[delimiter] = content.count(delimiter)
+          delimiter_counts = delimiters.to_h do |delimiter|
+            [delimiter, content.count(delimiter)]
           end
 
           return content if delimiter_counts[delimiters.first] == delimiter_counts[delimiters.last]

data/lib/rubocop/cop/correctors.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop # rubocop:disable Style/Documentation -- a namespace that only autoloads the correctors below
+    # Autoloads corrector classes used by cops. Classes are autoloaded to reduce the number of
+    # required classes because they're referenced only when autocorrection is performed.
+
+    # rubocop:disable Layout/LineLength -- the autoload paths do not wrap
+    autoload :AlignmentCorrector, 'rubocop/cop/correctors/alignment_corrector'
+    autoload :ConditionCorrector, 'rubocop/cop/correctors/condition_corrector'
+    autoload :EachToForCorrector, 'rubocop/cop/correctors/each_to_for_corrector'
+    autoload :EmptyLineCorrector, 'rubocop/cop/correctors/empty_line_corrector'
+    autoload :ForToEachCorrector, 'rubocop/cop/correctors/for_to_each_corrector'
+    autoload :IfThenCorrector, 'rubocop/cop/correctors/if_then_corrector'
+    autoload :LambdaLiteralToMethodCorrector, 'rubocop/cop/correctors/lambda_literal_to_method_corrector'
+    autoload :LineBreakCorrector, 'rubocop/cop/correctors/line_break_corrector'
+    autoload :MultilineLiteralBraceCorrector, 'rubocop/cop/correctors/multiline_literal_brace_corrector'
+    autoload :OrderedGemCorrector, 'rubocop/cop/correctors/ordered_gem_corrector'
+    autoload :ParenthesesCorrector, 'rubocop/cop/correctors/parentheses_corrector'
+    autoload :PercentLiteralCorrector, 'rubocop/cop/correctors/percent_literal_corrector'
+    autoload :PunctuationCorrector, 'rubocop/cop/correctors/punctuation_corrector'
+    autoload :RequireLibraryCorrector, 'rubocop/cop/correctors/require_library_corrector'
+    autoload :SpaceCorrector, 'rubocop/cop/correctors/space_corrector'
+    autoload :StringLiteralCorrector, 'rubocop/cop/correctors/string_literal_corrector'
+    autoload :UnusedArgCorrector, 'rubocop/cop/correctors/unused_arg_corrector'
+    # rubocop:enable Layout/LineLength
+  end
+end

data/lib/rubocop/cop/documentation.rb

@@ -14,7 +14,7 @@ module RuboCop
       # @api private
       def url_for(cop_class, config = nil)
         base = department_to_basename(cop_class.department)
-        fragment = cop_class.cop_name.downcase.gsub(/[^a-z]/, '')
+        fragment = cop_class.cop_name.downcase.delete('/')
         base_url = base_url_for(cop_class, config)
         extension = extension_for(cop_class, config)
 
@@ -55,10 +55,9 @@ module RuboCop
 
       # @api private
       def builtin?(cop_class)
-        # any custom method will do
-        return false unless (m = cop_class.instance_methods(false).first)
+        return false unless (name = cop_class.name)
 
-        path, _line = cop_class.instance_method(m).source_location
+        path, _line = Module.const_source_location(name)
         path.start_with?(__dir__)
       end
     end

data/lib/rubocop/cop/exclude_limit.rb

@@ -4,16 +4,42 @@ module RuboCop
   # Allows specified configuration options to have an exclude limit
   # ie. a maximum value tracked that it can be used by `--auto-gen-config`.
   module ExcludeLimit
+    class << self
+      attr_accessor :tmp_dir
+
+      # Reads the aggregated exclude limit values for a cop from tmp files.
+      # Returns a hash like { 'Max' => 81 } or an empty hash if no values were written.
+      def read_limits(cop_name)
+        cop_dir = cop_dir_for(cop_name)
+        return {} unless cop_dir&.directory?
+
+        limits = {}
+        cop_dir.children.each do |filepath|
+          next unless filepath.file?
+
+          values = filepath.readlines.map(&:to_i)
+          limits[filepath.basename.to_s] = values.max unless values.empty?
+        end
+        limits
+      end
+
+      # Returns the tmp directory path for a given cop, or nil if tmp_dir is not set.
+      def cop_dir_for(cop_name)
+        tmp_dir&.join(cop_name.tr('/', '-'))
+      end
+    end
+
     # Sets up a configuration option to have an exclude limit tracked.
     # The parameter name given is transformed into a method name (eg. `Max`
     # becomes `self.max=` and `MinDigits` becomes `self.min_digits=`).
     def exclude_limit(parameter_name, method_name: transform(parameter_name))
       define_method(:"#{method_name}=") do |value|
-        cfg = config_to_allow_offenses
-        cfg[:exclude_limit] ||= {}
-        current_max = cfg[:exclude_limit][parameter_name]
-        value = [current_max, value].max if current_max
-        cfg[:exclude_limit][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(parameter_name)
+        filepath.write("#{value}\n", mode: 'a')
       end
     end
 

data/lib/rubocop/cop/gemspec/dependency_version.rb

@@ -109,12 +109,6 @@ module RuboCop
           end
         end
 
-        def match_block_variable_name?(receiver_name)
-          gem_specification(processed_source.ast) do |block_variable_name|
-            return block_variable_name == receiver_name
-          end
-        end
-
         def add_dependency_method?(method_name)
           ADD_DEPENDENCY_METHODS.include?(method_name)
         end

data/lib/rubocop/cop/gemspec/development_dependencies.rb

@@ -95,7 +95,7 @@ module RuboCop
         private
 
         def forbidden_gem?(gem_name)
-          !cop_config['AllowedGems'].include?(gem_name)
+          !Array(cop_config['AllowedGems']).include?(gem_name)
         end
 
         def message(_range)

data/lib/rubocop/cop/gemspec/duplicated_assignment.rb

@@ -3,12 +3,12 @@
 module RuboCop
   module Cop
     module Gemspec
-      # An attribute assignment method calls should be listed only once
+      # An attribute assignment method call should be listed only once
       # in a gemspec.
       #
       # Assigning to an attribute with the same name using `spec.foo =` or
       # `spec.attribute#[]=` will be an unintended usage. On the other hand,
-      # duplication of methods such # as `spec.requirements`,
+      # duplication of methods such as `spec.requirements`,
       # `spec.add_runtime_dependency`, and others are permitted because it is
       # the intended use of appending values.
       #
@@ -83,18 +83,28 @@ module RuboCop
         def duplicated_assignment_method_nodes
           assignment_method_declarations(processed_source.ast)
             .select(&:assignment_method?)
-            .group_by(&:method_name)
+            .group_by { |node| [enclosing_specification(node), node.method_name] }
             .values
             .select { |nodes| nodes.size > 1 }
         end
 
         def duplicated_indexed_assignment_method_nodes
           indexed_assignment_method_declarations(processed_source.ast)
-            .group_by { |node| [node.children.first.method_name, node.first_argument] }
+            .group_by { |node| indexed_assignment_key(node) }
             .values
             .select { |nodes| nodes.size > 1 }
         end
 
+        def indexed_assignment_key(node)
+          [enclosing_specification(node), node.children.first.method_name, node.first_argument]
+        end
+
+        # Assignments in separate `Gem::Specification.new` blocks are not duplicates of
+        # one another, so the enclosing specification is part of the grouping key.
+        def enclosing_specification(node)
+          node.each_ancestor(:block).find { |block| gem_specification?(block) }
+        end
+
         def register_offense(node, assignment, line_of_first_occurrence)
           line_range = node.loc.column...node.loc.last_column
           offense_location = source_range(processed_source.buffer, node.first_line, line_range)

data/lib/rubocop/cop/gemspec/ordered_dependencies.rb

@@ -69,8 +69,7 @@ module RuboCop
         def on_new_investigation
           return if processed_source.blank?
 
-          dependency_declarations(processed_source.ast)
-            .each_cons(2) do |previous, current|
+          dependency_declarations(processed_source.ast).each_cons(2) do |previous, current|
             next unless consecutive_lines?(previous, current)
             next unless case_insensitive_out_of_order?(gem_name(current), gem_name(previous))
             next unless get_dependency_name(previous) == get_dependency_name(current)
@@ -81,12 +80,6 @@ module RuboCop
 
         private
 
-        def previous_declaration(node)
-          declarations = dependency_declarations(processed_source.ast)
-          node_index = declarations.find_index(node)
-          declarations.to_a[node_index - 1]
-        end
-
         def get_dependency_name(node)
           node.method_name
         end

data/lib/rubocop/cop/gemspec/require_mfa.rb

@@ -6,7 +6,7 @@ module RuboCop
       # Requires a gemspec to have `rubygems_mfa_required` metadata set.
       #
       # This setting tells RubyGems that MFA (Multi-Factor Authentication) is
-      # required for accounts to be able perform privileged operations, such as
+      # required for accounts to be able to perform privileged operations, such as
       # (see RubyGems' documentation for the full list of privileged
       # operations):
       #
@@ -70,7 +70,7 @@ module RuboCop
         def_node_matcher :metadata, <<~PATTERN
           `{
             (send _ :metadata= $_)
-            (send (send _ :metadata) :[]= (str "rubygems_mfa_required") $_)
+            (send (send _ :metadata) :[]= {(str "rubygems_mfa_required") (sym :rubygems_mfa_required)} $_)
           }
         PATTERN
 
@@ -78,13 +78,13 @@ module RuboCop
         def_node_search :metadata_assignment, <<~PATTERN
           `{
             (send _ :metadata= _)
-            (send (send _ :metadata) :[]= (str _) _)
+            (send (send _ :metadata) :[]= {str sym} _)
           }
         PATTERN
 
         # @!method rubygems_mfa_required(node)
         def_node_search :rubygems_mfa_required, <<~PATTERN
-          (pair (str "rubygems_mfa_required") $_)
+          (pair {(str "rubygems_mfa_required") (sym :rubygems_mfa_required)} $_)
         PATTERN
 
         # @!method true_string?(node)
@@ -92,7 +92,7 @@ module RuboCop
           (str "true")
         PATTERN
 
-        def on_block(node) # rubocop:disable Metrics/MethodLength, InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable Metrics/MethodLength, InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- the gemspec block is matched by its named block variable
           gem_specification(node) do |block_var|
             metadata_value = metadata(node)
             mfa_value = mfa_value(metadata_value)
@@ -143,7 +143,10 @@ module RuboCop
             #{block_var}.metadata['rubygems_mfa_required'] = 'true'
           RUBY
 
-          if (last_assignment = metadata_assignment(processed_source.ast).to_a.last)
+          # Scope the search to the current spec block. Searching the whole file
+          # would, for a second `Gem::Specification.new` block, insert the directive
+          # into the first block, leaving this block uncorrected and looping forever.
+          if (last_assignment = metadata_assignment(node).to_a.last)
             corrector.insert_after(last_assignment, "\n#{require_mfa_directive}")
           else
             corrector.insert_before(node.loc.end, "#{require_mfa_directive}\n")

data/lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb

@@ -3,11 +3,11 @@
 module RuboCop
   module Cop
     module Gemspec
-      # Checks that `RUBY_VERSION` constant is not used in gemspec.
-      # Using `RUBY_VERSION` is dangerous because value of the
+      # Checks that `RUBY_VERSION` and `Ruby::VERSION` constants are not used in gemspec.
+      # Using `RUBY_VERSION` and `Ruby::VERSION` is dangerous because the value of the
       # constant is determined by `rake release`.
-      # It's possible to have dependency based on ruby version used
-      # to execute `rake release` and not user's ruby version.
+      # It's possible to have a dependency based on the Ruby version used
+      # to execute `rake release` and not the user's Ruby version.
       #
       # @example
       #
@@ -28,15 +28,20 @@ module RuboCop
       class RubyVersionGlobalsUsage < Base
         include GemspecHelp
 
-        MSG = 'Do not use `RUBY_VERSION` in gemspec file.'
+        MSG = 'Do not use `%<ruby_version>s` in gemspec file.'
 
         # @!method ruby_version?(node)
-        def_node_matcher :ruby_version?, '(const {cbase nil?} :RUBY_VERSION)'
+        def_node_matcher :ruby_version?, <<~PATTERN
+          {
+            (const {cbase nil?} :RUBY_VERSION)
+            (const (const {cbase nil?} :Ruby) :VERSION)
+          }
+        PATTERN
 
         def on_const(node)
           return unless gem_spec_with_ruby_version?(node)
 
-          add_offense(node)
+          add_offense(node, message: format(MSG, ruby_version: node.source))
         end
 
         private

data/lib/rubocop/cop/gemspec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Cops for the `Gemspec` department. The department's cops are registered for lazy loading
+    # and their files are loaded on demand.
+    module Gemspec
+      extend LazyLoader
+
+      register_cop :AddRuntimeDependency, "#{__dir__}/gemspec/add_runtime_dependency"
+      register_cop :AttributeAssignment, "#{__dir__}/gemspec/attribute_assignment"
+      register_cop :DependencyVersion, "#{__dir__}/gemspec/dependency_version"
+      register_cop :DeprecatedAttributeAssignment, "#{__dir__}/gemspec/deprecated_attribute_assignment"
+      register_cop :DevelopmentDependencies, "#{__dir__}/gemspec/development_dependencies"
+      register_cop :DuplicatedAssignment, "#{__dir__}/gemspec/duplicated_assignment"
+      register_cop :OrderedDependencies, "#{__dir__}/gemspec/ordered_dependencies"
+      register_cop :RequireMFA, "#{__dir__}/gemspec/require_mfa"
+      register_cop :RequiredRubyVersion, "#{__dir__}/gemspec/required_ruby_version"
+      register_cop :RubyVersionGlobalsUsage, "#{__dir__}/gemspec/ruby_version_globals_usage"
+    end
+  end
+end

data/lib/rubocop/cop/generator/registration_injector.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    class Generator
+      # A class that injects a `register_cop` directive into the cop's department module
+      # so that the new cop is registered for lazy loading.
+      # The directive is injected in alphabetical order among the existing directives without
+      # reordering them, since the registration order defines the cop execution order.
+      # When the department module file does not exist yet, it is created, and a require for
+      # it is injected into the root RuboCop file.
+      #
+      # Anything unexpected in the department module, such as a commented-out or otherwise
+      # unparsable `register_cop` line, raises an error instead of silently producing
+      # a broken registration.
+      class RegistrationInjector
+        EXTEND_PATTERN = /\A(?<indent>\s*)extend LazyLoader\n\z/.freeze
+        ENTRY_PATTERN = %r{
+          \A(?<indent>\s*)register_cop\s
+          :(?<constant>[A-Za-z0-9]+),\s
+          "\#\{__dir__\}/(?<path>[a-z0-9_/]+)"\n\z
+        }x.freeze
+        DEPARTMENT_REQUIRE_PATTERN = %r{\Arequire_relative 'rubocop/cop/[a-z0-9_/]+'\n\z}.freeze
+
+        def initialize(source_path:, badge:, root_file_path: 'lib/rubocop.rb', output: $stdout)
+          @source_path = Pathname(source_path)
+          @badge = badge
+          @root_file_path = root_file_path
+          @department_file_path = Pathname("#{@source_path.dirname}.rb")
+          @output = output
+        end
+
+        def inject
+          if File.exist?(department_file_path)
+            inject_directive
+          else
+            create_department_file
+            inject_department_require
+          end
+        end
+
+        private
+
+        attr_reader :source_path, :badge, :root_file_path, :department_file_path, :output
+
+        def inject_directive
+          lines = File.readlines(department_file_path)
+          entries = parse_entries(lines)
+          return if entries.any? { |entry| entry[:path] == cop_path }
+
+          line, indent = insertion_point(lines, entries)
+          lines.insert(line, "#{indent}#{directive}\n")
+
+          write_department_file(lines)
+        end
+
+        def create_department_file
+          File.write(department_file_path, department_module_source)
+
+          output.puts "[create] #{department_file_path}"
+        end
+
+        def inject_department_require
+          require_path = department_file_path.sub_ext('').to_s.delete_prefix('lib/')
+          require_directive = "require_relative '#{require_path}'\n"
+
+          lines = File.readlines(root_file_path)
+          return if lines.include?(require_directive)
+
+          lines.insert(department_require_index(lines, require_directive), require_directive)
+          File.write(root_file_path, lines.join)
+
+          output.puts "[modify] #{root_file_path} - `#{require_directive.strip}` was injected."
+        end
+
+        def write_department_file(lines)
+          File.write(department_file_path, lines.join)
+
+          output.puts "[modify] #{department_file_path} - `#{directive}` was injected."
+        end
+
+        # @return [Array<Hash>] the `register_cop` entries with their line numbers
+        def parse_entries(lines)
+          lines.filter_map.with_index do |line, index|
+            match = ENTRY_PATTERN.match(line)
+
+            if match
+              { line: index, indent: match[:indent], constant: match[:constant],
+                path: match[:path] }
+            elsif line.include?('register_cop')
+              raise Error, "unexpected `register_cop` line in #{department_file_path}:" \
+                           "#{index + 1}; fix it or register the cop manually: #{line}"
+            end
+          end
+        end
+
+        # The directive path is relative to the department module file's directory,
+        # which `__dir__` resolves to at load time.
+        def cop_path
+          source_path.relative_path_from(department_file_path.dirname).to_s.delete_suffix('.rb')
+        end
+
+        def insertion_point(lines, entries)
+          if entries.empty?
+            first_directive_position(lines)
+          else
+            successor = entries.find { |entry| entry[:path] > cop_path }
+            entry = successor || entries.last
+
+            [entry[:line] + (successor ? 0 : 1), entry[:indent]]
+          end
+        end
+
+        def directive
+          "register_cop :#{badge.cop_name}, \"\#{__dir__}/#{cop_path}\""
+        end
+
+        # The department requires form the contiguous block right before
+        # the `rubocop/cop/team` require in the root RuboCop file.
+        def department_require_index(lines, require_directive)
+          anchor = lines.index("require_relative 'rubocop/cop/team'\n")
+          unless anchor
+            raise Error, "could not find the department require block in #{root_file_path}"
+          end
+
+          block_end = anchor - 1
+          block_end -= 1 while lines[block_end] == "\n"
+          block_start = block_end
+          block_start -= 1 while lines[block_start - 1]&.match?(DEPARTMENT_REQUIRE_PATTERN)
+
+          (block_start..block_end).find do |index|
+            lines[index] > require_directive
+          end || (block_end + 1)
+        end
+
+        def first_directive_position(lines)
+          extend_lines = lines.filter_map.with_index do |line, index|
+            [index, EXTEND_PATTERN.match(line)[:indent]] if EXTEND_PATTERN.match?(line)
+          end
+
+          unless extend_lines.size == 1
+            raise Error, "expected `extend LazyLoader` in #{department_file_path}; " \
+                         'add it or register the cop manually'
+          end
+
+          index, indent = extend_lines.first
+          blank_after_extend = lines[index + 1] == "\n"
+
+          [index + (blank_after_extend ? 2 : 1), indent]
+        end
+
+        def department_module_source
+          modules = %w[RuboCop Cop] + badge.department.to_s.split('/')
+          body_indent = '  ' * modules.size
+
+          lines = ['# frozen_string_literal: true', '']
+          lines.concat(module_opening_lines(modules))
+          lines << "#{body_indent}extend LazyLoader"
+          lines << ''
+          lines << "#{body_indent}#{directive}"
+          lines.concat(module_closing_lines(modules))
+
+          "#{lines.join("\n")}\n"
+        end
+
+        def module_opening_lines(modules)
+          modules.flat_map.with_index do |mod, nesting|
+            indent = '  ' * nesting
+            lines = []
+
+            if mod == modules.last
+              lines << "#{indent}# Cops for the `#{badge.department}` department. " \
+                       "The department's cops are"
+              lines << "#{indent}# registered for lazy loading and their files are " \
+                       'loaded on demand.'
+            end
+
+            lines << "#{indent}module #{mod}"
+          end
+        end
+
+        def module_closing_lines(modules)
+          (modules.size - 1).downto(0).map { |nesting| "#{'  ' * nesting}end" }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/generator.rb

@@ -136,6 +136,10 @@ module RuboCop
         RequireFileInjector.new(source_path: source_path, root_file_path: root_file_path).inject
       end
 
+      def inject_registration
+        RegistrationInjector.new(source_path: source_path, badge: badge).inject
+      end
+
       def inject_config(config_file_path: 'config/default.yml',
                         version_added: '<<next>>')
         injector =
@@ -143,7 +147,7 @@ module RuboCop
                                     badge: badge,
                                     version_added: version_added)
 
-        injector.inject do # rubocop:disable Lint/UnexpectedBlockArity
+        injector.inject do # rubocop:disable Lint/UnexpectedBlockArity -- this `inject` is the injector API, not `Enumerable#inject`
           output.puts(format(CONFIGURATION_ADDED_MESSAGE,
                              configuration_file_path: config_file_path))
         end

data/lib/rubocop/cop/internal_affairs/example_heredoc_delimiter.rb

@@ -9,15 +9,15 @@ module RuboCop
       # the delimiter.
       #
       # @example
-      #  # bad
-      #  expect_offense(<<~CODE)
-      #    example_ruby_code
-      #  CODE
+      #   # bad
+      #   expect_offense(<<~CODE)
+      #     example_ruby_code
+      #   CODE
       #
-      #  # good
-      #  expect_offense(<<~RUBY)
-      #    example_ruby_code
-      #  RUBY
+      #   # good
+      #   expect_offense(<<~RUBY)
+      #     example_ruby_code
+      #   RUBY
       class ExampleHeredocDelimiter < Base
         extend AutoCorrector