rubocop 1.53.0 → 1.90.0

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,23 +44,28 @@ 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).map do |pos|
-          pos + indentation_difference(line)
-        end
+        begin_position, end_position = last_match.offset(0)
+        end_position = extend_end_position(line, end_position)
 
-        end_position = extend_uri_end_position(line, end_position)
+        line_indentation_difference = indentation_difference(line)
+        begin_position += line_indentation_difference
+        end_position += line_indentation_difference
 
         return nil if begin_position < max_line_length && end_position < max_line_length
 
@@ -56,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
 
@@ -69,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)*}/)
@@ -91,8 +123,23 @@ module RuboCop
       end
 
       def uri_regexp
-        @uri_regexp ||=
-          URI::DEFAULT_PARSER.make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
+        @uri_regexp ||= begin
+          # Ruby 3.4 changes the default parser to RFC3986 which warns on make_regexp.
+          # 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
+          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)

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

@@ -30,12 +30,13 @@ module RuboCop
       end
 
       alias on_numblock on_block
+      alias on_itblock on_block
 
       private
 
       # @!method define_method?(node)
       def_node_matcher :define_method?, <<~PATTERN
-        ({block numblock}
+        (any_block
          (send nil? :define_method ({sym str} $_)) _ _)
       PATTERN
 
@@ -49,13 +50,13 @@ module RuboCop
 
         return unless complexity > max
 
-        msg = format(self.class::MSG,
-                     method: method_name,
-                     complexity: complexity,
-                     abc_vector: abc_vector,
-                     max: max)
+        msg = format(
+          self.class::MSG,
+          method: method_name, complexity: complexity, abc_vector: abc_vector, max: max
+        )
+        location = location(node)
 
-        add_offense(node, message: msg) { self.max = complexity.ceil }
+        add_offense(location, message: msg) { self.max = complexity.ceil }
       end
 
       def complexity(body)
@@ -69,6 +70,15 @@ module RuboCop
         end
         score
       end
+
+      def location(node)
+        if LSP.enabled?
+          end_range = node.loc?(:name) ? node.loc.name : node.loc.begin
+          node.source_range.begin.join(end_range)
+        else
+          node.source_range
+        end
+      end
     end
   end
 end

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

@@ -17,19 +17,22 @@ 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
+      alias on_csend on_send
 
       private
 
-      # In a chain of method calls, we regard the top send node as the base
+      # In a chain of method calls, we regard the top call node as the base
       # for indentation of all lines following the first. For example:
       # a.
       #   b c { block }.            <-- b is indented relative to a
       #   d                         <-- d is indented relative to a
       def left_hand_side(lhs)
-        while lhs.parent&.send_type? && lhs.parent.loc.dot && !lhs.parent.assignment_method?
+        while lhs.parent&.call_type? && lhs.parent.loc.dot && !lhs.parent.assignment_method?
           lhs = lhs.parent
         end
         lhs
@@ -120,12 +123,10 @@ module RuboCop
 
       def indented_keyword_expression(node)
         if node.for_type?
-          expression = node.collection
+          node.collection
         else
-          expression, = *node
+          node.children.first
         end
-
-        expression
       end
 
       def argument_in_method_call(node, kind) # rubocop:todo Metrics/CyclomaticComplexity
@@ -186,12 +187,10 @@ module RuboCop
 
       def assignment_rhs(node)
         case node.type
-        when :casgn   then _scope, _lhs, rhs = *node
-        when :op_asgn then _lhs, _op, rhs = *node
-        when :send    then rhs = node.last_argument
-        else               _lhs, rhs = *node
+        when :casgn, :op_asgn then node.rhs
+        when :send, :csend    then node.last_argument
+        else                       node.children.last
         end
-        rhs
       end
 
       def not_for_this_cop?(node)
@@ -201,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_array.rb

@@ -15,7 +15,7 @@ module RuboCop
         parent = node.parent
 
         parent&.send_type? && parent.arguments.include?(node) &&
-          !parent.parenthesized? && parent&.block_literal?
+          !parent.parenthesized? && parent.block_literal?
       end
 
       # Override to determine values that are invalid in a percent array

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,12 @@ 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-next Metrics/ModuleLength
     module PrecedingFollowingAlignment
+      # Tokens that end with an `=`, as well as `<<`, that can be aligned together:
+      # `=`, `==`, `===`, `!=`, `<=`, `>=`, `<<` and operator assignment (`+=`, etc).
+      ASSIGNMENT_OR_COMPARISON_TOKENS = %i[tEQL tEQ tEQQ tNEQ tLEQ tGEQ tOP_ASGN tLSHFT].freeze
+
       private
 
       def allow_for_alignment?
@@ -19,16 +24,20 @@ module RuboCop
         aligned_with_adjacent_line?(range, method(:aligned_operator?))
       end
 
-      def aligned_with_preceding_assignment(token)
+      # Allows alignment with a preceding operator that ends with an `=`,
+      # including assignment and comparison operators.
+      def aligned_with_preceding_equals_operator(token)
         preceding_line_range = token.line.downto(1)
 
-        aligned_with_assignment(token, preceding_line_range)
+        aligned_with_equals_sign(token, preceding_line_range)
       end
 
-      def aligned_with_subsequent_assignment(token)
+      # Allows alignment with a subsequent operator that ends with an `=`,
+      # including assignment and comparison operators.
+      def aligned_with_subsequent_equals_operator(token)
         subsequent_line_range = token.line.upto(processed_source.lines.length)
 
-        aligned_with_assignment(token, subsequent_line_range)
+        aligned_with_equals_sign(token, subsequent_line_range)
       end
 
       def aligned_with_adjacent_line?(range, predicate)
@@ -60,9 +69,17 @@ module RuboCop
           line = processed_source.lines[lineno]
           index = line =~ /\S/
           next unless index
-          next if indent && indent != index
 
-          return yield(range, line)
+          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
         false
       end
@@ -74,41 +91,58 @@ module RuboCop
           end.map(&:line)
       end
 
-      def aligned_token?(range, line)
-        aligned_words?(range, line) ||
-          aligned_char?(range, line) ||
-          aligned_assignment?(range, line)
+      def aligned_token?(range, line, lineno)
+        aligned_words?(range, line) || aligned_equals_operator?(range, lineno)
       end
 
-      def aligned_operator?(range, line)
-        (aligned_identical?(range, line) || aligned_assignment?(range, line))
+      def aligned_operator?(range, line, lineno)
+        aligned_identical?(range, line) || aligned_equals_operator?(range, lineno)
       end
 
       def aligned_words?(range, line)
-        /\s\S/.match?(line[range.column - 1, 2])
+        left_edge = range.column
+        return true if /\s\S/.match?(line[left_edge - 1, 2])
+
+        token = range.source
+        token == line[left_edge, token.length]
       end
 
-      def aligned_char?(range, line)
-        line[range.column] == range.source[0]
+      def aligned_equals_operator?(range, lineno)
+        # Check that the operator is aligned with a previous assignment or comparison operator
+        # ie. an equals sign, an operator assignment (eg. `+=`), a comparison (`==`, `<=`, etc.).
+        # Since append operators (`<<`) are a type of assignment, they are allowed as well,
+        # despite not ending with a literal equals character.
+        line_range = processed_source.buffer.line_range(lineno)
+        return false unless line_range
+
+        # Find the specific token to avoid matching up to operators inside strings
+        operator_token = processed_source.tokens_within(line_range).detect do |token|
+          ASSIGNMENT_OR_COMPARISON_TOKENS.include?(token.type)
+        end
+
+        aligned_with_preceding_equals?(range, operator_token) ||
+          aligned_with_append_operator?(range, operator_token)
       end
 
-      def aligned_assignment?(range, line)
-        (range.source[-1] == '=' && line[range.last_column - 1] == '=') ||
-          aligned_with_append_operator?(range, line)
+      def aligned_with_preceding_equals?(range, token)
+        return false unless token
+
+        range.source[-1] == '=' && range.last_column == token.pos.last_column
       end
 
-      def aligned_with_append_operator?(range, line)
-        last_column = range.last_column
+      def aligned_with_append_operator?(range, token)
+        return false unless token
 
-        (range.source == '<<' && line[last_column - 1] == '=') ||
-          (range.source[-1] == '=' && line[(last_column - 2)..(last_column - 1)] == '<<')
+        ((range.source == '<<' && token.equal_sign?) ||
+          (range.source[-1] == '=' && token.type == :tLSHFT)) &&
+          token && range.last_column == token.pos.last_column
       end
 
       def aligned_identical?(range, line)
         range.source == line[range.column, range.size]
       end
 
-      def aligned_with_assignment(token, line_range)
+      def aligned_with_equals_sign(token, line_range)
         token_line_indent    = processed_source.line_indentation(token.line)
         assignment_lines     = relevant_assignment_lines(line_range)
         relevant_line_number = assignment_lines[1]
@@ -118,12 +152,9 @@ module RuboCop
         relevant_indent = processed_source.line_indentation(relevant_line_number)
 
         return :none if relevant_indent < token_line_indent
+        return :none unless processed_source.lines[relevant_line_number - 1]
 
-        assignment_line = processed_source.lines[relevant_line_number - 1]
-
-        return :none unless assignment_line
-
-        aligned_assignment?(token.pos, assignment_line) ? :yes : :no
+        aligned_equals_operator?(token.pos, relevant_line_number) ? :yes : :no
       end
 
       def assignment_lines
@@ -134,10 +165,14 @@ module RuboCop
         @assignment_tokens ||= begin
           tokens = processed_source.tokens.select(&:equal_sign?)
 
-          # we don't want to operate on equals signs which are part of an
-          #   optarg in a method definition
-          # e.g.: def method(optarg = default_val); end
-          tokens = remove_optarg_equals(tokens, processed_source)
+          # We don't want to operate on equals signs which are part of an `optarg` in a
+          # method definition, or the separator of an endless method definition.
+          # For example (the equals sign to ignore is highlighted with ^):
+          #     def method(optarg = default_val); end
+          #                       ^
+          #     def method = foo
+          #                ^
+          tokens = remove_equals_in_def(tokens, processed_source)
 
           # Only attempt to align the first = on each line
           Set.new(tokens.uniq(&:line))
@@ -147,20 +182,58 @@ module RuboCop
       # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
       # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength
       def relevant_assignment_lines(line_range)
+        relevant_lines(line_range) { |line_number| assignment_lines.include?(line_number) }
+      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
@@ -173,10 +246,18 @@ module RuboCop
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
       # rubocop:enable Metrics/PerceivedComplexity, Metrics/MethodLength
 
-      def remove_optarg_equals(asgn_tokens, processed_source)
-        optargs    = processed_source.ast.each_node(:optarg)
-        optarg_eql = optargs.to_set { |o| o.loc.operator.begin_pos }
-        asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
+      def remove_equals_in_def(asgn_tokens, processed_source)
+        nodes = processed_source.ast.each_node(:optarg, :def)
+        eqls_to_ignore = nodes.with_object([]) do |node, arr|
+          loc = if node.def_type?
+                  node.loc.assignment if node.endless?
+                else
+                  node.loc.operator
+                end
+          arr << loc.begin_pos if loc
+        end
+
+        asgn_tokens.reject { |t| eqls_to_ignore.include?(t.begin_pos) }
       end
     end
   end