rubocop 1.53.0 → 1.90.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)
@@ -44,10 +48,16 @@ module RuboCop
       #
       class RedundantLineBreak < Base
         include CheckAssignment
+        include CheckSingleLineSuitability
+        include ReparsedEquivalence
         extend AutoCorrector
 
         MSG = 'Redundant line break detected.'
 
+        def on_lvasgn(node)
+          super unless end_with_percent_blank_string?(processed_source)
+        end
+
         def on_send(node)
           # Include "the whole expression".
           node = node.parent while node.parent&.send_type? ||
@@ -58,9 +68,14 @@ module RuboCop
 
           register_offense(node)
         end
+        alias on_csend on_send
 
         private
 
+        def end_with_percent_blank_string?(processed_source)
+          processed_source.buffer.source.end_with?("%\n\n")
+        end
+
         def check_assignment(node, _rhs)
           return unless offense?(node)
 
@@ -68,69 +83,129 @@ 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 offense?(node)
-          node.multiline? && !too_long?(node) && suitable_as_single_line?(node) &&
-            !configured_to_not_be_inspected?(node)
+        def apply_reparse_correction(corrector, node)
+          corrector.replace(node, to_single_line(node.source).strip)
         end
 
-        def configured_to_not_be_inspected?(node)
-          return true if other_cop_takes_precedence?(node)
+        # 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
 
-          !cop_config['InspectBlocks'] && (node.block_type? ||
-                                           any_descendant?(node, :block, &:multiline?))
+        def normalize_reparsed_ast(node)
+          fold_string_concatenation(node)
         end
 
-        def other_cop_takes_precedence?(node)
-          single_line_block_chain_enabled? && any_descendant?(node, :block) do |block_node|
-            block_node.parent.send_type? && block_node.parent.loc.dot && !block_node.multiline?
+        # 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 single_line_block_chain_enabled?
-          @config.for_cop('Layout/SingleLineBlockChain')['Enabled']
+        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 suitable_as_single_line?(node)
-          !comment_within?(node) &&
-            node.each_descendant(:if, :case, :kwbegin, :def).none? &&
-            node.each_descendant(:dstr, :str).none? { |n| n.heredoc? || n.value.include?("\n") } &&
-            node.each_descendant(:begin).none? { |b| !b.single_line? }
+        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 convertible_block?(node)
-          parent = node.parent
-          parent&.block_type? && node == parent.send_node &&
-            (node.parenthesized? || !node.arguments?)
+        def merge_plain_strings(chunk)
+          return chunk.first if chunk.one?
+
+          chunk.first.updated(:str, [chunk.map { |part| part.children.first }.join])
         end
 
-        def comment_within?(node)
-          processed_source.comments.map(&:loc).map(&:line).any? do |comment_line_number|
-            comment_line_number >= node.first_line && comment_line_number <= node.last_line
-          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?
+
+          !index_access_call_chained?(node) && !configured_to_not_be_inspected?(node)
+        end
+
+        def require_backslash?(node)
+          processed_source.lines[node.loc.operator.line - 1].end_with?('\\')
+        end
+
+        def index_access_call_chained?(node)
+          return false unless node.send_type? && node.method?(:[])
+
+          node.children.first.send_type? && node.children.first.method?(:[])
         end
 
-        def too_long?(node)
-          lines = processed_source.lines[(node.first_line - 1)...node.last_line]
-          to_single_line(lines.join("\n")).length > max_line_length
+        def configured_to_not_be_inspected?(node)
+          return true if other_cop_takes_precedence?(node)
+          return false if cop_config['InspectBlocks']
+
+          node.any_block_type? || any_descendant?(node, :any_block, &:multiline?)
         end
 
