rubocop 1.88.0 → 1.89.0

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

@@ -28,10 +28,10 @@ module RuboCop
       #   # bad
       #   hash = {
       #     key: :value
-      #   }
-      #   and_in_a_method_call({
-      #     no: :difference
-      #                        })
+      #          }
+      #   in_a_method_call({
+      #     foo: :bar
+      #   })
       #   takes_multi_pairs_hash(x: {
       #     a: 1,
       #     b: 2
@@ -42,13 +42,12 @@ module RuboCop
       #                          })
       #
       #   # good
-      #   special_inside_parentheses
       #   hash = {
       #     key: :value
       #   }
-      #   but_in_a_method_call({
-      #                          its_like: :this
-      #                        })
+      #   in_a_method_call({
+      #                      foo: :bar
+      #                    })
       #   takes_multi_pairs_hash(x: {
       #                            a: 1,
       #                            b: 2
@@ -67,17 +66,17 @@ module RuboCop
       #   # bad
       #   hash = {
       #     key: :value
-      #   }
-      #   but_in_a_method_call({
-      #                          its_like: :this
-      #                         })
+      #          }
+      #   in_a_method_call({
+      #                     foo: :bar
+      #                   })
       #
       #   # good
       #   hash = {
       #     key: :value
       #   }
-      #   and_in_a_method_call({
-      #     no: :difference
+      #   in_a_method_call({
+      #     foo: :bar
       #   })
       #
       #

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

@@ -25,6 +25,17 @@ module RuboCop
       #     end
       #   end
       #
+      # @example
+      #   # bad
+      #   value = (
+      #   foo - bar
+      #   )
+      #
+      #   # good
+      #   value = (
+      #     foo - bar
+      #   )
+      #
       # @example AllowedPatterns: ['^\s*module']
       #   # bad
       #   module A
@@ -95,6 +106,16 @@ module RuboCop
           check_indentation(node.loc.end, node.children.first)
         end
 
+        def on_begin(node)
+          # Only a parenthesized grouping expression (e.g. `(\n  foo\n)`) has
+          # explicit delimiters. Indent the body one step from the line
+          # the opening parenthesis is on, but only when the closing parenthesis is
+          # first on its line (a body on the opening line is skipped downstream).
+          return unless parentheses?(node) && begins_its_line?(node.loc.end)
+
+          check_indentation(opening_line_start(node.loc.begin), node.children.first)
+        end
+
         def on_block(node)
           end_loc = node.loc.end
 
@@ -185,7 +206,16 @@ 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,
+        # used as the base to indent the body from.
+        def opening_line_start(begin_loc)
+          column = begin_loc.source_line =~ /\S/
+          source_range(processed_source.buffer, begin_loc.line, column)
         end
 
         def check_members(base, members)

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

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

@@ -73,7 +73,12 @@ module RuboCop
         end
 
         def find_pair_ancestor(node)
-          node.each_ancestor.find(&:pair_type?)
+          node.each_ancestor do |ancestor|
+            return ancestor if ancestor.pair_type?
+            break if grouped_expression?(ancestor) || inside_arg_list_parentheses?(node, ancestor)
+          end
+
+          nil
         end
 
         def unwrap_block_node(node)
@@ -405,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
@@ -417,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?

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

@@ -204,10 +204,14 @@ module RuboCop
 
         def autocorrect(corrector, range, right_operand)
           range_source = range.source
+          # Match the operator exactly, not by substring, so compound assignments
+          # like `**=` and `/=` are not mistaken for `**` and `/` (which would drop
+          # the `=` and silently change the program's behavior).
+          operator = range_source.strip
 
-          if range_source.include?('**') && !space_around_exponent_operator?
+          if operator == '**' && !space_around_exponent_operator?
             corrector.replace(range, '**')
-          elsif range_source.include?('/') && !space_around_slash_operator?(right_operand)
+          elsif operator == '/' && !space_around_slash_operator?(right_operand)
             corrector.replace(range, '/')
           elsif range_source.end_with?("\n")
             corrector.replace(range, " #{range_source.strip}\n")

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

@@ -94,10 +94,10 @@ module RuboCop
             return empty_offenses(node, left, right, EMPTY_MSG)
           end
 
-          start_ok = next_to_newline?(node, left)
+          start_ok = next_to_newline?(tokens, left)
           end_ok = node.single_line? ? false : end_has_own_line?(right)
 
-          issue_offenses(node, left, right, start_ok, end_ok)
+          issue_offenses(node, tokens, left, right, start_ok, end_ok)
         end
         alias on_array_pattern on_array
 
@@ -117,7 +117,7 @@ module RuboCop
           elsif style == :space
             SpaceCorrector.add_space(processed_source, corrector, left, right)
           else
-            compact_corrections(corrector, node, left, right)
+            compact_corrections(corrector, tokens, left, right)
           end
         end
 
