rubocop 1.71.1 → 1.92.0

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

@@ -87,7 +87,7 @@ module RuboCop
           corrector.replace(range, correction)
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def ignored_literal_ranges(ast)
           # which lines start inside a string literal?
           return [] if ast.nil?
@@ -101,17 +101,22 @@ module RuboCop
               ranges << loc.expression
             elsif literal.heredoc?
               ranges << loc.heredoc_body
-            elsif (loc.respond_to?(:begin) && loc.begin) || ignored_parent?(literal)
+            elsif literal.loc?(:begin) || ignored_parent?(literal)
               ranges << loc.expression
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def comment_ranges(comments)
           comments.map(&:source_range)
         end
 
+        def output_record_separator_ranges(ast)
+          return [] if ast.nil?
+
+          ast.each_node(:gvar).select { |gvar| gvar.source == '$\\' }.map(&:source_range)
+        end
+
         def last_line(processed_source)
           last_token = processed_source.tokens.last
 
@@ -124,7 +129,8 @@ module RuboCop
 
         def ignored_ranges
           @ignored_ranges ||= ignored_literal_ranges(processed_source.ast) +
-                              comment_ranges(processed_source.comments)
+                              comment_ranges(processed_source.comments) +
+                              output_record_separator_ranges(processed_source.ast)
         end
 
         def ignored_parent?(node)

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

@@ -87,10 +87,10 @@ module RuboCop
           return if children.empty?
 
           if style == :aligned && !always_indented?(node)
-            check_aligned(children, 1)
+            check_aligned(children, 1, children[0].loc.column)
           else
             check_indented(children)
-            check_aligned(children, 2)
+            check_aligned(children, 2, indented_column(children))
           end
         end
 
@@ -110,21 +110,37 @@ module RuboCop
           PARENT_TYPES_FOR_INDENTED.include?(dstr_node.parent&.type)
         end
 
-        def check_aligned(children, start_index)
+        def check_aligned(children, start_index, target_column)
           base_column = children[start_index - 1].loc.column
-          children[start_index..].each do |child|
-            @column_delta = base_column - child.loc.column
-            add_offense_and_correction(child, MSG_ALIGN) if @column_delta != 0
-            base_column = child.loc.column
+          same_column_runs(children[start_index..]).each do |run|
+            column = run.first.loc.column
+            if column != base_column && column != target_column
+              register_misaligned_run(run, target_column - column)
+            end
+            base_column = column
+          end
+        end
+
+        def same_column_runs(parts)
+          parts.chunk_while { |a, b| a.loc.column == b.loc.column }
+        end
+
+        def register_misaligned_run(run, column_delta)
+          @column_delta = column_delta
+          add_offense(run.first, message: MSG_ALIGN) do |corrector|
+            run.each { |child| autocorrect(corrector, child) }
           end
         end
 
         def check_indented(children)
-          @column_delta = base_column(children[0]) + configured_indentation_width -
-                          children[1].loc.column
+          @column_delta = indented_column(children) - children[1].loc.column
           add_offense_and_correction(children[1], MSG_INDENT) if @column_delta != 0
         end
 
+        def indented_column(children)
+          base_column(children[0]) + configured_indentation_width
+        end
+
         def base_column(child)
           grandparent = child.parent.parent
           if grandparent&.pair_type?

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

@@ -65,16 +65,34 @@ module RuboCop
         include AllowedPattern
         include RangeHelp
         include LineLengthHelp
+        include EndlessMethodRewriter
         extend AutoCorrector
 
         exclude_limit 'Max'
 
         MSG = 'Line is too long. [%<length>d/%<max>d]'
 
