rubocop 1.71.1 → 1.91.0

data/lib/rubocop/cop/mixin/hash_transform_method/autocorrection.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module HashTransformMethod
+      # Internal helper class to hold autocorrect data
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
+        def self.from_each_with_object(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_hash_brackets_map(node, match)
+          new(match, node.children.last, 'Hash['.length, ']'.length)
+        end
+
+        def self.from_map_to_h(node, match)
+          if node.parent&.block_type? && node.parent.send_node == node
+            strip_trailing_chars = 0
+          else
+            map_range = node.children.first.source_range
+            node_range = node.source_range
+            strip_trailing_chars = node_range.end_pos - map_range.end_pos
+          end
+
+          new(match, node.children.first, 0, strip_trailing_chars)
+        end
+
+        def self.from_to_h(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def strip_prefix_and_suffix(node, corrector)
+          expression = node.source_range
+          corrector.remove_leading(expression, leading)
+          corrector.remove_trailing(expression, trailing)
+        end
+
+        def set_new_method_name(new_method_name, corrector)
+          range = block_node.send_node.loc.selector
+          if (send_end = block_node.send_node.loc.end)
+            # If there are arguments (only true in the `each_with_object`
+            # case)
+            range = range.begin.join(send_end)
+          end
+          corrector.replace(range, new_method_name)
+        end
+
+        def set_new_arg_name(transformed_argname, corrector)
+          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
+        end
+
+        def set_new_body_expression(transforming_body_expr, corrector)
+          body_source = transforming_body_expr.source
+          if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
+            body_source = "{ #{body_source} }"
+          end
+
+          corrector.replace(block_node.body, body_source)
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'hash_transform_method/autocorrection'
+
 module RuboCop
   module Cop
     # Common functionality for Style/HashTransformKeys and
@@ -9,12 +11,34 @@ module RuboCop
 
       RESTRICT_ON_SEND = %i[[] to_h].freeze
 
-      # @!method array_receiver?(node)
-      def_node_matcher :array_receiver?, <<~PATTERN
-        {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
+      # Internal helper class to hold match data
+      Captures = Struct.new(:transformed_argname, :transforming_body_expr, :unchanged_body_expr) do
+        def noop_transformation?
+          transforming_body_expr.lvar_type? &&
+            transforming_body_expr.children == [transformed_argname]
+        end
+
+        def transformation_uses_both_args?
+          transforming_body_expr.descendants.include?(unchanged_body_expr)
+        end
+
+        def use_transformed_argname?
+          transforming_body_expr.each_descendant(:lvar).any? do |node|
+            node.source == transformed_argname.to_s
+          end
+        end
+      end
+
+      # @!method hash_receiver?(node)
+      def_node_matcher :hash_receiver?, <<~PATTERN
+        {(hash ...)
+         (send _ {:to_h :to_hash :merge :merge! :update :invert :except :tally} ...)
+         (block (send _ {:group_by :to_h :tally :transform_keys :transform_keys!
+                         :transform_values :transform_values!}) ...)
+         (block (send _ :each_with_object (hash)) ...)}
       PATTERN
 
-      def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+      def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- the patterns matched here all name their block parameters
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
         end
@@ -70,6 +94,10 @@ module RuboCop
 
         return unless captures.use_transformed_argname?
 
+        # A splat transforming expression (e.g. `[k, *v]`) can't be used as a
+        # standalone block return value, so the rewrite would produce invalid Ruby.
+        return if captures.transforming_body_expr.splat_type?
+
         message = "Prefer `#{new_method_name}` over `#{match_desc}`."
         add_offense(node, message: message) do |corrector|
           correction = prepare_correction(node)
@@ -113,80 +141,6 @@ module RuboCop
         correction.set_new_arg_name(captures.transformed_argname, corrector)
         correction.set_new_body_expression(captures.transforming_body_expr, corrector)
       end
-
-      # Internal helper class to hold match data
-      Captures = Struct.new(:transformed_argname, :transforming_body_expr, :unchanged_body_expr) do
-        def noop_transformation?
-          transforming_body_expr.lvar_type? &&
-            transforming_body_expr.children == [transformed_argname]
-        end
-
-        def transformation_uses_both_args?
-          transforming_body_expr.descendants.include?(unchanged_body_expr)
-        end
-
-        def use_transformed_argname?
-          transforming_body_expr.each_descendant(:lvar).any? do |node|
-            node.source == transformed_argname.to_s
-          end
-        end
-      end
-
-      # Internal helper class to hold autocorrect data
-      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
-        def self.from_each_with_object(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def self.from_hash_brackets_map(node, match)
-          new(match, node.children.last, 'Hash['.length, ']'.length)
-        end
-
-        def self.from_map_to_h(node, match)
-          if node.parent&.block_type? && node.parent.send_node == node
-            strip_trailing_chars = 0
-          else
-            map_range = node.children.first.source_range
-            node_range = node.source_range
-            strip_trailing_chars = node_range.end_pos - map_range.end_pos
-          end
-
-          new(match, node.children.first, 0, strip_trailing_chars)
-        end
-
-        def self.from_to_h(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def strip_prefix_and_suffix(node, corrector)
-          expression = node.source_range
-          corrector.remove_leading(expression, leading)
-          corrector.remove_trailing(expression, trailing)
-        end
-
-        def set_new_method_name(new_method_name, corrector)
-          range = block_node.send_node.loc.selector
-          if (send_end = block_node.send_node.loc.end)
-            # If there are arguments (only true in the `each_with_object`
-            # case)
-            range = range.begin.join(send_end)
-          end
-          corrector.replace(range, new_method_name)
-        end
-
-        def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
-        end
-
-        def set_new_body_expression(transforming_body_expr, corrector)
-          body_source = transforming_body_expr.source
-          if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
-            body_source = "{ #{body_source} }"
-          end
-
-          corrector.replace(block_node.body, body_source)
-        end
-      end
     end
   end
 end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Shared machinery for cops that compare a call site's arguments against
+    # a method signature from the project index (`Rubydex::Signature`).
+    #
+    # A signature is reduced to a shape - `[min, max, has_keywords]` where
+    # `max` is nil for a rest parameter - and the number of positional
+    # arguments a call passes is counted with Ruby's semantics for trailing
+    # keyword hashes: keywords passed to a method with no keyword parameters
+    # collapse into a single positional hash.
+    module IndexedMethodArity
+      private
+
+      def arity_satisfied?(given, min, max)
+        given >= min && (max.nil? || given <= max)
+      end
+
+      def expected_range(min, max)
+        return "#{min}+" if max.nil?
+        return min.to_s if min == max
+
+        "#{min}..#{max}"
+      end
+
+      # The agreed `[min, max, has_keywords]` shape of an indexed member's
+      # method definitions, or nil when the member is not backed by plain
+      # method definitions (attr, alias), has no signature, forwards
+      # arguments, or its definitions disagree on arity (e.g. reopened with
+      # a different one).
+      def indexed_member_shape(member)
+        definitions = member.definitions.grep(Rubydex::MethodDefinition)
+        return nil if definitions.empty?
+
+        signature_shape(definitions.flat_map(&:signatures))
+      end
+
+      def signature_shape(signatures)
+        shapes = signatures.filter_map { |signature| shape_for(signature) }.uniq
+        shapes.one? ? shapes.first : nil
+      end
+
+      def shape_for(signature)
+        return nil if signature.forward_parameter
+
+        min = signature.positional_parameters.size + signature.post_parameters.size
+
+        [min, maximum_positional(signature, min), keyword_parameters?(signature)]
+      end
+
+      def maximum_positional(signature, min)
+        return nil if signature.rest_positional_parameter
+
+        min + signature.optional_positional_parameters.size
+      end
+
+      def keyword_parameters?(signature)
+        !signature.keyword_parameters.empty? ||
+          !signature.optional_keyword_parameters.empty? ||
+          !signature.rest_keyword_parameter.nil?
+      end
+
+      # The number of positional arguments the call passes, or nil when it
+      # cannot be determined statically (argument forwarding).
+      def positional_argument_count(node, callee_has_keywords)
+        arguments = node.arguments
+        return nil if forwards_arguments?(arguments)
+
+        arguments = arguments[0...-1] if arguments.last&.block_pass_type?
+        return arguments.size unless (keyword_hash = keyword_hash(arguments.last))
+        return nil if double_splat?(keyword_hash)
+
+        # A keyword-style hash passed to a method with no keyword parameters is
+        # received as a single positional hash argument.
+        callee_has_keywords ? arguments.size - 1 : arguments.size
+      end
+
+      def forwards_arguments?(arguments)
+        arguments.any? do |argument|
+          argument.type?(:splat, :forwarded_args, :forwarded_restarg, :forwarded_kwrestarg)
+        end
+      end
+
+      def keyword_hash(node)
+        node if node&.hash_type? && !node.braces?
+      end
+
+      def double_splat?(hash_node)
+        hash_node.each_child_node.any?(&:kwsplat_type?)
+      end
+    end
+  end
+end

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

@@ -8,8 +8,27 @@ module RuboCop
 
       private
 
-      def ignore_cop_directives?
-        config.for_cop('Layout/LineLength')['IgnoreCopDirectives']
+      def allow_rbs_inline_annotation?
+        config.for_cop('Layout/LineLength')['AllowRBSInlineAnnotation']
+      end
+
+      def rbs_inline_annotation_on_source_line?(line_index)
+        source_line_number = line_index + processed_source.buffer.first_line
+        comment = processed_source.comment_at_line(source_line_number)
+
+        return false unless comment
+
+        comment.text.start_with?(/#:|#\[.+\]|#\|/)
+      end
+
+      def allow_cop_directives?
+        # TODO: This logic for backward compatibility with deprecated `IgnoreCopDirectives` option.
+        # The following three lines will be removed in RuboCop 2.0.
+        ignore_cop_directives = config.for_cop('Layout/LineLength')['IgnoreCopDirectives']
+        return true if ignore_cop_directives
+        return false if ignore_cop_directives == false
+
+        config.for_cop('Layout/LineLength')['AllowCopDirectives']
       end
 
       def directive_on_source_line?(line_index)
@@ -25,20 +44,24 @@ module RuboCop
         config.for_cop('Layout/LineLength')['AllowURI']
       end
 
-      def allowed_uri_position?(line, uri_range)
-        uri_range.begin < max_line_length && uri_range.end == line_length(line)
+      def allow_qualified_name?
+        config.for_cop('Layout/LineLength')['AllowQualifiedName']
+      end
+
+      def allowed_position?(line, range)
+        range.begin < max_line_length && range.end == line_length(line)
       end
 
       def line_length(line)
         line.length + indentation_difference(line)
       end
 
-      def find_excessive_uri_range(line)
-        last_uri_match = match_uris(line).last
-        return nil unless last_uri_match
+      def find_excessive_range(line, type)
+        last_match = (type == :uri ? match_uris(line) : match_qualified_names(line)).last
+        return nil unless last_match
 
-        begin_position, end_position = last_uri_match.offset(0)
-        end_position = extend_uri_end_position(line, end_position)
+        begin_position, end_position = last_match.offset(0)
+        end_position = extend_end_position(line, end_position)
 
         line_indentation_difference = indentation_difference(line)
         begin_position += line_indentation_difference
@@ -57,6 +80,14 @@ module RuboCop
         matches
       end
 
+      def match_qualified_names(string)
+        matches = []
+        string.scan(qualified_name_regexp) do
+          matches << $LAST_MATCH_INFO
+        end
+        matches
+      end
+
       def indentation_difference(line)
         return 0 unless tab_indentation_width
 
@@ -70,7 +101,7 @@ module RuboCop
         index * (tab_indentation_width - 1)
       end
 
-      def extend_uri_end_position(line, end_position)
+      def extend_end_position(line, end_position)
         # Extend the end position YARD comments with linked URLs of the form {<uri> <title>}
         if line&.match(/{(\s|\S)*}$/)
           match = line[end_position..line_length(line)]&.match(/(\s|\S)*}/)
@@ -97,10 +128,20 @@ module RuboCop
           # Additionally, the RFC2396_PARSER alias is only available on 3.4 for now.
           # Extra info at https://github.com/ruby/uri/issues/118
           parser = defined?(URI::RFC2396_PARSER) ? URI::RFC2396_PARSER : URI::DEFAULT_PARSER
-          parser.make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
+          schemes = config.for_cop('Layout/LineLength')['URISchemes']
+          regexp = parser.make_regexp(schemes)
+
+          # `make_regexp` in uri 1.1.0+ matches schemes case-insensitively, which makes
+          # constant paths like `Http::UploadedFile` look like URIs. Require the exact case
+          # given in `URISchemes`.
+          schemes ? /(?=#{Regexp.union(schemes)}:)#{regexp}/ : regexp
         end
       end
 
+      def qualified_name_regexp
+        /\b(?:[A-Z][A-Za-z0-9_]*::)+[A-Za-z_][A-Za-z0-9_]*\b/
+      end
+
       def valid_uri?(uri_ish_string)
         URI.parse(uri_ish_string)
         true

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

@@ -30,6 +30,7 @@ module RuboCop
       end
 
       alias on_numblock on_block
+      alias on_itblock on_block
 
       private
 
@@ -72,7 +73,7 @@ module RuboCop
 
       def location(node)
         if LSP.enabled?
-          end_range = node.loc.respond_to?(:name) ? node.loc.name : node.loc.begin
+          end_range = node.loc?(:name) ? node.loc.name : node.loc.begin
           node.source_range.begin.join(end_range)
         else
           node.source_range

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

@@ -17,6 +17,8 @@ module RuboCop
 
         lhs = left_hand_side(node.receiver)
         rhs = right_hand_side(node)
+        return unless rhs
+
         range = offending_range(node, lhs, rhs, style)
         check(range, node, lhs, rhs)
       end
@@ -198,7 +200,7 @@ module RuboCop
       end
 
       def grouped_expression?(node)
-        node.begin_type? && node.loc.respond_to?(:begin) && node.loc.begin
+        node.begin_type? && node.loc?(:begin) && node.loc.begin
       end
 
       def inside_arg_list_parentheses?(node, ancestor)

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

@@ -127,7 +127,7 @@ module RuboCop
         parent ||= node
 
         if node.respond_to?(:loc) &&
-           node.loc.respond_to?(:heredoc_end) &&
+           node.loc?(:heredoc_end) &&
            node.loc.heredoc_end.last_line >= parent.last_line
           return true
         end

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

@@ -24,7 +24,7 @@ module RuboCop
         gem_canonical_name(string_a) < gem_canonical_name(string_b)
       end
 
-      def consecutive_lines(previous, current)
+      def consecutive_lines?(previous, current)
         first_line = get_source_range(current, treat_comments_as_separators).first_line
         previous.source_range.last_line == first_line - 1
       end

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

@@ -21,7 +21,7 @@ module RuboCop
       end
 
       def begin_source(node)
-        node.loc.begin.source if node.loc.respond_to?(:begin) && node.loc.begin
+        node.loc.begin.source if node.loc?(:begin)
       end
 
       def type(node)

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     # Common functionality for checking whether an AST node/token is aligned
     # with something on a preceding or following line
-    # rubocop:disable Metrics/ModuleLength
+    # rubocop:disable-next Metrics/ModuleLength
     module PrecedingFollowingAlignment
       # Tokens that end with an `=`, as well as `<<`, that can be aligned together:
       # `=`, `==`, `===`, `!=`, `<=`, `>=`, `<<` and operator assignment (`+=`, etc).
@@ -69,7 +69,15 @@ module RuboCop
           line = processed_source.lines[lineno]
           index = line =~ /\S/
           next unless index
-          next if indent && indent != index
+
+          if indent
+            # When searching for the nearest line with the same indentation,
+            # more deeply indented lines are nested content of the current group
+            # and are skipped, but a less deeply indented line ends the enclosing block:
+            # an alignment anchor beyond it would be coincidental.
+            break if index < indent
+            next if index > indent
+          end
 
           return yield(range, line, lineno + 1)
         end
@@ -174,20 +182,69 @@ module RuboCop
       # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
       # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength
       def relevant_assignment_lines(line_range)
+        relevant_lines(line_range, interrupting_operator_lines) do |line_number|
+          assignment_lines.include?(line_number)
+        end
+      end
+
+      def interrupting_operator_lines
+        @interrupting_operator_lines ||=
+          processed_source.tokens.each_with_object(Set.new) do |token, lines|
+            next unless ASSIGNMENT_OR_COMPARISON_TOKENS.include?(token.type)
+
+            lines << token.line unless assignment_lines.include?(token.line)
+          end
+      end
+
+      def alignment_lines(line_number)
+        @alignment_lines_by_line ||= {}
+        return @alignment_lines_by_line[line_number] if @alignment_lines_by_line.key?(line_number)
+
+        lines = alignment_line_ranges(line_number).flatten.uniq.sort.freeze
+
+        lines.each { |line| @alignment_lines_by_line[line] = lines }
+      end
+
+      def alignment_line_ranges(line_number)
+        last_line = processed_source.lines.length
+
+        [
+          relevant_lines(line_number.downto(1), definition_boundary_lines) do |line|
+            !aligned_comment_lines.include?(line)
+          end,
+          relevant_lines(line_number.upto(last_line), definition_boundary_lines) do |line|
+            !aligned_comment_lines.include?(line)
+          end
+        ]
+      end
+
+      def definition_boundary_lines
+        @definition_boundary_lines ||= begin
+          nodes = processed_source.ast&.each_node(:any_def) || []
+
+          nodes.each_with_object(Set.new) do |node, lines|
+            lines << node.first_line << node.last_line
+          end
+        end
+      end
+
+      def relevant_lines(line_range, boundary_lines = [])
         result                        = []
-        original_line_indent          = processed_source.line_indentation(line_range.first)
+        original_line                 = line_range.first
+        original_line_indent          = processed_source.line_indentation(original_line)
         relevant_line_indent_at_level = true
 
         line_range.each do |line_number|
           current_line_indent = processed_source.line_indentation(line_number)
           blank_line          = processed_source.lines[line_number - 1].blank?
 
-          if (current_line_indent < original_line_indent && !blank_line) ||
+          if (line_number != original_line && boundary_lines.include?(line_number)) ||
+             (current_line_indent < original_line_indent && !blank_line) ||
              (relevant_line_indent_at_level && blank_line)
             break
           end
 
-          result << line_number if assignment_lines.include?(line_number) &&
+          result << line_number if yield(line_number) &&
                                    current_line_indent == original_line_indent
 
           unless blank_line
@@ -214,6 +271,5 @@ module RuboCop
         asgn_tokens.reject { |t| eqls_to_ignore.include?(t.begin_pos) }
       end
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end