@@ -134,8 +134,8 @@ module RuboCop
           cop_config['EnforcedStyleForEmptyBrackets']
         end
 
-        def next_to_newline?(node, token)
-          processed_source.tokens_within(node)[index_for(node, token) + 1].line != token.line
+        def next_to_newline?(tokens, token)
+          tokens[index_for(tokens, token) + 1].line != token.line
         end
 
         def end_has_own_line?(token)
@@ -145,68 +145,67 @@ module RuboCop
           !/\S/.match?(processed_source.lines[line][0..col])
         end
 
-        def index_for(node, token)
-          processed_source.tokens_within(node).index(token)
+        def index_for(tokens, token)
+          tokens.index(token)
         end
 
         def line_and_column_for(token)
           [token.line - 1, token.column - 1]
         end
 
-        def issue_offenses(node, left, right, start_ok, end_ok)
+        # rubocop:disable Metrics/ParameterLists
+        def issue_offenses(node, tokens, left, right, start_ok, end_ok)
           case style
           when :no_space
-            start_ok = next_to_comment?(node, left)
+            start_ok = next_to_comment?(tokens, left)
             no_space_offenses(node, left, right, MSG, start_ok: start_ok, end_ok: end_ok)
           when :space
             space_offenses(node, left, right, MSG, start_ok: start_ok, end_ok: end_ok)
           else
-            compact_offenses(node, left, right, start_ok, end_ok)
+            compact_offenses(node, tokens, left, right, start_ok, end_ok)
           end
         end
+        # rubocop:enable Metrics/ParameterLists
 
-        def next_to_comment?(node, token)
-          processed_source.tokens_within(node)[index_for(node, token) + 1].comment?
+        def next_to_comment?(tokens, token)
+          tokens[index_for(tokens, token) + 1].comment?
         end
 
-        def compact_offenses(node, left, right, start_ok, end_ok)
-          if qualifies_for_compact?(node, left, side: :left)
+        # rubocop:disable Metrics/ParameterLists
+        def compact_offenses(node, tokens, left, right, start_ok, end_ok)
+          if qualifies_for_compact?(tokens, left, side: :left)
             compact_offense(node, left, side: :left)
-          elsif !multi_dimensional_array?(node, left, side: :left)
+          elsif !multi_dimensional_array?(tokens, left, side: :left)
             space_offenses(node, left, nil, MSG, start_ok: start_ok, end_ok: true)
           end
-          if qualifies_for_compact?(node, right)
+
+          if qualifies_for_compact?(tokens, right)
             compact_offense(node, right)
-          elsif !multi_dimensional_array?(node, right)
+          elsif !multi_dimensional_array?(tokens, right)
             space_offenses(node, nil, right, MSG, start_ok: true, end_ok: end_ok)
           end
         end
+        # rubocop:enable Metrics/ParameterLists
 
-        def qualifies_for_compact?(node, token, side: :right)
+        def qualifies_for_compact?(tokens, token, side: :right)
           if side == :right
-            multi_dimensional_array?(node, token) && token.space_before?
+            multi_dimensional_array?(tokens, token) && token.space_before?
           else
-            multi_dimensional_array?(node, token, side: :left) && token.space_after?
+            multi_dimensional_array?(tokens, token, side: :left) && token.space_after?
           end
         end
 
-        def multi_dimensional_array?(node, token, side: :right)
+        def multi_dimensional_array?(tokens, token, side: :right)
           offset = side == :right ? -1 : +1
-          i = index_for(node, token) + offset
-          i += offset while processed_source.tokens_within(node)[i].new_line?
+          i = index_for(tokens, token) + offset
+          i += offset while tokens[i].new_line?
           if side == :right
-            processed_source.tokens_within(node)[i].right_bracket?
+            tokens[i].right_bracket?
           else
-            processed_source.tokens_within(node)[i].left_bracket?
+            tokens[i].left_bracket?
           end
         end
 
-        def next_to_bracket?(token, side: :right)
-          line_index, col = line_and_column_for(token)
-          line = processed_source.lines[line_index]
-          side == :right ? line[col] == ']' : line[col + 2] == '['
-        end
-
         def compact_offense(node, token, side: :right)
           if side == :right
             space_offense(node, token, :left, MSG, NO_SPACE_COMMAND)
@@ -215,14 +214,14 @@ module RuboCop
           end
         end
 
-        def compact_corrections(corrector, node, left, right)
-          if multi_dimensional_array?(node, left, side: :left)
+        def compact_corrections(corrector, tokens, left, right)
+          if multi_dimensional_array?(tokens, left, side: :left)
             compact(corrector, left, :right)
           elsif !left.space_after?
             corrector.insert_after(left.pos, ' ')
           end
 
-          if multi_dimensional_array?(node, right)
+          if multi_dimensional_array?(tokens, right)
             compact(corrector, right, :left)
           elsif !right.space_before?
             corrector.insert_before(right.pos, ' ')