+        # A trailing backslash, or a trailing unicode, hex, octal, meta or control escape whose
+        # payload may be incomplete. An even run of backslashes is complete on its own.
+        # Meta and control prefixes chain (`\M-\C-x`, `\c\M-x`), so a whole chain is one escape,
+        # and a braced unicode escape may hold several space-separated codepoints.
+        ESCAPE_SEQUENCE_TAIL = /
+          (?<!\\)(?:\\\\)*
+          (
+            \\(?:(?:[MC]-|c)\\)*
+            (?:u\{[\da-f\x20]*|u[\da-f]{0,4}|x[\da-f]{0,2}|[0-7]{0,3}|[MC]-?|c)?
+          )\z
+        /xi.freeze
+
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         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)
@@ -91,9 +109,22 @@ module RuboCop
         alias on_hash on_potential_breakable_node
         alias on_send on_potential_breakable_node
         alias on_csend on_potential_breakable_node
-        alias on_def on_potential_breakable_node
+
+        def on_def(node)
+          if node.endless?
+            track_endless_method(node)
+          else
+            check_for_breakable_node(node)
+          end
+        end
+        alias on_defs on_def
 
         def on_new_investigation
+          @breakable_range_by_line_index = {}
+          @breakable_string_delimiters = {}
+          @endless_methods_by_line = {}
+          @heredocs = nil
+
           return unless processed_source.raw_source.include?(';')
 
           check_for_breakable_semicolons(processed_source)
@@ -109,6 +140,70 @@ module RuboCop
 
         attr_accessor :breakable_range
 
+        def track_endless_method(node)
+          line_index = node.first_line - processed_source.buffer.first_line
+          endless_methods_by_line[line_index] = node
+        end
+
+        def handle_endless_method_line(line, line_index)
+          if require_endless_methods?
+            return register_required_endless_method_offense(line, line_index)
+          end
+
+          register_endless_method_offense(line, line_index)
+        end
+
+        def require_endless_methods?
+          config.cop_enabled?('Style/EndlessMethod') &&
+            config.for_cop('Style/EndlessMethod')['EnforcedStyle'] == 'require_always'
+        end
+
+        def register_endless_method_offense(line, line_index)
+          message = format(MSG, length: line_length(line), max: max)
+          loc = excess_range(nil, line, line_index)
+
+          add_offense(loc, message: message) do |corrector|
+            self.max = line_length(line)
+
+            correct_to_multiline(corrector, endless_methods_by_line[line_index])
+          end
+        end
+
+        def register_required_endless_method_offense(line, line_index)
+          node = endless_methods_by_line[line_index]
+          loc = excess_range(nil, line, line_index)
+
+          add_offense(loc, message: format(MSG, length: line_length(line), max: max)) do |corrector|
+            self.max = line_length(line)
+
+            if correctable_endless_method_block?(node)
+              correct_endless_method_block_to_multiline(corrector, node)
+            end
+          end
+        end
+
+        def correctable_endless_method_block?(node)
+          block_node = node.body
+
+          block_node&.type?(:any_block) &&
+            block_node.braces? &&
+            block_node.single_line? &&
+            block_node.body &&
+            !receiver_contains_heredoc?(block_node)
+        end
+
+        def correct_endless_method_block_to_multiline(corrector, node)
+          block_node = node.body
+          block_arguments = block_node.arguments? ? " #{block_node.arguments.source}" : ''
+          replacement = [
+            "#{block_node.send_node.source} do#{block_arguments}",
+            "#{indent(node, offset: 2)}#{block_node.body.source}",
+            "#{indent(node)}end"
+          ].join("\n")
+
+          corrector.replace(block_node, replacement)
+        end
+
         def check_for_breakable_node(node)
           breakable_node = extract_breakable_node(node, max)
           return if breakable_node.nil?
@@ -132,8 +227,11 @@ module RuboCop
 
         def check_for_breakable_block(block_node)
           return unless block_node.single_line?
+          return if receiver_contains_heredoc?(block_node)
 
           line_index = block_node.loc.line - 1
+          return if breakable_string_delimiters[line_index]
+
           range = breakable_block_range(block_node)
           pos = range.begin_pos + 1
 
@@ -202,38 +300,77 @@ module RuboCop
           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
