rubocop 1.81.7 → 1.92.1

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -61,11 +61,13 @@ module RuboCop
       # @api private
       def extract_breakable_node_from_elements(node, elements, max)
         return unless breakable_collection?(node, elements)
-        return if safe_to_ignore?(node)
 
+        # Check the cheap conditions first, `safe_to_ignore?` may traverse all elements of
+        # a containing collection.
         line = processed_source.lines[node.first_line - 1]
+        return if max && line.length <= max
         return if processed_source.line_with_comment?(node.loc.line)
-        return if line.length <= max
+        return if safe_to_ignore?(node)
 
         extract_first_element_over_column_limit(node, elements, max)
       end
@@ -74,11 +76,7 @@ module RuboCop
       def extract_first_element_over_column_limit(node, elements, max)
         line = node.first_line
 
-        # If a `send` or `csend` node is not parenthesized, don't move the first element, because it
-        # can result in changed behavior or a syntax error.
-        if node.call_type? && !node.parenthesized? && !first_argument_is_heredoc?(node)
-          elements = elements.drop(1)
-        end
+        elements = elements.drop(1) unless first_element_movable?(node)
 
         i = 0
         i += 1 while within_column_limit?(elements[i], max, line)
@@ -91,23 +89,35 @@ module RuboCop
       end
 
       # @api private
-      def first_argument_is_heredoc?(node)
-        first_argument = node.first_argument
+      # If a method call or definition is not parenthesized, the first element cannot be moved,
+      # because it can result in changed behavior or a syntax error.
+      def first_element_movable?(node)
+        return !node.arguments.loc.begin.nil? if node.any_def_type?
+        return true if !node.call_type? || node.parenthesized?
 
-        first_argument.respond_to?(:heredoc?) && first_argument.heredoc?
+        node.first_argument.respond_to?(:heredoc?) && node.first_argument.heredoc?
       end
 
       # @api private
       # If a `send` or `csend` node contains a heredoc argument, splitting cannot happen
       # after the heredoc or else it will cause a syntax error.
       def shift_elements_for_heredoc_arg(node, elements, index)
-        return index unless node.type?(:call, :array)
+        return index unless node.type?(:call, :array, :hash)
+        return index unless (heredoc_pos = heredoc_begin_position(node))
+
+        last_safe = elements.rindex { |element| element.source_range.begin_pos <= heredoc_pos }
+        return nil if last_safe.nil? ||
+                      (last_safe.zero? && elements.first.source_range.end_pos > heredoc_pos)
 
-        heredoc_index = elements.index { |arg| arg.respond_to?(:heredoc?) && arg.heredoc? }
-        return index unless heredoc_index
-        return nil if heredoc_index.zero?
+        [index, last_safe + 1].min
+      end
 
-        heredoc_index >= index ? index : heredoc_index + 1
+      # @api private
+      def heredoc_begin_position(node)
+        children = node.call_type? ? node.arguments : node.children
+        children.flat_map { |child| [child, *child.each_descendant(:any_str)] }
+                .find { |descendant| descendant.type?(:any_str) && descendant.heredoc? }
+                &.source_range&.begin_pos
       end
 
       # @api private
@@ -126,9 +136,7 @@ module RuboCop
         # or redundant edits, we only mark one offense at a time.
         return true if contained_by_breakable_collection_on_same_line?(node)
 
-        return true if contained_by_multiline_collection_that_could_be_broken_up?(node)
-
-        false
+        contained_by_multiline_collection_that_could_be_broken_up?(node)
       end
 
       # @api private
@@ -143,9 +151,7 @@ module RuboCop
         # break before the second argument and the rest of the
         # argument will get auto-formatted onto separate lines
         # by other cops.
-        has_second_element = elements.length >= 2
-
-        starts_with_bracket && has_second_element
+        starts_with_bracket && elements.length >= 2
       end
 
       # @api private
@@ -173,20 +179,36 @@ module RuboCop
         node.each_ancestor.find do |ancestor|
           if ancestor.type?(:hash, :array) &&
              breakable_collection?(ancestor, ancestor.children)
-            return children_could_be_broken_up?(ancestor.children)
+            return children_could_be_broken_up?(ancestor, ancestor.children)
           end
 
           next unless ancestor.call_type?
 
           args = process_args(ancestor.arguments)
-          return children_could_be_broken_up?(args) if breakable_collection?(ancestor, args)
+          if breakable_collection?(ancestor, args)
+            return children_could_be_broken_up?(ancestor, args)
+          end
         end
 
         false
       end
 
       # @api private