-        def to_single_line(source)
-          source
-            .gsub(/" *\\\n\s*'/, %q(" + ')) # Double quote, backslash, and then single quote
-            .gsub(/' *\\\n\s*"/, %q(' + ")) # Single quote, backslash, and then double quote
-            .gsub(/(["']) *\\\n\s*\1/, '')  # Double or single quote, backslash, then same quote
-            .gsub(/\n\s*(?=\.\w)/, '')      # Extra space within method chaining
-            .gsub(/\s*\\?\n\s*/, ' ')       # Any other line break, with or without backslash
+        def other_cop_takes_precedence?(node)
+          single_line_block_chain_enabled? && any_descendant?(node, :any_block) do |block_node|
+            next unless (parent = block_node.parent)
+
+            parent.call_type? && parent.loc.dot && block_node.single_line?
+          end
         end
 
-        def max_line_length
-          config.for_cop('Layout/LineLength')['Max']
+        def single_line_block_chain_enabled?
+          @config.cop_enabled?('Layout/SingleLineBlockChain')
+        end
+
+        def convertible_block?(node)
+          return false unless (parent = node.parent)
+
+          parent.any_block_type? && node == parent.send_node &&
+            (node.parenthesized? || !node.arguments?)
         end
       end
     end

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

@@ -29,8 +29,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 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)
@@ -92,20 +91,22 @@ module RuboCop
           )
         end
 
+        # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
-            when :block, :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
-              mlhs_node, = *node
-              mlhs_node.source_range
+              node.lhs.source_range
             else
-              # It is a wrapper with access modifier.
-              node.child_nodes.first.loc.name
+              # It is a wrapper with receiver of object attribute or access modifier.
+              node.receiver&.source_range || node.child_nodes.first.loc.name
             end
 
           range_between(starting_loc.begin_pos, ending_loc.end_pos).source
@@ -161,8 +162,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)
@@ -195,6 +195,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,16 +25,21 @@ module RuboCop
 
         MSG = 'Put method call on a separate line if chained to a single line block.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MapToHash]
+        end
+
         def on_send(node)
           range = offending_range(node)
           add_offense(range) { |corrector| corrector.insert_before(range, "\n") } if range
         end
+        alias on_csend on_send
 
         private
 
         def offending_range(node)
           receiver = node.receiver
-          return unless receiver&.block_type?
+          return unless receiver&.any_block_type?
 
           receiver_location = receiver.loc
           closing_block_delimiter_line_num = receiver_location.end.line

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

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for colon (:) not followed by some kind of space.
+      # Checks for colon (`:`) not followed by some kind of space.
       # N.B. this cop does not handle spaces after a ternary operator, which are
-      # instead handled by Layout/SpaceAroundOperators.
+      # instead handled by `Layout/SpaceAroundOperators`.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for comma (,) not followed by some kind of space.
+      # Checks for comma (`,`) not followed by some kind of space.
       #
       # @example
       #
@@ -23,8 +23,8 @@ module RuboCop
           cfg['EnforcedStyle'] || 'space'
         end
 
-        def kind(token)
-          'comma' if token.comma?
+        def kind(token, next_token)
+          'comma' if token.comma? && !next_token.semicolon?
         end
       end
     end

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

@@ -22,7 +22,7 @@ module RuboCop
 
         def on_def(node)
           args = node.arguments
-          return unless args.loc.begin&.is?('(')
+          return unless args.parenthesized_call?
 
           expr = args.source_range
           pos_before_left_paren = range_between(expr.begin_pos - 1, expr.begin_pos)

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

@@ -31,7 +31,7 @@ module RuboCop
         private
 
         def whitespace_after_operator?(node)
-          node.receiver.loc.column - node.loc.column > 1
+          node.receiver.source_range.begin_pos - node.source_range.begin_pos > 1
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for semicolon (;) not followed by some kind of space.
+      # Checks for semicolon (`;`) not followed by some kind of space.
       #
       # @example
       #   # bad
@@ -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

@@ -29,7 +29,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           arguments = node.arguments
 
           return unless node.arguments? && pipes?(arguments)

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,17 +38,20 @@ 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
 
         def on_and(node)
           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)
@@ -161,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
@@ -256,7 +264,7 @@ module RuboCop
           # regular dotted method calls bind more tightly than operators
           # so we need to climb up the AST past them
           node.each_ancestor do |ancestor|
-            return true if ancestor.and_type? || ancestor.or_type? || ancestor.range_type?
+            return true if ancestor.operator_keyword? || ancestor.range_type?
             return false unless ancestor.send_type?
             return true if ancestor.operator_method?
           end

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

@@ -19,7 +19,7 @@ module RuboCop
       #   foo &. bar
       #   foo &. bar&. buzz
       #   RuboCop:: Cop
-      #   RuboCop:: Cop:: Cop
+      #   RuboCop:: Cop:: Base
       #   :: RuboCop::Cop
       #
       #   # good
@@ -31,7 +31,7 @@ module RuboCop
       #   foo&.bar
       #   foo&.bar&.buzz
       #   RuboCop::Cop
-      #   RuboCop::Cop::Cop
+      #   RuboCop::Cop::Base
       #   ::RuboCop::Cop
       #
       class SpaceAroundMethodCallOperator < Base
@@ -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