+          content_begin_pos = node.loc?(:begin) ? node.loc.begin.end_pos : source_range.begin_pos
+          pos.end_pos if pos.end_pos > content_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) # rubocop:disable Metrics/AbcSize
+        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/))
+          if (space_pos = breakable_space_position(node, relevant_substr))
+            # A space can separate codepoints inside a braced unicode escape.
+            escape_pos = escape_sequence_start(relevant_substr[0..space_pos])
+            source_range.resize(escape_pos || (space_pos + 1))
+          elsif (escape_pos = escape_sequence_start(relevant_substr))
             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: max - source_range.last_column - 3)
+            breakable_string_range_at_limit(source_range)
           end
         end
 
+        def breakable_space_position(node, substr)
+          limit = string_content_length(node) - 1
+          space_pos = substr.rindex(/\s/)
+          space_pos = substr[0, limit].rindex(/\s/) if space_pos && space_pos + 1 > limit
+          space_pos
+        end
+
+        def escape_sequence_start(text)
+          text.match(ESCAPE_SEQUENCE_TAIL)&.begin(1)
+        end
+
+        def breakable_string_range_at_limit(source_range)
+          adjustment = max - source_range.last_column - 3
+          return if adjustment.abs > source_range.size
+
+          cut = source_range.adjust(end_pos: adjustment)
+          escape_pos = escape_sequence_start(cut.source)
+          escape_pos ? source_range.resize(escape_pos) : cut
+        end
+
+        def string_content_length(node)
+          content_end = node.loc?(:end) ? node.loc.end.begin_pos : node.source_range.end_pos
+
+          content_end - node.source_range.begin_pos
+        end
+
         def breakable_dstr_begin_position(node)
           source_range = node.source_range
-          source_range.begin_pos if source_range.begin_pos < max && source_range.end_pos >= max
+          return unless source_range.column < max && source_range.last_column >= max
+          return if opens_string?(node)
+
+          source_range.begin_pos
+        end
+
+        def opens_string?(begin_node)
+          quote = begin_node.parent.loc.begin
+
+          quote && quote.end_pos == begin_node.source_range.begin_pos
         end
 
         def breakable_range_by_line_index
           @breakable_range_by_line_index ||= {}
         end
 
+        def endless_methods_by_line
+          @endless_methods_by_line ||= {}
+        end
+
         def breakable_string_delimiters
           @breakable_string_delimiters ||= {}
         end
@@ -249,14 +386,23 @@ module RuboCop
           [max - indentation_difference(line), 0].max
         end
 
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_line(line, line_index)
           return if line_length(line) <= max
           return if allowed_line?(line, line_index)
 
-          if ignore_cop_directives? && directive_on_source_line?(line_index)
+          if endless_methods_by_line.key?(line_index)
+            return handle_endless_method_line(line, line_index)
+          end
+
+          if allow_rbs_inline_annotation? && rbs_inline_annotation_on_source_line?(line_index)
+            return
+          end
+
+          if allow_cop_directives? && directive_on_source_line?(line_index)
             return check_directive_line(line, line_index)
           end
-          return check_uri_line(line, line_index) if allow_uri?
+          return check_line_for_exemptions(line, line_index) if allow_uri? || allow_qualified_name?
 
           register_offense(excess_range(nil, line, line_index), line, line_index)
         end
@@ -303,10 +449,7 @@ module RuboCop
         def max
           cop_config['Max']
         end
-
-        def allow_heredoc?
-          allowed_heredoc
-        end
+        alias max_line_length max
 
         def allowed_heredoc
           cop_config['AllowHeredoc']
@@ -319,7 +462,7 @@ module RuboCop
         def extract_heredocs(ast)
           return [] unless ast
 
-          ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
+          ast.each_node(:any_str).select(&:heredoc?).map do |node|
             body = node.location.heredoc_body
             delimiter = node.location.heredoc_end.source.strip
             [body.first_line...body.last_line, delimiter]
@@ -335,8 +478,11 @@ module RuboCop
           end
         end
 
