rubocop 1.81.7 → 1.92.1

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

@@ -49,10 +49,16 @@ module RuboCop
       class RedundantLineBreak < Base
         include CheckAssignment
         include CheckSingleLineSuitability
+        include ReparsedEquivalence
         extend AutoCorrector
 
         MSG = 'Redundant line break detected.'
 
+        def on_new_investigation
+          super
+          @offense_line_ranges = []
+        end
+
         def on_lvasgn(node)
           super unless end_with_percent_blank_string?(processed_source)
         end
@@ -76,16 +82,108 @@ module RuboCop
         end
 
         def check_assignment(node, _rhs)
-          return unless offense?(node)
+          return unless offense?(node) && !part_of_ignored_node?(node)
 
           register_offense(node)
         end
 
         def register_offense(node)
+          line_range = joined_line_range(node)
+          return if too_long_as_single_line?(line_range)
+
+          # 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)
+          @offense_line_ranges.reject! { |range| line_range.cover?(range) }
+          @offense_line_ranges << line_range
+        end
+
+        # Offenses registered in the same pass that share a line with `node`
+        # get joined onto that line too, so the combined line has to fit.
+        def joined_line_range(node)
+          sharing_ranges = @offense_line_ranges.select do |range|
+            range.begin <= node.last_line && node.first_line <= range.end
+          end
+          lines = [node.first_line, node.last_line, *sharing_ranges.flat_map(&:minmax)]
+
+          lines.min..lines.max
+        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)
@@ -114,7 +212,9 @@ module RuboCop
 
         def other_cop_takes_precedence?(node)
           single_line_block_chain_enabled? && any_descendant?(node, :any_block) do |block_node|
-            block_node.parent.send_type? && block_node.parent.loc.dot && !block_node.multiline?
+            next unless (parent = block_node.parent)
+
+            parent.call_type? && parent.loc.dot && block_node.single_line?
           end
         end
 

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

@@ -22,6 +22,7 @@ module RuboCop
       #     puts 'error'
       #   end
       class RescueEnsureAlignment < Base
+        include Alignment
         include RangeHelp
         include EndKeywordAlignment
         extend AutoCorrector
@@ -29,7 +30,7 @@ module RuboCop
         MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
               'aligned with `%<beginning>s` at ' \
               '%<begin_loc_line>d, %<begin_loc_column>d.'
-        ANCESTOR_TYPES = %i[kwbegin any_def class module any_block].freeze
+        ANCESTOR_TYPES = %i[kwbegin any_def class module sclass any_block].freeze
         ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method private_class_method].freeze
 
         def on_resbody(node)
@@ -74,9 +75,10 @@ module RuboCop
           # Some inline node is sitting before current node.
           return nil unless whitespace.source.strip.empty?
 
-          new_column = alignment_location.column
+          indentation = alignment_indentation(alignment_location)
+          return nil if indentation.nil?
 
-          corrector.replace(whitespace, ' ' * new_column)
+          corrector.replace(whitespace, indentation)
         end
 
         def format_message(alignment_node, alignment_loc, kw_loc)
@@ -91,7 +93,18 @@ module RuboCop
           )
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # A run of spaces sized to the target column would be turned back into tabs by
+        # `Layout/IndentationStyle`, generally landing on a different column, so under
+        # tabs the target line's own indentation is reused. There is nothing to reuse
+        # when the target does not start its line.
+        def alignment_indentation(location)
+          return ' ' * location.column unless using_tabs?
+          return unless begins_its_line?(location)
+
+          location.source_line[/\A\s*/]
+        end
+
+        # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
@@ -100,6 +113,8 @@ module RuboCop
             when :def, :defs, :class, :module,
                  :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
               node.loc.name
+            when :sclass
+              node.identifier.source_range
             when :masgn
               node.lhs.source_range
             else
@@ -109,7 +124,6 @@ module RuboCop
 
           range_between(starting_loc.begin_pos, ending_loc.end_pos).source
         end
-        # rubocop:enable Metrics/AbcSize
 
         # We will use ancestor or wrapper with access modifier.
 

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

@@ -25,13 +25,17 @@ module RuboCop
 
         MSG = 'Put method call on a separate line if chained to a single line block.'
 
+        # These cops rewrite a method chained to the block in the same pass,
+        # which must not start a line of its own.
         def self.autocorrect_incompatible_with
-          [Style::MapToHash]
+          [Style::FloatDivision, Style::MapToHash, Style::NilComparison, Style::RedundantSort]
         end
 
         def on_send(node)
           range = offending_range(node)