-      def children_could_be_broken_up?(children)
+      # The result depends only on the given node, but the check may traverse all children of
+      # a large collection and is repeated for each contained element, so memoize it per node.
+      def children_could_be_broken_up?(node, children)
+        if @check_line_breakable_processed_source != processed_source
+          @check_line_breakable_processed_source = processed_source
+          @children_could_be_broken_up_cache = {}.compare_by_identity
+        end
+
+        @children_could_be_broken_up_cache.fetch(node) do
+          @children_could_be_broken_up_cache[node] = compute_children_could_be_broken_up?(children)
+        end
+      end
+
+      # @api private
+      def compute_children_could_be_broken_up?(children)
         return false if all_on_same_line?(children)
 
         last_seen_line = -1
@@ -222,7 +244,7 @@ module RuboCop
       def already_on_multiple_lines?(node)
         return node.first_line != node.last_argument.last_line if node.any_def_type?
 
-        !node.single_line?
+        node.multiline?
       end
 
       def chained_to_heredoc?(node)

data/lib/rubocop/cop/mixin/check_single_line_suitability.rb

@@ -5,6 +5,8 @@ module RuboCop
     # Checks for code on multiple lines that could be rewritten on a single line
     # without changing semantics or exceeding the `Max` parameter of `Layout/LineLength`.
     module CheckSingleLineSuitability
+      include LineLengthHelp
+
       def suitable_as_single_line?(node)
         !too_long?(node) &&
           !comment_within?(node) &&
@@ -14,8 +16,14 @@ module RuboCop
       private
 
       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
+        too_long_as_single_line?(node.first_line..node.last_line)
+      end
+
+      def too_long_as_single_line?(line_range)
+        return false unless max_line_length
+
+        lines = processed_source.lines[(line_range.begin - 1)...line_range.end]
+        line_length(to_single_line(lines.join("\n"))) > max_line_length
       end
 
       def to_single_line(source)
@@ -27,10 +35,6 @@ module RuboCop
           .gsub(/\s*\\?\n\s*/, ' ')       # Any other line break, with or without backslash
       end
 
-      def max_line_length
-        config.for_cop('Layout/LineLength')['Max']
-      end
-
       def comment_within?(node)
         comment_line_numbers = processed_source.comments.map { |comment| comment.loc.line }
 
@@ -40,9 +44,9 @@ module RuboCop
       end
 
       def safe_to_split?(node)
-        node.each_descendant(:if, :case, :kwbegin, :any_def).none? &&
+        node.each_descendant(:if, :case, :kwbegin, :any_def, :rescue, :ensure).none? &&
           node.each_descendant(:dstr, :str).none? { |n| n.heredoc? || n.value.include?("\n") } &&
-          node.each_descendant(:begin, :sym).none? { |b| !b.single_line? }
+          node.each_descendant(:begin, :sym).none?(&:multiline?)
       end
     end
   end

data/lib/rubocop/cop/mixin/code_length.rb

@@ -59,12 +59,20 @@ module RuboCop
         return node.loc.name if node.casgn_type?
 
         if LSP.enabled?
-          end_range = node.loc.respond_to?(:name) ? node.loc.name : node.loc.begin
-          node.source_range.begin.join(end_range)
+          node.source_range.begin.join(header_end(node))
         else
           node.source_range
         end
       end
+
+      # Where the header of a definition ends: the name of a class, module or
+      # method, the `self` of `class << self`, or the opening of a block.
+      def header_end(node)
+        return node.loc.name if node.loc?(:name)
+        return node.identifier.source_range if node.sclass_type?
+
+        node.loc.begin
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -64,7 +64,7 @@ module RuboCop
       # Returns the end line of a node, which might be a comment and not part of the AST
       # End line is considered either the line at which another node starts, or
       # the line at which the parent node ends.
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def find_end_line(node)
         if node.if_type?
           if node.else?
@@ -89,7 +89,6 @@ module RuboCop
           end
         end || node.loc.end.line
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     end
   end
 end

data/lib/rubocop/cop/mixin/configurable_enforced_style.rb

@@ -25,7 +25,7 @@ module RuboCop
       end
       private_constant :SYMBOL_TO_STRING_CACHE
 
-      # rubocop:disable Metrics
+      # rubocop:disable-next Metrics
       def style_detected(detected)
         return if no_acceptable_style?
 
