rubocop 1.88.1 → 1.89.0

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

@@ -12,20 +12,28 @@ module RuboCop
       class << self
         attr_reader :processed_source
 
-        def correct(corrector, processed_source, node, column_delta)
+        # `tab_indentation` may only be set by callers whose `column_delta` represents
+        # whole indentation levels (e.g. `Layout/IndentationWidth`).
+        # Alignment to an arbitrary column cannot be expressed with tabs, so those callers
+        # leave tab correction disabled to avoid producing a never-converging correction.
+        def correct(corrector, processed_source, node, column_delta, tab_indentation: false)
           return unless node
 
           @processed_source = processed_source
-          # Disable autocorrection for tabs as it requires special handling
-          return if using_tabs?
 
           expr = node.respond_to?(:loc) ? node.source_range : node
           return if block_comment_within?(expr)
 
           taboo_ranges = inside_string_ranges(node)
 
-          each_line(expr) do |line_begin_pos|
-            autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges)
+          if using_tabs?
+            return unless tab_indentation
+
+            correct_tab_indentation(corrector, expr, column_delta, taboo_ranges)
+          else
+            each_line(expr) do |line_begin_pos|
+              autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges)
+            end
           end
         end
 
@@ -58,6 +66,48 @@ module RuboCop
           end
         end
 
+        # Tab indentation is corrected by rewriting each line's leading whitespace to
+        # the target number of tabs. Working in whole tabs rather than applying a column delta
+        # keeps the result idempotent, which avoids the infinite loops that delta-based correction
+        # caused for tabs.
+        def correct_tab_indentation(corrector, expr, column_delta, taboo_ranges)
+          buffer = expr.source_buffer
+
+          each_line(expr) do |line_begin_pos|
+            line_range = buffer.line_range(buffer.line_for_position(line_begin_pos))
+            correct_tab_line(corrector, line_range, column_delta, taboo_ranges)
+          end
+        end
+
+        def correct_tab_line(corrector, line_range, column_delta, taboo_ranges)
+          leading = line_range.source[/\A[ \t]*/]
+          return if leading.length == line_range.source.length # blank line
+
+          leading_range = range_between(line_range.begin_pos, line_range.begin_pos + leading.length)
+          return if taboo_ranges.any? { |t| within?(leading_range, t) }
+
+          target = target_tab_indentation(leading, column_delta)
+          corrector.replace(leading_range, target) unless leading == target
+        end
+
+        def target_tab_indentation(leading, column_delta)
+          width = configured_indentation_width
+          return leading unless width.positive?
+
+          visual_width = leading.chars.sum { |char| char == "\t" ? width : 1 }
+
+          "\t" * ([visual_width + column_delta, 0].max / width)
+        end
+
+        # The number of columns a single tab spans. This must match the width
+        # `Layout/IndentationWidth` uses to compute `column_delta`, otherwise
+        # the division below would not land on a tab boundary. `Layout/IndentationStyle`
+        # has its own `IndentationWidth`, but that only governs how that cop replaces tabs
+        # with spaces, so it must not be consulted here.
+        def configured_indentation_width
+          processed_source.config.for_cop('Layout/IndentationWidth')['Width'] || 2
+        end
+
         def inside_string_ranges(node)
           return [] unless node.is_a?(Parser::AST::Node)
 

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

@@ -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.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 =

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

@@ -251,7 +251,7 @@ module RuboCop
           key = category || name
           visibility_key =
             if node.def_modifier?
-              "#{name}_methods"
+              name.end_with?('_class_method') ? "#{name}s" : "#{name}_methods"
             else
               "#{node_visibility(node)}_#{key}"
             end
@@ -283,7 +283,7 @@ module RuboCop
           # Exploding such a node into its children would yield non-node values (e.g. a
           # method-name `Symbol` from a `csend`) and crash later checks.
           if class_def.type?(:begin, :kwbegin)
-            class_def.children.compact
+            flatten_class_elements(class_def)
           else
             [class_def]
           end
@@ -296,6 +296,12 @@ module RuboCop
             private_constant?(node)
         end
 
+        def flatten_class_elements(node)
+          node.children.compact.flat_map do |child|
+            child.kwbegin_type? ? flatten_class_elements(child) : [child]
+          end
+        end
+
         def ignore_for_autocorrect?(node, sibling)
           classification = classify(node)
           sibling_class = classify(sibling)

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

@@ -155,8 +155,15 @@ module RuboCop
 
         def less_indented?(line)
           rule = config.for_cop('Layout/AccessModifierIndentation')['EnforcedStyle'] == 'outdent'
