rubocop 1.71.1 → 1.92.1

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,22 +35,18 @@ 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 }
 
         comment_line_numbers.any? do |comment_line_number|
-          comment_line_number >= node.first_line && comment_line_number <= node.last_line
+          comment_line_number.between?(node.first_line, node.last_line)
         end
       end
 
       def safe_to_split?(node)
-        node.each_descendant(:if, :case, :kwbegin, :def, :defs).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?
@@ -82,14 +82,13 @@ module RuboCop
               next_sibling.source_range
           next_sibling.loc.line
         elsif (parent = node.parent)
-          if parent.loc.respond_to?(:end) && parent.loc.end
+          if parent.loc?(:end)
             parent.loc.end.line
           else
             parent.loc.line
           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/def_node.rb

@@ -19,7 +19,7 @@ module RuboCop
 
       # @!method non_public_modifier?(node)
       def_node_matcher :non_public_modifier?, <<~PATTERN
-        (send nil? {:private :protected :private_class_method} ({def defs} ...))
+        (send nil? {:private :protected :private_class_method} (any_def ...))
       PATTERN
     end
   end

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)
@@ -21,7 +23,7 @@ module RuboCop
 
         # @!method empty_line_required?(node)
         def_node_matcher :empty_line_required?,
-                         '{def defs class module (send nil? {:private :protected :public})}'
+                         '{any_def class module (send nil? {:private :protected :public})}'
 
         def check(node, body, adjusted_first_line: nil)
           return if valid_body_style?(body)
@@ -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/end_keyword_alignment.rb

@@ -19,8 +19,7 @@ module RuboCop
       def check_end_kw_alignment(node, align_ranges)
         return if ignored_node?(node)
 
-        end_loc = node.loc.end
-        return if accept_end_kw_alignment?(end_loc)
+        return unless (end_loc = node.loc.end)
 
         matching = matching_ranges(end_loc, align_ranges)
 
@@ -57,11 +56,6 @@ module RuboCop
         add_offense(end_loc, message: msg) { |corrector| autocorrect(corrector, node) }
       end
 
-      def accept_end_kw_alignment?(end_loc)
-        end_loc.nil? || # Discard modifier forms of if/while/until.
-          !/\A[ \t]*end/.match?(processed_source.lines[end_loc.line - 1])
-      end
-
       def style_parameter_name
         'EnforcedStyleAlignWith'
       end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to forbid certain identifiers in a cop.
+    module ForbiddenIdentifiers
+      SIGILS = '@$' # if a variable starts with a sigil it will be removed
+
+      def forbidden_identifier?(name)
+        return false if forbidden_identifiers.empty?
+
+        forbidden_identifiers.include?(name.to_s.delete(SIGILS))
+      end
+
+      def forbidden_identifiers
+        cop_config.fetch('ForbiddenIdentifiers', [])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to forbid certain patterns in a cop.
+    module ForbiddenPattern
+      def forbidden_pattern?(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/frozen_string_literal.rb

@@ -6,7 +6,6 @@ module RuboCop
     module FrozenStringLiteral
       module_function
 
-      FROZEN_STRING_LITERAL_REGEXP = /#\s*frozen[-_]?string[-_]?literal:/i.freeze
       FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'
       FROZEN_STRING_LITERAL_TYPES_RUBY27 = %i[str dstr].freeze
 
@@ -90,7 +89,7 @@ module RuboCop
 
         if first_non_comment_token
           # `line` is 1-indexed so we need to subtract 1 to get the array index
-          processed_source.lines[0...first_non_comment_token.line - 1]
+          processed_source.lines[0...(first_non_comment_token.line - 1)]
         else
           processed_source.lines
         end

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

@@ -25,6 +25,28 @@ module RuboCop
           (args
             (arg $_)) ...)
       PATTERN
+
+      # @!method assignment_method_declarations(node)
+      def_node_search :assignment_method_declarations, <<~PATTERN
+        (send
+          (lvar {#match_block_variable_name? :_1 :it}) _ ...)
+      PATTERN
+
+      # @!method indexed_assignment_method_declarations(node)
+      def_node_search :indexed_assignment_method_declarations, <<~PATTERN
+        (send
+          (send (lvar {#match_block_variable_name? :_1 :it}) _)
+          :[]=
+          literal?
+          _
+        )
+      PATTERN
+
+      def match_block_variable_name?(receiver_name)
+        gem_specification(processed_source.ast) do |block_variable_name|
+          return block_variable_name == receiver_name
+        end
+      end
     end
   end
 end

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

@@ -10,7 +10,7 @@ module RuboCop
           true
         end
 
-        def deltas_for_first_pair(first_pair, _node)
+        def deltas_for_first_pair(first_pair)
           {
             separator: separator_delta(first_pair),
             value: value_delta(first_pair)
@@ -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
@@ -81,13 +96,7 @@ module RuboCop
       class TableAlignment
         include ValueAlignment
 
-        def initialize
-          self.max_key_width = 0
-        end
-
-        def deltas_for_first_pair(first_pair, node)
-          self.max_key_width = node.keys.map { |key| key.source.length }.max
-
+        def deltas_for_first_pair(first_pair)
           separator_delta = separator_delta(first_pair, first_pair, 0)
           {
             separator: separator_delta,
@@ -97,33 +106,68 @@ module RuboCop
 
         private
 
-        attr_accessor :max_key_width
-
         def key_delta(first_pair, current_pair)
           first_pair.key_delta(current_pair)
         end
 
         def hash_rocket_delta(first_pair, current_pair)
-          first_pair.loc.column + max_key_width + 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 +
-                                 current_pair.delimiter(true).length +
-                                 max_key_width
+          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.select(&:single_line?).map { |key| key.source.length }.max || 0
+        end
+
+        def max_delimiter_width(hash_node)
+          hash_node.pairs.map { |pair| pair.delimiter(true).length }.max
+        end
       end
 
       # Handles calculation of deltas when the enforced style is 'separator'.
       class SeparatorAlignment
         include ValueAlignment
 
-        def deltas_for_first_pair(*_nodes)
+        def deltas_for_first_pair(_first_pair)
           {}
         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)
@@ -135,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