@@ -51,7 +51,6 @@ module RuboCop
           config_to_allow_offenses[style_parameter_name] = updated_list.first
         end
       end
-      # rubocop:enable Metrics
 
       def no_acceptable_style?
         config_to_allow_offenses['Enabled'] == false

data/lib/rubocop/cop/mixin/configurable_max.rb

@@ -13,11 +13,12 @@ module RuboCop
           `max=` is deprecated. Use `exclude_limit <ParameterName>` instead.
         WARNING
 
-        cfg = config_to_allow_offenses
-        cfg[:exclude_limit] ||= {}
-        current_max = cfg[:exclude_limit][max_parameter_name]
-        value = [current_max, value].max if current_max
-        cfg[:exclude_limit][max_parameter_name] = value
+        cop_dir = RuboCop::ExcludeLimit.cop_dir_for(self.class.badge.to_s)
+        return unless cop_dir
+
+        cop_dir.mkpath
+        filepath = cop_dir.join(max_parameter_name)
+        filepath.write("#{value}\n", mode: 'a')
       end
 
       def max_parameter_name

data/lib/rubocop/cop/mixin/empty_lines_around_body.rb

@@ -5,7 +5,7 @@ module RuboCop
     module Layout
       # Common functionality for checking if presence/absence of empty lines
       # around some kind of body matches the configuration.
-      module EmptyLinesAroundBody
+      module EmptyLinesAroundBody # rubocop:disable Metrics/ModuleLength
         extend NodePattern::Macros
         include ConfigurableEnforcedStyle
         include RangeHelp
@@ -14,6 +14,8 @@ module RuboCop
         MSG_MISSING = 'Empty line missing at %<kind>s body %<location>s.'
         MSG_DEFERRED = 'Empty line missing before first %<type>s definition'
 
+        LEADING_DOT_TYPES = %i[tDOT tANDDOT].to_set.freeze
+
         private
 
         # @!method constant_definition?(node)
@@ -29,6 +31,7 @@ module RuboCop
 
           first_line = adjusted_first_line || node.source_range.first_line
           last_line = node.source_range.last_line
+          return if first_line >= last_line
 
           case style
           when :empty_lines_except_namespace
@@ -99,12 +102,20 @@ module RuboCop
           return unless yield(processed_source.lines[line])
 
           offset = style == :empty_lines && msg.include?('end.') ? 2 : 1
+          return if style == :empty_lines && leading_dot_line?(line + offset)
+
           range = source_range(processed_source.buffer, line + offset, 0)
           add_offense(range, message: msg) do |corrector|
             EmptyLineCorrector.correct(corrector, [style, range])
           end
         end
 
+        def leading_dot_line?(line)
+          first_token = processed_source.sorted_tokens.find { |token| token.line == line }
+
+          LEADING_DOT_TYPES.include?(first_token&.type)
+        end
+
         def check_deferred_empty_line(body)
           node = first_empty_line_required_child(body)
           return unless node