-        def line_in_heredoc?(line_number)
-          heredocs.any? { |range, _delimiter| range.cover?(line_number) }
+        def receiver_contains_heredoc?(node)
+          return false unless (receiver = node.receiver)
+          return true if receiver.any_str_type? && receiver.heredoc?
+
+          receiver.each_descendant(:any_str).any?(&:heredoc?)
         end
 
         def check_directive_line(line, line_index)
@@ -356,11 +502,32 @@ module RuboCop
           )
         end
 
-        def check_uri_line(line, line_index)
-          uri_range = find_excessive_uri_range(line)
-          return if uri_range && allowed_uri_position?(line, uri_range)
+        def check_line_for_exemptions(line, line_index)
+          uri_range            = range_if_applicable(line, :uri)
+          qualified_name_range = range_if_applicable(line, :qualified_name)
+
+          return if allowed_combination?(line, uri_range, qualified_name_range)
 
-          register_offense(excess_range(uri_range, line, line_index), line, line_index)
+          range = uri_range || qualified_name_range
+          register_offense(excess_range(range, line, line_index), line, line_index)
+        end
+
+        def range_if_applicable(line, type)
+          return unless type == :uri ? allow_uri? : allow_qualified_name?
+
+          find_excessive_range(line, type)
+        end
+
+        def allowed_combination?(line, uri_range, qualified_name_range)
+          if uri_range && qualified_name_range
+            allowed_position?(line, uri_range) && allowed_position?(line, qualified_name_range)
+          elsif uri_range
+            allowed_position?(line, uri_range)
+          elsif qualified_name_range
+            allowed_position?(line, qualified_name_range)
+          else
+            false
+          end
         end
 
         def breakable_dstr?(node)
@@ -369,9 +536,11 @@ module RuboCop
         end
 
         def string_delimiter(node)
