rubocop 1.88.2 → 1.89.0

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/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?

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

@@ -410,7 +410,7 @@ module RuboCop
 
         def find_continuation_node(node)
           receiver = node.receiver
-          return receiver.send_node if single_line_block_receiver?(receiver)
+          return leftmost_call_on_same_line(receiver) if single_line_block_receiver?(receiver)
           return unless receiver.call_type? && receiver.loc.dot
           return receiver if receiver.receiver.begin_type? && node.block_node.single_line?
           return unless receiver.loc.dot.line > receiver.receiver.last_line
@@ -422,9 +422,19 @@ module RuboCop
           receiver.single_line? && receiver.any_block_type?
         end
 
+        def leftmost_call_on_same_line(node)
+          current = node.any_block_type? ? node.send_node : node
+          while current.receiver&.call_type? &&
+                current.receiver.loc?(:dot) &&
+                current.receiver.loc.dot.line == current.loc.dot.line
+            current = current.receiver
+          end
+          current
+        end
+
         def handle_descendant_block(node)
           receiver = node.receiver
-          return receiver.send_node if single_line_block_receiver?(receiver)
+          return leftmost_call_on_same_line(receiver) if single_line_block_receiver?(receiver)
 
           block_node = node.each_descendant(:any_block).first
           return unless block_node&.multiline?

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

@@ -49,6 +49,7 @@ module RuboCop
       class RedundantLineBreak < Base
         include CheckAssignment
         include CheckSingleLineSuitability
+        include ReparsedEquivalence
         extend AutoCorrector
 
         MSG = 'Redundant line break detected.'
@@ -82,12 +83,88 @@ module RuboCop
         end
 
         def register_offense(node)
+          # The exact single-line correction is verified to parse equivalently
+          # before the offense is registered, so a join that would change how
+          # the code parses is never reported or offered.
+          return if verified_by_reparse([node], oversized: :verify).empty?
+
           add_offense(node) do |corrector|
             corrector.replace(node, to_single_line(node.source).strip)
           end
           ignore_node(node)
         end
 
+        def apply_reparse_correction(corrector, node)
+          corrector.replace(node, to_single_line(node.source).strip)
+        end
+
+        # Joining lines shifts the value of any later `__LINE__`, exactly as
+        # any other line-removing correction does; neutralize it on both sides
+        # with an identifier, which stays valid in every position the keyword
+        # can appear in.
+        def preprocess_reparsed_source(source)
+          source.gsub(/\b__LINE__\b/, '__LINE0__')
+        end
+
+        def normalize_reparsed_ast(node)
+          fold_string_concatenation(node)
+        end
+
+        # Joining lines merges split string literals (`"a" \<newline> "b"` into
+        # `"ab"`) and turns mixed-quote pairs into `+` concatenation, which
+        # changes the tree but not the resulting string. Normalize all string
+        # concatenation to a canonical form before comparing: nested
+        # concatenations are flattened and adjacent literal parts merged.
+        def fold_string_concatenation(node)
+          return node unless node.is_a?(::Parser::AST::Node)
+
+          children = node.children.map { |child| fold_string_concatenation(child) }
+          node = node.updated(nil, children)
+
+          parts = string_concatenation_parts(node)
+          return node unless parts
+
+          merged = merge_string_parts(parts)
+          if merged.one? && merged.first.str_type?
+            node.updated(:str, merged.first.children)
+          else
+            node.updated(:dstr, merged)
+          end
+        end
+
+        def string_concatenation_parts(node)
+          case node.type
+          when :dstr
+            node.children
+          when :send
+            parts = [node.receiver, *node.arguments]
+            parts if node.method?(:+) && parts.all? { |part| stringish?(part) }
+          end
+        end
+
+        def merge_string_parts(parts)
+          flattened = parts.flat_map do |part|
+            part.is_a?(::Parser::AST::Node) && part.dstr_type? ? part.children : [part]
+          end
+
+          flattened.chunk_while { |left, right| plain_string?(left) && plain_string?(right) }
+                   .map { |chunk| merge_plain_strings(chunk) }
+        end
+
+        def merge_plain_strings(chunk)
+          return chunk.first if chunk.one?
+
+          chunk.first.updated(:str, [chunk.map { |part| part.children.first }.join])
+        end
+
+        def stringish?(node)
+          node.is_a?(::Parser::AST::Node) && %i[str dstr].include?(node.type)
+        end
+
+        def plain_string?(node)
+          node.is_a?(::Parser::AST::Node) && node.str_type? && node.children.one?
+        end
+
         def offense?(node)
           return false unless node.multiline? && suitable_as_single_line?(node)
           return require_backslash?(node) if node.operator_keyword?