data/lib/rubocop/cop/mixin/endless_method_body_help.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking whether a method body can become the
+    # body of an endless method definition without changing its meaning.
+    module EndlessMethodBodyHelp
+      private
+
+      def endless_method_body?(body)
+        return false if body.type?(:begin, :kwbegin, :rescue, :ensure, :masgn)
+        return false if low_precedence_body?(body)
+        return false if ends_with_omitted_hash_value?(body) || ends_with_anonymous_argument?(body)
+        return false if body.assignment? && multiple_values?(assigned_value(body))
+
+        !command_disallowed_in_endless_body?(body)
+      end
+
+      # `def foo = bar and baz` parses as `(def foo = bar) and baz`.
+      def low_precedence_body?(body)
+        body.type?(:any_match_pattern, :while_post, :until_post) ||
+          (body.type?(:and, :or) && body.semantic_operator?) ||
+          (body.type?(:if, :while, :until) && body.modifier_form?)
+      end
+
+      # `foo = 1, 2` and `foo = *bar` assign an array without brackets.
+      def multiple_values?(node)
+        node.array_type? && !node.bracketed?
+      end
+
+      def ends_with_omitted_hash_value?(body)
+        body.each_descendant(:pair).any? do |pair|
+          pair.value_omission? && pair.source_range.end_pos == body.source_range.end_pos
+        end
+      end
+
+      def ends_with_anonymous_argument?(body)
+        forwarding = %i[forwarded_restarg forwarded_kwrestarg block_pass]
+
+        body.each_descendant(*forwarding).any? do |argument|
+          argument.source_range.end_pos == body.source_range.end_pos &&
+            (!argument.block_pass_type? || argument.children.first.nil?)
+        end
+      end
+
+      def command_disallowed_in_endless_body?(body)
+        return true if body.assignment? && command_call?(assigned_value(body))
+        return true if body_disallowed_in_argument?(body)
+        return true if negated_command_call?(body)
+
+        body.each_node(:any_block).any? do |block|
+          block.keywords? && command_call?(block.send_node)
+        end
+      end
+
+      def body_disallowed_in_argument?(body)
+        command_body_in_argument?(body) || do_end_block_body_in_command_argument?(body)
+      end
+
+      # `private def foo = bar baz` parses only on Ruby 4.0+, and only as the sole argument.
+      def command_body_in_argument?(body)
+        return false unless command_call?(body)
+
+        call = argument_receiving_call(body.parent)
+        return false if call.nil?
+
+        target_ruby_version < 4.0 || !call.arguments.one?
+      end
+
+      def argument_receiving_call(def_node)
+        call = def_node.parent
+        return unless call&.call_type?
+
+        call if call.arguments.any? { |argument| argument.equal?(def_node) }
+      end
+
+      def do_end_block_body_in_command_argument?(body)
+        call = argument_receiving_call(body.parent)
+        return false if call.nil? || call.parenthesized?
+
+        body.each_node(:any_block).any? do |block|
+          block.keywords? && !block.send_node.lambda_literal?
+        end
+      end
+
+      def assigned_value(node)
+        while node.assignment? || node.rescue_type?
+          node = node.rescue_type? ? node.body : node.children.last
+        end
+        node
+      end
+
+      def command_call?(node)
+        node = node.send_node if node.any_block_type?
+        return false unless node.type?(:call, :super, :yield)
+
+        node.arguments? && !node.parenthesized? && !node.operator_method? && !node.setter_method?
+      end
+
+      def negated_command_call?(node)
+        node.send_type? && node.prefix_bang? && command_call?(node.receiver)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/endless_method_rewriter.rb

@@ -5,20 +5,28 @@ module RuboCop
     # Common functionality for rewriting endless methods to normal method definitions
     module EndlessMethodRewriter
       def correct_to_multiline(corrector, node)
-        replacement = <<~RUBY.strip
-          def #{node.method_name}#{arguments(node)}
-            #{node.body.source}
-          end
-        RUBY
+        replacement = [
+          "def #{receiver(node)}#{node.method_name}#{arguments(node)}",
+          "#{indent(node, offset: configured_indentation_width)}#{node.body.source}",
+          "#{indent(node)}end"
+        ].join("\n")
 
         corrector.replace(node, replacement)
       end
 
       private
 
+      def receiver(node)
+        node.receiver ? "#{node.receiver.source}#{node.loc.operator.source}" : ''
+      end
+
       def arguments(node, missing = '')
         node.arguments.any? ? node.arguments.source : missing
       end
+
+      def configured_indentation_width
+        cop_config['IndentationWidth'] || config.for_cop('Layout/IndentationWidth')['Width'] || 2
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/forbidden_identifiers.rb

@@ -7,9 +7,9 @@ module RuboCop
       SIGILS = '@$' # if a variable starts with a sigil it will be removed
 
       def forbidden_identifier?(name)
-        name = name.to_s.delete(SIGILS)
+        return false if forbidden_identifiers.empty?
 
-        forbidden_identifiers.any? && forbidden_identifiers.include?(name)
+        forbidden_identifiers.include?(name.to_s.delete(SIGILS))
       end
 
       def forbidden_identifiers

data/lib/rubocop/cop/mixin/forbidden_pattern.rb

@@ -5,12 +5,16 @@ module RuboCop
     # This module encapsulates the ability to forbid certain patterns in a cop.
     module ForbiddenPattern
       def forbidden_pattern?(name)
-        forbidden_patterns.any? { |pattern| Regexp.new(pattern).match?(name) }
+        forbidden_pattern_regexps.any? { |pattern| pattern.match?(name) }
       end
 
       def forbidden_patterns
         cop_config.fetch('ForbiddenPatterns', [])
       end
+
+      def forbidden_pattern_regexps
+        @forbidden_pattern_regexps ||= forbidden_patterns.map { |pattern| Regexp.new(pattern) }
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/hash_alignment_styles.rb