-          add_offense(range) { |corrector| corrector.insert_before(range, "\n") } if range
+          return if !range || heredoc_opened_before?(node.receiver, range)
+
+          add_offense(range) { |corrector| corrector.insert_before(range, "\n") }
         end
         alias on_csend on_send
 
@@ -63,6 +67,10 @@ module RuboCop
           # l.(1) has no selector, so we use the opening parenthesis instead
           node.loc.selector || node.loc.begin
         end
+
+        def heredoc_opened_before?(receiver, range)
+          receiver.each_node(:any_str).any? { |str| str.heredoc? && str.first_line == range.line }
+        end
       end
     end
   end

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

@@ -23,16 +23,8 @@ module RuboCop
           cfg['EnforcedStyle'] || 'space'
         end
 
-        def kind(token)
-          'comma' if token.comma? && !before_semicolon?(token)
-        end
-
-        private
-
-        def before_semicolon?(token)
-          tokens = processed_source.tokens
-
-          tokens[tokens.index(token) + 1].semicolon?
+        def kind(token, next_token)
+          'comma' if token.comma? && !next_token.semicolon?
         end
       end
     end

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

@@ -20,6 +20,7 @@ module RuboCop
 
         def on_send(node)
           return unless node.prefix_bang? && whitespace_after_operator?(node)
+          return if unary_tilde?(node.receiver)
 
           add_offense(node) do |corrector|
             corrector.remove(
@@ -33,6 +34,10 @@ module RuboCop
         def whitespace_after_operator?(node)
           node.receiver.source_range.begin_pos - node.source_range.begin_pos > 1
         end
+
+        def unary_tilde?(receiver)
+          receiver.send_type? && receiver.unary_operation? && receiver.method?(:~)
+        end
       end
     end
   end

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

@@ -20,7 +20,7 @@ module RuboCop
           cfg['EnforcedStyle'] || 'space'
         end
 
-        def kind(token)
+        def kind(token, _next_token)
           'semicolon' if token.semicolon?
         end
 

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

@@ -5,7 +5,9 @@ module RuboCop
     module Layout
       # Checks the spacing inside and after block parameters pipes. Line breaks
       # inside parameter pipes are checked by `Layout/MultilineBlockLayout` and
-      # not by this cop.
+      # not by this cop. Spaces inside a lambda's parameter parentheses are left
+      # to `Layout/SpaceInsideParens` when that cop is enabled, so the examples
+      # below apply to a lambda only when it is not.
       #
       # @example EnforcedStyleInsidePipes: no_space (default)
       #   # bad
@@ -29,12 +31,12 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- checks spacing inside a block parameter list
           arguments = node.arguments
 
           return unless node.arguments? && pipes?(arguments)
 
-          check_inside_pipes(arguments)
+          check_inside_pipes(arguments) unless checked_by_space_inside_parens?(arguments)
           check_after_closing_pipe(arguments) if node.body
           check_each_arg(arguments)
         end
@@ -53,6 +55,10 @@ module RuboCop
           'EnforcedStyleInsidePipes'
         end
 
+        def checked_by_space_inside_parens?(arguments)
+          arguments.loc.begin.source == '(' && config.cop_enabled?('Layout/SpaceInsideParens')
+        end
+
         def check_inside_pipes(arguments)
           case style
           when :no_space
@@ -142,7 +148,7 @@ module RuboCop
             if node
               corrector.insert_before(node, ' ')
             else
-              corrector.insert_after(target, ' ')
+              corrector.insert_after(range_between(space_begin_pos, space_begin_pos), ' ')
             end
           end
         end

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

@@ -47,9 +47,11 @@ module RuboCop
           check(node, [:operator].freeze) if node.keyword?
         end
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node)
           check(node, %i[begin end].freeze)
         end
+        alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_break(node)
           check(node, [:keyword].freeze)
@@ -167,7 +169,7 @@ module RuboCop
 
         def check(node, locations, begin_keyword = DO)
           locations.each do |loc|
-            next unless node.loc.respond_to?(loc)
+            next unless node.loc?(loc)
 
             range = node.loc.public_send(loc)
             next unless range
@@ -207,6 +209,7 @@ module RuboCop
           end
 
           return unless space_after_missing?(range)
+          return if block_brace_with_no_space_style?(node, range)
 
           add_offense(range, message: format(MSG_AFTER, range: range.source)) do |corrector|
             corrector.insert_after(range, ' ')
