rubocop 1.67.0 → 1.75.7

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

@@ -58,6 +58,12 @@ module RuboCop
       #   attr_reader :name #: String
       #   attr_reader :age  #: Integer?
       #
+      #   #: (
+      #   #|   Integer,
+      #   #|   String
+      #   #| ) -> void
+      #   def foo; end
+      #
       # @example AllowRBSInlineAnnotation: true
       #
       #   # good
@@ -67,19 +73,46 @@ module RuboCop
       #   attr_reader :name #: String
       #   attr_reader :age  #: Integer?
       #
+      #   #: (
+      #   #|   Integer,
+      #   #|   String
+      #   #| ) -> void
+      #   def foo; end
+      #
+      # @example AllowSteepAnnotation: false (default)
+      #
+      #   # bad
+      #   [1, 2, 3].each_with_object([]) do |n, list| #$ Array[Integer]
+      #     list << n
+      #   end
+      #
+      #   name = 'John'      #: String
+      #
+      # @example AllowSteepAnnotation: true
+      #
+      #   # good
+      #
+      #   [1, 2, 3].each_with_object([]) do |n, list| #$ Array[Integer]
+      #     list << n
+      #   end
+      #
+      #   name = 'John'      #: String
+      #
       class LeadingCommentSpace < Base
         include RangeHelp
         extend AutoCorrector
 
         MSG = 'Missing space after `#`.'
 