-          delimiter = node.loc.begin
-          delimiter ||= node.parent.loc.begin if node.parent&.dstr_type?
-          delimiter = delimiter&.source
+          delimiter = if node.loc?(:begin)
+                        node.loc.begin
+                      elsif node.parent&.dstr_type? && node.parent.loc?(:begin)
+                        node.parent.loc.begin
+                      end&.source
 
           delimiter if %w[' "].include?(delimiter)
         end
@@ -381,9 +550,11 @@ module RuboCop
           # The maximum allowed length of a string value is:
           # `Max` - end delimiter (quote) - continuation characters (space and slash)
           max_length = max - 3
-          # If the string 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)]
+          # Offset by the string's starting column so the broken line actually fits
+          # within `Max`, whatever precedes the string on its line.
+          max_length -= node.loc.column
+
+          node.source[0, [max_length, 0].max]
         end
       end
     end

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

@@ -27,67 +27,67 @@ module RuboCop
       # line as the last element of the array.
       #
       # @example EnforcedStyle: symmetrical (default)
-      #     # bad
-      #     [ :a,
-      #       :b
-      #     ]
-      #
-      #     # bad
-      #     [
-      #       :a,
-      #       :b ]
-      #
-      #     # good
-      #     [ :a,
-      #       :b ]
-      #
-      #     # good
-      #     [
-      #       :a,
-      #       :b
-      #     ]
+      #   # bad
+      #   [ :a,
+      #     :b
+      #   ]
+      #
+      #   # bad
+      #   [
+      #     :a,
+      #     :b ]
+      #
+      #   # good
+      #   [ :a,
+      #     :b ]
+      #
+      #   # good
+      #   [
+      #     :a,
+      #     :b
+      #   ]
       #
       # @example EnforcedStyle: new_line
-      #     # bad
-      #     [
-      #       :a,
-      #       :b ]
-      #
-      #     # bad
-      #     [ :a,
-      #       :b ]
-      #
-      #     # good
-      #     [ :a,
-      #       :b
-      #     ]
-      #
-      #     # good
-      #     [
-      #       :a,
-      #       :b
-      #     ]
+      #   # bad
+      #   [
+      #     :a,
+      #     :b ]
+      #
+      #   # bad
+      #   [ :a,
+      #     :b ]
+      #
+      #   # good
+      #   [ :a,
+      #     :b
+      #   ]
+      #
+      #   # good
+      #   [
+      #     :a,
+      #     :b
+      #   ]
       #
       # @example EnforcedStyle: same_line
-      #     # bad
-      #     [ :a,
-      #       :b
-      #     ]
-      #
-      #     # bad
-      #     [
-      #       :a,
-      #       :b
-      #     ]
-      #
-      #     # good
-      #     [
-      #       :a,
-      #       :b ]
-      #
-      #     # good
-      #     [ :a,
-      #       :b ]
+      #   # bad
+      #   [ :a,
+      #     :b
+      #   ]
+      #
+      #   # bad
+      #   [
+      #     :a,
+      #     :b
+      #   ]
+      #
+      #   # good
+      #   [
+      #     :a,
+      #     :b ]
+      #
+      #   # good
+      #   [ :a,
+      #     :b ]
       class MultilineArrayBraceLayout < Base
         include MultilineLiteralBraceLayout
         extend AutoCorrector
@@ -106,6 +106,18 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'The closing array brace must be on the ' \
                                    'same line as the last array element.'
 
+        # Moving the closing bracket after a hash literal or method call element while
+        # `Layout/MultilineHashBraceLayout` or `Layout/MultilineMethodCallBraceLayout` moves
+        # that element's closing brace in the same pass places the bracket after whatever
+        # follows the moved brace, such as a comment.
+        # Moving it while `Style/ConcatArrayLiterals` removes the brackets in the same pass
+        # leaves the bracket behind.
+        def self.autocorrect_incompatible_with
+          [
+            Layout::MultilineHashBraceLayout, Layout::MultilineMethodCallBraceLayout, Style::ConcatArrayLiterals
+          ]
+        end
+
         def on_array(node)
           check_brace_layout(node)
         end

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

@@ -69,11 +69,14 @@ module RuboCop
         SAME_LINE_OFFENSE = 'Right hand side of multi-line assignment is not ' \
                             'on the same line as the assignment operator `=`.'
 
+        BLOCK_TYPES = %i[block numblock itblock].freeze
+
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_assignment(node, rhs)
           return if node.send_type? && node.loc.operator&.source != '='
           return unless rhs
           return unless supported_types.include?(rhs.type)
-          return if rhs.single_line?
+          return if rhs.single_line? && (!rhs.block_type? || same_line?(node, rhs.loc.begin))
 
           check_by_enforced_style(node, rhs)
         end
@@ -109,7 +112,10 @@ module RuboCop
         private
 
         def supported_types
-          @supported_types ||= cop_config['SupportedTypes'].map(&:to_sym)
+          @supported_types ||= cop_config['SupportedTypes'].flat_map do |type|
+            sym = type.to_sym
+            sym == :block ? BLOCK_TYPES : sym
+          end
         end
       end
     end

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

@@ -56,6 +56,13 @@ module RuboCop
         ARG_MSG = 'Block argument expression is not on the same line as the block start.'
         PIPE_SIZE = '|'.length
 
+        # `Style/Lambda` moves the block arguments of `lambda` into `->(...)`, and
+        # `Style/ItBlockParameter` and `Style/HashEachMethods` remove some or all of them,
+        # in the same pass, while this cop moves them next to the block start.
+        def self.autocorrect_incompatible_with
+          [Style::HashEachMethods, Style::ItBlockParameter, Style::Lambda]
+        end
+
         def on_block(node)
           return if node.single_line?
 
@@ -69,6 +76,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -77,6 +85,8 @@ module RuboCop
         end
 
         def line_break_necessary_in_args?(node)
+          return false unless max_line_length
+
           needed_length_for_args(node) > max_line_length
         end
 
@@ -152,7 +162,7 @@ module RuboCop
         end
 
         def include_trailing_comma?(args)
-          arg_count = args.each_descendant(:arg).to_a.size
+          arg_count = args.each_descendant.count(&:argument_type?)
           arg_count == 1 && args.source.include?(',')
         end
       end