@@ -231,6 +234,15 @@ module RuboCop
           !/[\s;,#\\)}\].]/.match?(char)
         end
 
+        def block_brace_with_no_space_style?(node, range)
+          return false unless (parent = node.parent)
+          return false unless parent.any_block_type? && parent.loc.begin&.begin_pos == range.end_pos
+
+          space_before_block_braces_config = config.for_cop('Layout/SpaceBeforeBlockBraces')
+          space_before_block_braces_config.fetch('Enabled', true) &&
+            space_before_block_braces_config['EnforcedStyle'] == 'no_space'
+        end
+
         def accepted_opening_delimiter?(range, char)
           return true unless char
 

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

@@ -129,6 +129,12 @@ module RuboCop
           check_operator(:class, node.loc.operator, rhs)
         end
 
+        def on_def(node)
+          return unless node.endless?
+
+          check_operator(:assignment, node.loc.assignment, node.body)
+        end
+
         def on_binary(node)
           rhs = node.rhs
 
@@ -170,6 +176,7 @@ module RuboCop
         alias on_or_asgn  on_assignment
         alias on_and_asgn on_assignment
         alias on_op_asgn  on_assignment
+        alias on_defs     on_def
 
         private
 
@@ -204,10 +211,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")
@@ -247,7 +258,7 @@ module RuboCop
           return false unless allow_for_alignment?
           return false unless with_space.source.start_with?(EXCESSIVE_SPACE)
 
-          return !aligned_with_operator?(operator) unless type == :assignment
+          return !aligned_with_operator?(operator) unless grouped_alignment_type?(type)
 
           token            = Token.new(operator, nil, operator.source)
           align_preceding  = aligned_with_preceding_equals_operator(token)
@@ -258,6 +269,10 @@ module RuboCop
           aligned_with_subsequent_equals_operator(token) != :yes
         end
 
+        def grouped_alignment_type?(type)
+          type == :assignment || (type == :special_asgn && force_equal_sign_alignment?)
+        end
+
         def excess_trailing_space?(right_operand, with_space)
           with_space.source.end_with?(EXCESSIVE_SPACE) &&
             (!allow_for_alignment? || !aligned_with_something?(right_operand))

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

@@ -49,8 +49,11 @@ module RuboCop
         MISSING_MSG = 'Space missing to the left of {.'
         DETECTED_MSG = 'Space detected to the left of {.'
 
+        # `Style/BlockDelimiters` decides whether to put a space before the `do`
+        # it writes by looking at the source before this cop removed the space,
+        # so the two corrections cannot be applied in the same pass.
         def self.autocorrect_incompatible_with
-          [Style::SymbolProc]
+          [Style::BlockDelimiters, Style::SymbolProc]
         end
 
         def on_block(node)

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

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

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

@@ -7,18 +7,18 @@ module RuboCop
       # parenthesis (`(`) in lambda literals.
       #
       # @example EnforcedStyle: require_no_space (default)
-      #     # bad
-      #     a = -> (x, y) { x + y }
+      #   # bad
+      #   a = -> (x, y) { x + y }
       #
-      #     # good
-      #     a = ->(x, y) { x + y }
+      #   # good
+      #   a = ->(x, y) { x + y }
       #
       # @example EnforcedStyle: require_space
-      #     # bad
-      #     a = ->(x, y) { x + y }
+      #   # bad
+      #   a = ->(x, y) { x + y }
       #
-      #     # good
-      #     a = -> (x, y) { x + y }
+      #   # good
+      #   a = -> (x, y) { x + y }
       class SpaceInLambdaLiteral < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
@@ -26,6 +26,7 @@ module RuboCop
 
         MSG_REQUIRE_SPACE = 'Use a space between `->` and `(` in lambda literals.'
         MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and `(` in lambda literals.'
+        RESTRICT_ON_SEND = %i[lambda].freeze
 
         def on_send(node)
           return unless arrow_lambda_with_args?(node)

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, node, 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-next 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
 
-        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-next 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)
+
+          return if closing_bracket_kept_apart?(node, tokens, left, 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
 
-        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,25 @@ module RuboCop
           end
         end
 
-        def compact_corrections(corrector, node, left, right)
-          if multi_dimensional_array?(node, left, side: :left)
+        # A closing bracket on its own line is only collapsed when the opening
+        # bracket ends up on the first element's line, so that the brackets
+        # stay symmetrical (see `Layout/MultilineArrayBraceLayout`).
+        def closing_bracket_kept_apart?(node, tokens, left, right)
+          end_has_own_line?(right) &&
+            !multi_dimensional_array?(tokens, left, side: :left) &&
+            !same_line?(left, node.children.first)
+        end
+
+        def compact_corrections(corrector, node, 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)
+          return if closing_bracket_kept_apart?(node, tokens, left, right)
+
+          if multi_dimensional_array?(tokens, right)
             compact(corrector, right, :left)
           elsif !right.space_before?
             corrector.insert_before(right.pos, ' ')