rubocop 1.71.1 → 1.92.0

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

@@ -6,25 +6,29 @@ module RuboCop
       # Checks whether certain expressions, e.g. method calls, that could fit
       # completely on a single line, are broken up into multiple lines unnecessarily.
       #
-      # @example any configuration
+      # @example
       #   # bad
       #   foo(
       #     a,
       #     b
       #   )
       #
+      #   # good
+      #   foo(a, b)
+      #
+      #   # bad
       #   puts 'string that fits on ' \
       #        'a single line'
       #
+      #   # good
+      #   puts 'string that fits on a single line'
+      #
+      #   # bad
       #   things
       #     .select { |thing| thing.cond? }
       #     .join('-')
       #
       #   # good
-      #   foo(a, b)
-      #
-      #   puts 'string that fits on a single line'
-      #
       #   things.select { |thing| thing.cond? }.join('-')
       #
       # @example InspectBlocks: false (default)
@@ -45,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
@@ -72,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)
@@ -110,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,8 +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 def defs class module any_block].freeze
-        ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = %i[def defs].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)
@@ -75,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)
@@ -92,15 +93,28 @@ 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
-            when :block, :numblock, :kwbegin
+            when :block, :numblock, :itblock, :kwbegin
               node.loc.begin
             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
@@ -110,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.
 
@@ -162,8 +175,7 @@ module RuboCop
         end
 
         def access_modifier_node(node)
-          return nil unless
-            ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS.include?(node.type)
+          return nil unless node.any_def_type?
 
           access_modifier_node = node.ancestors.first
           return nil unless access_modifier?(access_modifier_node)
@@ -196,6 +208,14 @@ module RuboCop
         def alignment_location(alignment_node)
           if begin_end_alignment_style == 'start_of_line'
             start_line_range(alignment_node)
+          elsif alignment_node.any_block_type?
+            # If the alignment node is a block, the `rescue`/`ensure` keyword should
+            # be aligned to the start of the block. It is possible that the block's
+            # `send_node` spans multiple lines, in which case it should align to the
+            # start of the last line.
+            send_node = alignment_node.send_node
+            range = processed_source.buffer.line_range(send_node.last_line)
+            range.adjust(begin_pos: range.source =~ /\S/)
           else
             alignment_node.source_range
           end

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.'
 
+        # `Style/FloatDivision` and `Style/NilComparison` 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]
         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,9 +20,19 @@ module RuboCop
           cfg['EnforcedStyle'] || 'space'
         end
 
-        def kind(token)
+        def kind(token, _next_token)
           'semicolon' if token.semicolon?
         end
+
+        def space_missing?(token1, token2)
+          super && !semicolon_sequence?(token1, token2)
+        end
+
+        private
+
+        def semicolon_sequence?(token, next_token)
+          token.semicolon? && next_token.semicolon?
+        end
       end
     end
   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

@@ -16,6 +16,8 @@ module RuboCop
       #
       #   something = 123if test
       #
+      #   return(foo + bar)
+      #
       #   # good
       #   something 'test' do |x|
       #   end
@@ -24,6 +26,9 @@ module RuboCop
       #   end
       #
       #   something = 123 if test
+      #
+      #   return (foo + bar)
+      #
       class SpaceAroundKeyword < Base
         extend AutoCorrector
 
@@ -33,7 +38,7 @@ module RuboCop
         DO = 'do'
         SAFE_NAVIGATION = '&.'
         NAMESPACE_OPERATOR = '::'
-        ACCEPT_LEFT_PAREN = %w[break defined? next not rescue return super yield].freeze
+        ACCEPT_LEFT_PAREN = %w[break defined? next not rescue super yield].freeze
         ACCEPT_LEFT_SQUARE_BRACKET = %w[super yield].freeze
         ACCEPT_NAMESPACE_OPERATOR = 'super'
         RESTRICT_ON_SEND = %i[!].freeze
@@ -42,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)
@@ -162,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
@@ -202,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, ' ')
@@ -226,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_method_call_operator.rb

@@ -51,7 +51,7 @@ module RuboCop
         alias on_csend on_send
 
         def on_const(node)
-          return unless node.loc.respond_to?(:double_colon) && node.loc.double_colon
+          return unless node.loc?(:double_colon)
 
           check_space_after_double_colon(node)
         end

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
 
@@ -151,6 +157,14 @@ module RuboCop
           check_operator(:match_pattern, node.loc.operator, node)
         end
 
+        def on_match_alt(node)
+          check_operator(:match_alt, node.loc.operator, node)
+        end
+
+        def on_match_as(node)
+          check_operator(:match_as, node.loc.operator, node)
+        end
+
         alias on_or       on_binary
         alias on_and      on_binary
         alias on_lvasgn   on_assignment
@@ -162,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
 
@@ -196,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")
@@ -239,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)
@@ -250,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))
@@ -260,7 +283,10 @@ module RuboCop
         end
 
         def hash_table_style?
-          align_hash_cop_config && align_hash_cop_config['EnforcedHashRocketStyle'] == 'table'
+          return false unless align_hash_cop_config
+
+          enforced_styles = Array(align_hash_cop_config['EnforcedHashRocketStyle'])
+          enforced_styles.include?('table')
         end
 
         def space_around_exponent_operator?

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)
@@ -77,6 +80,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

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
       #
@@ -22,50 +22,17 @@ module RuboCop
         RESTRICT_ON_SEND = %i[[] []=].freeze
 
         def on_send(node)
-          return unless (first_argument = node.first_argument)
+          return if node.loc.dot
 
-          begin_pos = first_argument.source_range.begin_pos
-          return unless (range = offense_range(node, begin_pos))
-
-          register_offense(range)
-        end
-
-        private
-
-        def offense_range(node, begin_pos)
           receiver_end_pos = node.receiver.source_range.end_pos
           selector_begin_pos = node.loc.selector.begin_pos
           return if receiver_end_pos >= selector_begin_pos
-          return if dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
-
-          if reference_variable_with_brackets?(node)
-            range_between(receiver_end_pos, selector_begin_pos)
-          elsif node.method?(:[]=)
-            offense_range_for_assignment(node, begin_pos)
-          end
-        end
-
-        def dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
-          return false unless node.loc.respond_to?(:dot) && (dot = node.loc.dot)
 
-          dot.begin_pos == receiver_end_pos && dot.end_pos == selector_begin_pos
-        end
-
-        def offense_range_for_assignment(node, begin_pos)
-          end_pos = node.receiver.source_range.end_pos
-
-          return if begin_pos - end_pos == 1 ||
-                    (range = range_between(end_pos, begin_pos - 1)).source.start_with?('[')
-
-          range
-        end
-
-        def register_offense(range)
-          add_offense(range) { |corrector| corrector.remove(range) }
-        end
+          range = range_between(receiver_end_pos, selector_begin_pos)
 
-        def reference_variable_with_brackets?(node)
-          node.receiver&.variable? && node.method?(:[]) && node.arguments.size == 1
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
         end
       end
     end