-        def on_new_investigation # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        def on_new_investigation # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           processed_source.comments.each do |comment|
             next unless /\A(?!#\+\+|#--)(#+[^#\s=])/.match?(comment.text)
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
+            next if shebang_continuation?(comment)
             next if doxygen_comment_style?(comment)
             next if gemfile_ruby_comment?(comment)
             next if rbs_inline_annotation?(comment)
+            next if steep_annotation?(comment)
 
             add_offense(comment) do |corrector|
               expr = comment.source_range
@@ -103,6 +136,20 @@ module RuboCop
           comment.text.start_with?('#!')
         end
 
+        def shebang_continuation?(comment)
+          return false unless shebang?(comment)
+          return true if comment.loc.line == 1
+
+          previous_line_comment = processed_source.comment_at_line(comment.loc.line - 1)
+          return false unless previous_line_comment
+
+          # If the comment is a shebang but not on the first line, check if the previous
+          # line has a shebang comment that wasn't marked as an offense; if so, this comment
+          # continues the shebang and is acceptable.
+          shebang?(previous_line_comment) &&
+            !current_offense_locations.include?(previous_line_comment.source_range)
+        end
+
         def rackup_options?(comment)
           comment.text.start_with?('#\\')
         end
@@ -140,7 +187,15 @@ module RuboCop
         end
 
         def rbs_inline_annotation?(comment)
-          allow_rbs_inline_annotation? && comment.text.start_with?(/#:|#\[.+\]/)
+          allow_rbs_inline_annotation? && comment.text.start_with?(/#:|#\[.+\]|#\|/)
+        end
+
+        def allow_steep_annotation?
+          cop_config['AllowSteepAnnotation']
+        end
+
+        def steep_annotation?(comment)
+          allow_steep_annotation? && comment.text.start_with?(/#[$:]/)
         end
       end
     end

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

@@ -51,6 +51,15 @@ module RuboCop
         private_constant :LINE_1_ENDING, :LINE_2_BEGINNING,
                          :LEADING_STYLE_OFFENSE, :TRAILING_STYLE_OFFENSE
 
+        # When both cops are activated and run in the same iteration of the correction loop,
+        # `Style/StringLiterals` undoes the moving of spaces that
+        # `Layout/LineContinuationLeadingSpace` performs. This is because `Style/StringLiterals`
+        # takes the original string content and transforms it, rather than just modifying the
+        # delimiters, in order to handle escaping for quotes within the string.
+        def self.autocorrect_incompatible_with
+          [Style::StringLiterals]
+        end
+
         def on_dstr(node)
           # Quick check if we possibly have line continuations.
           return unless node.source.include?('\\')
@@ -129,9 +138,9 @@ module RuboCop
 
         def message(_range)
           if enforced_style_leading?
-            'Move trailing spaces to the start of next line.'
+            'Move trailing spaces to the start of the next line.'
           else
-            'Move leading spaces to the end of previous line.'
+            'Move leading spaces to the end of the previous line.'
           end
         end
 

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

@@ -101,7 +101,7 @@ module RuboCop
               ranges << loc.expression
             elsif literal.heredoc?
               ranges << loc.heredoc_body
-            elsif loc.respond_to?(:begin) && loc.begin
+            elsif (loc.respond_to?(:begin) && loc.begin) || ignored_parent?(literal)
               ranges << loc.expression
             end
           end
@@ -127,6 +127,12 @@ module RuboCop
                               comment_ranges(processed_source.comments)
         end
 
+        def ignored_parent?(node)
+          return false unless node.parent
+
+          node.parent.type?(:regexp, :xstr)
+        end
+
         def no_space_style?
           cop_config['EnforcedStyle'] == 'no_space'
         end

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

@@ -102,7 +102,7 @@ module RuboCop
 
         def strings_concatenated_with_backslash?(dstr_node)
           dstr_node.multiline? &&
-            dstr_node.children.all? { |c| c.str_type? || c.dstr_type? } &&
+            dstr_node.children.all? { |c| c.type?(:str, :dstr) } &&
             dstr_node.children.none?(&:multiline?)
         end
 
@@ -127,7 +127,7 @@ module RuboCop
 
         def base_column(child)
           grandparent = child.parent.parent
-          if grandparent&.type == :pair
+          if grandparent&.pair_type?
             grandparent.loc.column
           else
             child.source_range.source_line =~ /\S/

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

@@ -38,7 +38,7 @@ module RuboCop
       # * `Layout/MultilineHashKeyLineBreaks`
       # * `Layout/MultilineMethodArgumentLineBreaks`
       # * `Layout/MultilineMethodParameterLineBreaks`
-      # * `Layout//ParameterAlignment`
+      # * `Layout/ParameterAlignment`
       # * `Style/BlockDelimiters`
       #
       # Together, these cops will pretty print hashes, arrays,
@@ -60,7 +60,7 @@ module RuboCop
       #     bar: "0000000000",
       #     baz: "0000000000",
       #   }
-      class LineLength < Base
+      class LineLength < Base # rubocop:disable Metrics/ClassLength
         include CheckLineBreakable
         include AllowedPattern
         include RangeHelp
@@ -74,8 +74,16 @@ module RuboCop
         def on_block(node)
           check_for_breakable_block(node)
         end
-
         alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_str(node)
+          check_for_breakable_str(node)
+        end
+
+        def on_dstr(node)
+          check_for_breakable_dstr(node)
+        end
 
         def on_potential_breakable_node(node)
           check_for_breakable_node(node)
@@ -83,7 +91,9 @@ module RuboCop
         alias on_array on_potential_breakable_node
         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_new_investigation
           return unless processed_source.raw_source.include?(';')
@@ -132,6 +142,42 @@ module RuboCop
           breakable_range_by_line_index[line_index] = range_between(pos, pos + 1)
         end
 
+        def check_for_breakable_str(node)
+          line_index = node.loc.line - 1
+          return if breakable_range_by_line_index[line_index]
+
+          return unless breakable_string?(node)
+          return unless (delimiter = string_delimiter(node))
+          return unless (pos = breakable_string_position(node))
+
+          breakable_range_by_line_index[line_index] = range_between(pos, pos + 1)
+          breakable_string_delimiters[line_index] = delimiter
+        end
+
+        def check_for_breakable_dstr(node) # rubocop:disable Metrics/AbcSize
+          line_index = node.loc.line - 1
+          return if breakable_range_by_line_index[line_index]
+
+          return unless breakable_dstr?(node)
+          return unless (delimiter = string_delimiter(node))
+
+          node.each_child_node(:begin).detect do |begin_node|
+            next unless (pos = breakable_dstr_begin_position(begin_node))
+
+            breakable_range_by_line_index[line_index] = range_between(pos, pos + 1)
+            breakable_string_delimiters[line_index] = delimiter
+          end
+        end
+
+        def breakable_string?(node)
+          allow_string_split? &&
+            node.single_line? &&
+            !node.heredoc? &&
+            # TODO: strings inside hashes, kwargs and arrays are currently ignored,
+            # but could be considered in the future
+            !node.parent&.type?(:pair, :kwoptarg, :array)
+        end
+
         def breakable_block_range(block_node)
           if block_node.arguments? && !block_node.lambda?
             block_node.arguments.loc.end
@@ -153,10 +199,47 @@ module RuboCop
           next_range
         end
 
+        def breakable_string_position(node)
+          source_range = node.source_range
+          return if source_range.last_column < max
+          return unless (pos = breakable_string_range(node))
+
+          pos.end_pos unless pos.end_pos == source_range.begin_pos
+        end
+
+        # Locate where to break a string that is too long, ensuring that escape characters
+        # are not bisected.
+        # If the string contains spaces, use them to determine a place for a clean break;
+        # otherwise, the string will be broken at the line length limit.
+        def breakable_string_range(node)
+          source_range = node.source_range
+          relevant_substr = largest_possible_string(node)
+
+          if (space_pos = relevant_substr.rindex(/\s/))
+            source_range.resize(space_pos + 1)
+          elsif (escape_pos = relevant_substr.rindex(/\\(u[\da-f]{0,4}|x[\da-f]{0,2})?\z/))
+            source_range.resize(escape_pos)
+          else
+            adjustment = max - source_range.last_column - 3
+            return if adjustment.abs > source_range.size
+
+            source_range.adjust(end_pos: adjustment)
+          end
+        end
+
+        def breakable_dstr_begin_position(node)
+          source_range = node.source_range
+          source_range.begin_pos if source_range.column < max && source_range.last_column >= max
+        end
+
         def breakable_range_by_line_index
           @breakable_range_by_line_index ||= {}
         end
 
+        def breakable_string_delimiters
+          @breakable_string_delimiters ||= {}
+        end
+
         def heredocs
           @heredocs ||= extract_heredocs(processed_source.ast)
         end
@@ -197,7 +280,14 @@ module RuboCop
 
           add_offense(loc, message: message) do |corrector|
             self.max = line_length(line)
-            corrector.insert_before(breakable_range, "\n") unless breakable_range.nil?
+
+            insertion = if (delimiter = breakable_string_delimiters[line_index])
+                          [delimiter, " \\\n", delimiter].join
+                        else
+                          "\n"
+                        end
+
+            corrector.insert_before(breakable_range, insertion) unless breakable_range.nil?
           end
         end
 
@@ -224,6 +314,10 @@ module RuboCop
           cop_config['AllowHeredoc']
         end
 
+        def allow_string_split?
+          cop_config['SplitStrings']
+        end
+
         def extract_heredocs(ast)
           return [] unless ast
 
@@ -270,6 +364,31 @@ module RuboCop
 
           register_offense(excess_range(uri_range, line, line_index), line, line_index)
         end
+
+        def breakable_dstr?(node)
+          # If the `dstr` only contains one child, it cannot be broken
+          breakable_string?(node) && !node.child_nodes.one?
+        end
+
+        def string_delimiter(node)
+          delimiter = node.loc.begin
+          if node.parent&.dstr_type? && node.parent.loc.respond_to?(:begin)
+            delimiter ||= node.parent.loc.begin
+          end
+          delimiter = delimiter&.source
+
+          delimiter if %w[' "].include?(delimiter)
+        end
+
+        # Find the largest possible substring of a string node to retain before a break
+        def largest_possible_string(node)
+          # 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 doesn't start at the beginning of the line, the max length is offset
+          max_length -= column_offset_between(node.loc, node.parent.loc) if node.parent
+          node.source[0...(max_length)]
+        end
       end
     end
   end

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

@@ -69,6 +69,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

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

@@ -52,7 +52,7 @@ module RuboCop
         def on_hash(node)
           # This cop only deals with hashes wrapped by a set of curly
           # braces like {foo: 1}. That is, not a kwargs hashes.
-          # Style/MultilineMethodArgumentLineBreaks handles those.
+          # Layout/MultilineMethodArgumentLineBreaks handles those.
           return unless starts_with_curly_brace?(node)
           return unless node.loc.begin
 

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

@@ -33,6 +33,18 @@ module RuboCop
       #
       # @example AllowMultilineFinalElement: false (default)
       #
+      #   # bad
+      #   foo(a, b,
+      #     c
+      #   )
+      #
+      #   # bad
+      #   foo(
+      #     a, b, {
+      #       foo: "bar",
+      #     }
+      #   )
+      #
       #   # good
       #   foo(
       #     a,
@@ -44,6 +56,18 @@ module RuboCop
       #
       # @example AllowMultilineFinalElement: true
       #
+      #   # bad
+      #   foo(a, b,
+      #     c
+      #   )
+      #
+      #   # good
+      #   foo(
+      #     a, b, {
+      #       foo: "bar",
+      #     }
+      #   )
+      #
       #   # good
       #   foo(
       #     a,
@@ -75,6 +99,7 @@ module RuboCop
 
           check_line_breaks(node, args, ignore_last: ignore_last_element?)
         end
+        alias on_csend on_send
 
         private
 

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

@@ -12,7 +12,7 @@ module RuboCop
       # argument of the call, then the closing brace should be on the same
       # line as the last argument of the call.
       #
-      # If an method call's opening brace is on the line above the first
+      # If a method call's opening brace is on the line above the first
       # argument of the call, then the closing brace should be on the line
       # below the last argument of the call.
       #
@@ -109,6 +109,7 @@ module RuboCop
         def on_send(node)
           check_brace_layout(node)
         end
+        alias on_csend on_send
 
         private
 

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

@@ -100,7 +100,7 @@ module RuboCop
 
         def extra_indentation(given_style, parent)
           if given_style == :indented_relative_to_receiver
-            if parent && (parent.splat_type? || parent.kwsplat_type?)
+            if parent&.type?(:splat, :kwsplat)
               configured_indentation_width - parent.loc.operator.length
             else
               configured_indentation_width
@@ -216,7 +216,7 @@ module RuboCop
 
         def get_dot_right_above(node)
           node.each_ancestor.find do |a|
-            dot = a.loc.respond_to?(:dot) && a.loc.dot
+            dot = a.loc.dot if a.loc?(:dot)
             next unless dot
 
             dot.line == node.loc.dot.line - 1 && dot.column == node.loc.dot.column
@@ -224,7 +224,7 @@ module RuboCop
         end
 
         def find_multiline_block_chain_node(node)
-          return unless (block_node = node.each_descendant(:block, :numblock).first)
+          return unless (block_node = node.each_descendant(:any_block).first)
           return unless block_node.multiline? && block_node.parent.call_type?
 
           if node.receiver.call_type?
@@ -239,7 +239,7 @@ module RuboCop
           node = node.receiver while node.receiver
           # ascend to first call which has a dot
           node = node.parent
-          node = node.parent until node.loc.respond_to?(:dot) && node.loc.dot
+          node = node.parent until node.loc?(:dot)
 
           node
         end

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

@@ -12,7 +12,7 @@ module RuboCop
       # first parameter of the definition, then the closing brace should be
       # on the same line as the last parameter of the definition.
       #
-      # If an method definition's opening brace is on the line above the first
+      # If a method definition's opening brace is on the line above the first
       # parameter of the definition, then the closing brace should be on the
       # line below the last parameter of the definition.
       #

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

@@ -65,6 +65,7 @@ module RuboCop
 
           check_line_breaks(node, node.arguments, ignore_last: ignore_last_element?)
         end
+        alias on_defs on_def
 
         private
 

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

@@ -76,9 +76,8 @@ module RuboCop
         end
 
         def check_and_or(node)
-          lhs, rhs = *node
-          range = offending_range(node, lhs, rhs.source_range, style)
-          check(range, node, lhs, rhs.source_range)
+          range = offending_range(node, node.lhs, node.rhs.source_range, style)
+          check(range, node, node.lhs, node.rhs.source_range)
         end
 
         def offending_range(node, lhs, rhs, given_style)
@@ -119,7 +118,7 @@ module RuboCop
         end
 
         def right_hand_side(send_node)
-          send_node.first_argument.source_range
+          send_node.first_argument&.source_range
         end
       end
     end

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

@@ -3,11 +3,10 @@
 module RuboCop
   module Cop
     module Layout
-      # Here we check if the parameters on a multi-line method call or
-      # definition are aligned.
+      # Check that the parameters on a multi-line method call or definition are aligned.
       #
-      # To set the alignment of the first argument, use the cop
-      # FirstParameterIndentation.
+      # To set the alignment of the first argument, use the
+      # `Layout/FirstParameterIndentation` cop.
       #
       # @example EnforcedStyle: with_first_parameter (default)
       #   # good

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,6 +48,7 @@ module RuboCop
       #
       class RedundantLineBreak < Base
         include CheckAssignment
+        include CheckSingleLineSuitability
         extend AutoCorrector
 
         MSG = 'Redundant line break detected.'
@@ -84,8 +89,8 @@ module RuboCop
         end
 
         def offense?(node)
-          return false if !node.multiline? || too_long?(node) || !suitable_as_single_line?(node)
-          return require_backslash?(node) if node.and_type? || node.or_type?
+          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
@@ -102,58 +107,26 @@ module RuboCop
 
         def configured_to_not_be_inspected?(node)
           return true if other_cop_takes_precedence?(node)
+          return false if cop_config['InspectBlocks']
 
-          !cop_config['InspectBlocks'] && (node.block_type? ||
-                                           any_descendant?(node, :block, &:multiline?))
+          node.any_block_type? || any_descendant?(node, :any_block, &:multiline?)
         end
 
         def other_cop_takes_precedence?(node)
-          single_line_block_chain_enabled? && any_descendant?(node, :block) do |block_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?
           end
         end
 
         def single_line_block_chain_enabled?
-          @config.for_cop('Layout/SingleLineBlockChain')['Enabled']
-        end
-
-        def suitable_as_single_line?(node)
-          !comment_within?(node) &&
-            node.each_descendant(:if, :case, :kwbegin, :def, :defs).none? &&
-            node.each_descendant(:dstr, :str).none? { |n| n.heredoc? || n.value.include?("\n") } &&
-            node.each_descendant(:begin, :sym).none? { |b| !b.single_line? }
+          @config.cop_enabled?('Layout/SingleLineBlockChain')
         end
 
         def convertible_block?(node)
-          parent = node.parent
-          parent&.block_type? && node == parent.send_node &&
-            (node.parenthesized? || !node.arguments?)
-        end
-
-        def comment_within?(node)
-          comment_line_numbers = processed_source.comments.map { |comment| comment.loc.line }
-
-          comment_line_numbers.any? do |comment_line_number|
-            comment_line_number >= node.first_line && comment_line_number <= node.last_line
-          end
-        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
-        end
+          return false unless (parent = node.parent)
 
-        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 which includes `&.`
-            .gsub(/\s*\\?\n\s*/, ' ')       # Any other line break, with or without backslash
-        end
-
-        def max_line_length
-          config.for_cop('Layout/LineLength')['Max']
+          parent.any_block_type? && node == parent.send_node &&
+            (node.parenthesized? || !node.arguments?)
         end
       end
     end