@@ -55,22 +55,37 @@ module RuboCop
       # Common functionality for checking alignment of hash values.
       module ValueAlignment
         def checkable_layout?(node)
-          !node.pairs_on_same_line? && !node.mixed_delimiters?
+          !node.pairs_on_same_line? && !node.mixed_delimiters? && alignable_values?(node)
         end
 
         def deltas(first_pair, current_pair)
           key_delta = key_delta(first_pair, current_pair)
-          separator_delta = separator_delta(first_pair, current_pair, key_delta)
-          value_delta = value_delta(first_pair, current_pair) - key_delta - separator_delta
+          shift = separator_shift(current_pair, key_delta)
+          separator_delta = separator_delta(first_pair, current_pair, shift)
+          value_delta = value_delta(first_pair, current_pair) - shift - separator_delta
 
           { key: key_delta, separator: separator_delta, value: value_delta }
         end
 
         private
 
-        def separator_delta(first_pair, current_pair, key_delta)
+        def alignable_values?(node)
+          return false if node.pairs.first.value_omission?
+
+          node.pairs.none? { |pair| value_on_later_line?(pair) }
+        end
+
+        def value_on_later_line?(pair)
+          pair.value && pair.key.last_line != pair.value.first_line
+        end
+
+        def separator_shift(current_pair, key_delta)
+          current_pair.key.multiline? ? 0 : key_delta
+        end
+
+        def separator_delta(first_pair, current_pair, shift)
           if current_pair.hash_rocket?
-            hash_rocket_delta(first_pair, current_pair) - key_delta
+            hash_rocket_delta(first_pair, current_pair) - shift
           else
             0
           end
@@ -96,20 +111,37 @@ module RuboCop
         end
 
         def hash_rocket_delta(first_pair, current_pair)
-          first_pair.loc.column + max_key_width(first_pair.parent) + 1 -
-            current_pair.loc.operator.column
+          target_operator_column(first_pair) - current_pair.loc.operator.column
         end
 
         def value_delta(first_pair, current_pair)
-          correct_value_column = first_pair.key.loc.column +
-                                 max_key_width(first_pair.parent) +
-                                 max_delimiter_width(first_pair.parent)
+          correct_value_column = target_operator_column(first_pair) +
+                                 max_delimiter_width(first_pair.parent) - 1
 
           current_pair.value_omission? ? 0 : correct_value_column - current_pair.value.loc.column
         end
 
+        # The column the separator should land on: the shared key margin
+        # plus the widest single-line key, or, if larger, a multiline key's
+        # own last-line end column. The latter can't be measured from a
+        # multiline key's (newline-including) source length, so it's a
+        # separate candidate rather than folded into `max_key_width`.
+        def target_operator_column(first_pair)
+          hash_node = first_pair.parent
+          candidates = multiline_key_end_columns(hash_node)
+
+          key_width = max_key_width(hash_node)
+          candidates << (first_pair.loc.column + key_width + 1) if key_width.positive?
+
+          candidates.max
+        end
+
+        def multiline_key_end_columns(hash_node)
+          hash_node.keys.reject(&:single_line?).map { |key| key.source_range.end.column + 1 }
+        end
+
         def max_key_width(hash_node)
-          hash_node.keys.map { |key| key.source.length }.max
+          hash_node.keys.select(&:single_line?).map { |key| key.source.length }.max || 0
         end
 
         def max_delimiter_width(hash_node)
@@ -125,6 +157,17 @@ module RuboCop
           {}
         end
 
+        # Keys are right-aligned by the column their last line ends on.
+        # A key spanning several lines ends on a line other than the one it starts on,
+        # so moving its first line would never change that column and the correction
+        # would be repeated on every pass. Such pairs are left alone, and so is every pair
+        # when the first key spans several lines, since there is then no column to right-align to.
+        def deltas(first_pair, current_pair)
+          return {} if first_pair.key.multiline? || current_pair.key.multiline?
+
+          super
+        end
+
         private
 
         def key_delta(first_pair, current_pair)
@@ -136,7 +179,10 @@ module RuboCop
         end
 
         def value_delta(first_pair, current_pair)
-          current_pair.value_omission? ? 0 : first_pair.value_delta(current_pair)
+          return 0 if first_pair.equal?(current_pair) || current_pair.value_omission?
+
+          expected_value_column = first_pair.loc.operator.end.column + 1
+          expected_value_column - current_pair.value.loc.column
         end
       end