-          access_modifier = 'private|protected|public'
-          /\A\s*(end\b|[)}\]])/.match?(line) || (rule && /\A\s*(#{access_modifier})\b/.match?(line))
+          /\A\s*(end\b|[)}\]])/.match?(line) || (rule && bare_access_modifier?(line))
+        end
+
+        # Only a bare access modifier (the keyword alone on its line) is outdented by
+        # `Layout/AccessModifierIndentation`. An inline modifier such as `private def foo`
+        # keeps the regular method indentation, so a comment above it must not be pushed
+        # one level deeper.
+        def bare_access_modifier?(line)
+          /\A\s*(private|protected|public)\s*(#.*)?\z/.match?(line)
         end
 
         def two_alternatives?(line)

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

@@ -92,13 +92,7 @@ module RuboCop
           case parent.type
           when :def, :defs then base_for_method_definition(parent)
           when :kwbegin then parent.loc.begin
-          when :block, :numblock, :itblock
-            assignment_node = assignment_node(parent)
-            if same_line?(parent, assignment_node)
-              assignment_node.source_range
-            else
-              parent.send_node.source_range
-            end
+          when :block, :numblock, :itblock then start_line_range(parent)
           else node.loc.keyword
           end
         end
@@ -143,13 +137,6 @@ module RuboCop
             autocorrect(corrector, else_range)
           end
         end
-
-        def assignment_node(node)
-          assignment_node = node.ancestors.first
-          return unless assignment_node&.assignment?
-
-          assignment_node
-        end
       end
     end
   end

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

@@ -172,7 +172,7 @@ module RuboCop
             'Indent the right bracket the same as the first position ' \
             'after the preceding left parenthesis.'
           when :parent_hash_key
-            'Indent the right bracket the same as the parent hash key.' \
+            'Indent the right bracket the same as the parent hash key.'
           else
             'Indent the right bracket the same as the start of the line ' \
             'where the left bracket is.'

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

@@ -206,7 +206,9 @@ module RuboCop
         def autocorrect(corrector, node)
           return unless node
 
-          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+          AlignmentCorrector.correct(
+            corrector, processed_source, node, @column_delta, tab_indentation: true
+          )
         end
 
         # Returns a range at the first non-space column of the line the opening parenthesis is on,

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

@@ -98,6 +98,24 @@ module RuboCop
       #
       #   name = 'John'      #: String
       #
+      # @example AllowYARDCommentBlockSeparator: false (default)
+      #
+      #   # bad
+      #
+      #   # Copyright (c) Example Corp
+      #   #-
+      #   class Client
+      #   end
+      #
+      # @example AllowYARDCommentBlockSeparator: true
+      #
+      #   # good
+      #
+      #   # Copyright (c) Example Corp
+      #   #-
+      #   class Client
+      #   end
+      #
       class LeadingCommentSpace < Base
         include RangeHelp
         extend AutoCorrector
@@ -113,6 +131,7 @@ module RuboCop
             next if gemfile_ruby_comment?(comment)
             next if rbs_inline_annotation?(comment)
             next if steep_annotation?(comment)
+            next if yard_comment_block_separator?(comment)
 
             add_offense(comment) do |corrector|
               expr = comment.source_range
@@ -197,6 +216,14 @@ module RuboCop
         def steep_annotation?(comment)
           allow_steep_annotation? && comment.text.start_with?(/#[$:]/)
         end
+
+        def allow_yard_comment_block_separator?
+          cop_config['AllowYARDCommentBlockSeparator']
+        end
+
+        def yard_comment_block_separator?(comment)
+          allow_yard_comment_block_separator? && comment.text.match?(/\A#-\s*\z/)
+        end
       end
     end
   end

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

@@ -65,6 +65,7 @@ module RuboCop
         include AllowedPattern
         include RangeHelp
         include LineLengthHelp
+        include EndlessMethodRewriter
         extend AutoCorrector
 
         exclude_limit 'Max'
@@ -92,8 +93,15 @@ module RuboCop
         alias on_hash on_potential_breakable_node
         alias on_send on_potential_breakable_node
         alias on_csend on_potential_breakable_node
-        alias on_def on_potential_breakable_node
-        alias on_defs on_potential_breakable_node
+
+        def on_def(node)
+          if node.endless?
+            track_endless_method(node)
+          else
+            check_for_breakable_node(node)
+          end
+        end
+        alias on_defs on_def
 
         def on_new_investigation
           return unless processed_source.raw_source.include?(';')
@@ -111,6 +119,70 @@ module RuboCop
 
         attr_accessor :breakable_range
 
+        def track_endless_method(node)
+          line_index = node.first_line - processed_source.buffer.first_line
+          endless_methods_by_line[line_index] = node
+        end
+
+        def handle_endless_method_line(line, line_index)
+          if require_endless_methods?
+            return register_required_endless_method_offense(line, line_index)
+          end
+
+          register_endless_method_offense(line, line_index)
+        end
+
+        def require_endless_methods?
+          config.cop_enabled?('Style/EndlessMethod') &&
+            config.for_cop('Style/EndlessMethod')['EnforcedStyle'] == 'require_always'
+        end
+
+        def register_endless_method_offense(line, line_index)
+          message = format(MSG, length: line_length(line), max: max)
+          loc = excess_range(nil, line, line_index)
+
+          add_offense(loc, message: message) do |corrector|
+            self.max = line_length(line)
+
+            correct_to_multiline(corrector, endless_methods_by_line[line_index])
+          end
+        end
+
+        def register_required_endless_method_offense(line, line_index)
+          node = endless_methods_by_line[line_index]
+          loc = excess_range(nil, line, line_index)
+
+          add_offense(loc, message: format(MSG, length: line_length(line), max: max)) do |corrector|
+            self.max = line_length(line)
+
+            if correctable_endless_method_block?(node)
+              correct_endless_method_block_to_multiline(corrector, node)
+            end
+          end
+        end
+
+        def correctable_endless_method_block?(node)
+          block_node = node.body
+
+          block_node&.type?(:any_block) &&
+            block_node.braces? &&
+            block_node.single_line? &&
+            block_node.body &&
+            !receiver_contains_heredoc?(block_node)
+        end
+
+        def correct_endless_method_block_to_multiline(corrector, node)
+          block_node = node.body
+          block_arguments = block_node.arguments? ? " #{block_node.arguments.source}" : ''
+          replacement = [
+            "#{block_node.send_node.source} do#{block_arguments}",
+            "#{indent(node, offset: 2)}#{block_node.body.source}",
+            "#{indent(node)}end"
+          ].join("\n")
+
+          corrector.replace(block_node, replacement)
+        end
+
         def check_for_breakable_node(node)
           breakable_node = extract_breakable_node(node, max)
           return if breakable_node.nil?
@@ -237,6 +309,10 @@ module RuboCop
           @breakable_range_by_line_index ||= {}
         end
 
+        def endless_methods_by_line
+          @endless_methods_by_line ||= {}
+        end
+
         def breakable_string_delimiters
           @breakable_string_delimiters ||= {}
         end
@@ -252,10 +328,15 @@ module RuboCop
           [max - indentation_difference(line), 0].max
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_line(line, line_index)
           return if line_length(line) <= max
           return if allowed_line?(line, line_index)
+
+          if endless_methods_by_line.key?(line_index)
+            return handle_endless_method_line(line, line_index)
+          end
+
           if allow_rbs_inline_annotation? && rbs_inline_annotation_on_source_line?(line_index)
             return
           end
@@ -267,7 +348,7 @@ module RuboCop
 
           register_offense(excess_range(nil, line, line_index), line, line_index)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def allowed_line?(line, line_index)
           matches_allowed_pattern?(line) ||
@@ -313,10 +394,6 @@ module RuboCop
         end
         alias max_line_length max
 
-        def allow_heredoc?
-          allowed_heredoc
-        end
-
         def allowed_heredoc
           cop_config['AllowHeredoc']
         end
@@ -344,10 +421,6 @@ module RuboCop
           end
         end
 
-        def line_in_heredoc?(line_number)
-          heredocs.any? { |range, _delimiter| range.cover?(line_number) }
-        end
-
         def receiver_contains_heredoc?(node)
           return false unless (receiver = node.receiver)
           return true if receiver.any_str_type? && receiver.heredoc?
@@ -420,11 +493,16 @@ module RuboCop
           # The maximum allowed length of a string value is:
           # `Max` - end delimiter (quote) - continuation characters (space and slash)
           max_length = max - 3
-          # If the string is on the same line as its parent, offset by the column difference
-          # (Only apply when on same line to avoid negative offsets for multi-line dstr)
-          if same_line?(node, node.parent)
-            max_length -= column_offset_between(node.loc, node.parent.loc)
-          end
+          # Offset by the string's starting column so the broken line actually fits
+          # within `Max`. When on the same line as its parent, use the column difference;
+          # otherwise the string is indented on its own line, so subtract that indentation.
+          # (Without this, an indented string under a multi-line parent never shortens
+          # below `Max` and the autocorrect loops, inserting empty `"" \` fragments.)
+          max_length -= if same_line?(node, node.parent)
+                          column_offset_between(node.loc, node.parent.loc)
+                        else
+                          node.loc.column
+                        end
           node.source[0...(max_length)]
         end
       end