rubocop 1.89.0 → 1.90.0

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

@@ -5,6 +5,14 @@ module RuboCop
     module Layout
       # Checks for a newline after the final magic comment.
       #
+      # `NumberOfEmptyLines` configures the minimum number of empty lines required. Set it
+      # to `2` when using YARD, which otherwise treats the magic comments as documentation
+      # for the first module or class in the file.
+      #
+      # NOTE: `Layout/EmptyLines` has to be disabled for values greater than `1`, as it
+      # removes the extra empty lines this cop adds, and autocorrecting with both enabled
+      # loops between them.
+      #
       # @example
       #   # good
       #   # frozen_string_literal: true
@@ -20,30 +28,80 @@ module RuboCop
       #   class Person
       #     # Some code
       #   end
+      #
+      # @example NumberOfEmptyLines: 1 (default)
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #   class Person
+      #   end
+      #
+      # @example NumberOfEmptyLines: 2
+      #   # bad
+      #   # frozen_string_literal: true
+      #
+      #   class Person
+      #   end
+      #
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #
+      #   class Person
+      #   end
       class EmptyLineAfterMagicComment < Base
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Add an empty line after magic comments.'
+        MSG = 'Expected at least %<expected>d empty %<lines>s after magic comments; found ' \
+              '%<actual>d.'
+
+        def validate_config
+          return if number_of_empty_lines.is_a?(Integer) && number_of_empty_lines.positive?
+
+          raise ValidationError,
+                'The `Layout/EmptyLineAfterMagicComment` cop only accepts a positive ' \
+                'integer for its `NumberOfEmptyLines` configuration parameter, but ' \
+                "`#{number_of_empty_lines.inspect}` was given."
+        end
 
         def on_new_investigation
           return unless (last_magic_comment = last_magic_comment(processed_source))
-          return unless (next_line = processed_source[last_magic_comment.loc.line])
-          return if next_line.strip.empty?
+
+          actual = empty_lines_after(last_magic_comment)
+          # Trailing empty lines are `Layout/TrailingEmptyLines`' responsibility.
+          return unless processed_source[last_magic_comment.loc.line + actual]
+          return if actual >= number_of_empty_lines
 
           offending_range = offending_range(last_magic_comment)
 
-          add_offense(offending_range) do |corrector|
-            corrector.insert_before(offending_range, "\n")
+          add_offense(offending_range, message: message(actual)) do |corrector|
+            corrector.insert_before(offending_range, "\n" * (number_of_empty_lines - actual))
           end
         end
 
         private
 
+        def message(actual)
+          format(MSG, expected: number_of_empty_lines, actual: actual,
+                      lines: number_of_empty_lines == 1 ? 'line' : 'lines')
+        end
+
+        def empty_lines_after(last_magic_comment)
+          first_line = last_magic_comment.loc.line
+          count = 0
+          count += 1 while (line = processed_source[first_line + count]) && line.strip.empty?
+          count
+        end
+
         def offending_range(last_magic_comment)
           source_range(processed_source.buffer, last_magic_comment.loc.line + 1, 0)
         end
 
+        def number_of_empty_lines
+          cop_config.fetch('NumberOfEmptyLines', 1)
+        end
+
         # Find the last magic comment in the source file.
         #
         # Take all comments that precede the first line of code (or just take

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

@@ -123,7 +123,7 @@ module RuboCop
           AlignmentCorrector.align_end(corrector, processed_source, node, alignment_node(node))
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def check_assignment(node, rhs)
           # If there are method calls chained to the right hand side of the
           # assignment, we let rhs be the receiver of those method calls before
@@ -139,7 +139,6 @@ module RuboCop
 
           check_asgn_alignment(node, rhs)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def check_asgn_alignment(outer_node, inner_node)
           align_with = {

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

@@ -41,6 +41,7 @@ module RuboCop
 
           @aligned_comments = aligned_locations(processed_source.comments.map(&:loc))
           @corrected = Set.new if force_equal_sign_alignment?
+          prepare_alignment_data
 
           processed_source.tokens.each_cons(2) do |token1, token2|
             check_tokens(processed_source.ast, token1, token2)
@@ -95,19 +96,120 @@ module RuboCop
           end_pos = token2.begin_pos - 1
           return if end_pos <= start_pos
 
-          return if allow_for_alignment? && aligned_tok?(token2)
+          return if allow_for_alignment? && aligned_tok?(token1, token2)
 
           yield range_between(start_pos, end_pos)
         end
 
-        def aligned_tok?(token)
+        def aligned_tok?(previous_token, token)
           if token.comment?
             @aligned_comments.include?(token.line)
           else
-            aligned_with_something?(token.pos)
+            aligned_with_something?(token.pos) &&
+              (ASSIGNMENT_OR_COMPARISON_TOKENS.include?(token.type) ||
+               spacing_varies?(previous_token, token))
           end
         end
 
+        def spacing_varies?(previous_token, token)
+          by_column, typed = group_profile(token.line)
+          column = token.pos.column
+          lines, spacings = typed[[column, token.type]]
+          entries = by_column[column]
+
+          if lines.size > 1
+            uniform_alignment_allowed?(token, lines, spacings)
+          elsif entries.size > 1
+            distinct_spacings(entries).size > 1
+          else
+            nearest_spacing_varies?(previous_token, token)
+          end
+        end
+
+        def uniform_alignment_allowed?(token, lines, spacings)
+          return @alignment_verdicts[lines] if @alignment_verdicts.key?(lines)
+
+          @alignment_verdicts[lines] =
+            spacings.uniq.size > 1 || aligned_on_other_column?(token, lines)
+        end
+
+        def aligned_on_other_column?(token, lines)
+          line_set = Set.new(lines)
+          by_column, = group_profile(token.line)
+
+          by_column.any? do |column, entries|
+            next false if column == token.pos.column
+
+            shared = entries.filter_map { |line, spacing| spacing if line_set.include?(line) }
+            shared.uniq.size > 1
+          end
+        end
+
+        def distinct_spacings(entries)
+          entries.map(&:last).uniq
+        end
+
+        def group_profile(line_number)
+          group = alignment_lines(line_number)
+
+          @group_profiles[group] ||= build_group_profile(group)
+        end
+
+        def build_group_profile(group)
+          by_column = Hash.new { |hash, key| hash[key] = [] }
+          typed = Hash.new { |hash, key| hash[key] = [[], []] }
+
+          group.each { |line| record_line_spacings(by_column, typed, line) }
+
+          [by_column, typed]
+        end
+
+        def record_line_spacings(by_column, typed, line)
+          @tokens_by_line[line]&.each_cons(2) do |previous_token, token|
+            spacing = token.begin_pos - previous_token.end_pos
+            by_column[token.pos.column] << [line, spacing]
+            lines, spacings = typed[[token.pos.column, token.type]]
+            lines << line
+            spacings << spacing
+          end
+        end
+
+        def nearest_spacing_varies?(previous_token, token)
+          spacing = token.begin_pos - previous_token.end_pos
+          line_ranges = [(token.line - 1).downto(1),
+                         (token.line + 1).upto(processed_source.lines.length)]
+
+          line_ranges.any? do |line_numbers|
+            nearest_spacing_differs?(line_numbers, token, spacing)
+          end
+        end
+
+        def nearest_spacing_differs?(line_numbers, token, spacing)
+          line_numbers.each do |line|
+            break if definition_boundary_lines.include?(line)
+            next if aligned_comment_lines.include?(line)
+
+            other_spacing = spacing_before_token_at(line, token.pos.column)
+            return other_spacing != spacing if other_spacing
+          end
+
+          false
+        end
+
+        def spacing_before_token_at(line_number, column)
+          tokens = @tokens_by_line[line_number]
+          index = tokens&.index { |token| token.pos.column == column }
+          return unless index&.positive?
+
+          tokens[index].begin_pos - tokens[index - 1].end_pos
+        end
+
+        def prepare_alignment_data
+          @group_profiles = {}.compare_by_identity
+          @alignment_verdicts = {}.compare_by_identity
+          @tokens_by_line = processed_source.tokens.group_by(&:line)
+        end
+
         def ignored_range?(ast, start_pos)
           ignored_ranges(ast).any? { |r| r.include?(start_pos) }
         end

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

@@ -156,7 +156,8 @@ module RuboCop
           return unless should_check?(node)
           return if same_line?(node, node.first_argument)
           return if enforce_first_argument_with_fixed_indentation? &&
-                    !enable_layout_first_method_argument_line_break?
+                    (!enable_layout_first_method_argument_line_break? ||
+                     conflicts_with_fixed_indentation_alignment?(node))
 
           indent = base_indentation(node) + configured_indentation_width
 
@@ -309,6 +310,25 @@ module RuboCop
         def enable_layout_first_method_argument_line_break?
           config.cop_enabled?('Layout/FirstMethodArgumentLineBreak')
         end
+
+        def conflicts_with_fixed_indentation_alignment?(node)
+          return false unless special_inner_call_indentation?(node)
+          return false unless argument_alignment_applies?(node)
+
+          base_indentation(node) != indentation_of_method_line(node)
+        end
+
+        def argument_alignment_applies?(node)
+          return false if !node.call_type? || node.method?(:[]=)
+
+          node.arguments.size >= 2 ||
+            (node.first_argument.hash_type? && node.first_argument.pairs.count >= 2)
+        end
+
+        def indentation_of_method_line(node)
+          lineno = node.loc.selector ? node.loc.selector.line : node.loc.begin.line
+          processed_source.lines[lineno - 1] =~ /\S/
+        end
       end
     end
   end

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

@@ -87,7 +87,7 @@ module RuboCop
           corrector.replace(range, correction)
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def ignored_literal_ranges(ast)
           # which lines start inside a string literal?
           return [] if ast.nil?
@@ -106,7 +106,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def comment_ranges(comments)
           comments.map(&:source_range)

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

@@ -328,7 +328,7 @@ module RuboCop
           [max - indentation_difference(line), 0].max
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_line(line, line_index)
           return if line_length(line) <= max
           return if allowed_line?(line, line_index)
@@ -348,7 +348,6 @@ module RuboCop
 
           register_offense(excess_range(nil, line, line_index), line, line_index)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def allowed_line?(line, line_index)
           matches_allowed_pattern?(line) ||

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

@@ -71,7 +71,7 @@ module RuboCop
 
         BLOCK_TYPES = %i[block numblock itblock].freeze
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_assignment(node, rhs)
           return if node.send_type? && node.loc.operator&.source != '='
           return unless rhs
@@ -80,7 +80,6 @@ module RuboCop
 
           check_by_enforced_style(node, rhs)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def check_by_enforced_style(node, rhs)
           case style

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

@@ -423,11 +423,11 @@ module RuboCop
         end
 
         def leftmost_call_on_same_line(node)
-          current = node.any_block_type? ? node.send_node : node
-          while current.receiver&.call_type? &&
-                current.receiver.loc?(:dot) &&
-                current.receiver.loc.dot.line == current.loc.dot.line
-            current = current.receiver
+          current = unwrap_block_node(node)
+          while (receiver = unwrap_block_node(current.receiver)) &&
+                receiver.call_type? && receiver.loc?(:dot) &&
+                receiver.loc.dot.line == current.loc.dot.line
+            current = receiver
           end
           current
         end

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

@@ -91,7 +91,7 @@ module RuboCop
           )
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
@@ -111,7 +111,6 @@ module RuboCop
 
           range_between(starting_loc.begin_pos, ending_loc.end_pos).source
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         # We will use ancestor or wrapper with access modifier.
 

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

@@ -129,6 +129,12 @@ module RuboCop
           check_operator(:class, node.loc.operator, rhs)
         end
 
+        def on_def(node)
+          return unless node.endless?
+
+          check_operator(:assignment, node.loc.assignment, node.body)
+        end
+
         def on_binary(node)
           rhs = node.rhs
 
@@ -170,6 +176,7 @@ module RuboCop
         alias on_or_asgn  on_assignment
         alias on_and_asgn on_assignment
         alias on_op_asgn  on_assignment
+        alias on_defs     on_def
 
         private
 

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

@@ -153,7 +153,7 @@ module RuboCop
           [token.line - 1, token.column - 1]
         end
 
-        # rubocop:disable Metrics/ParameterLists
+        # rubocop:disable-next Metrics/ParameterLists
         def issue_offenses(node, tokens, left, right, start_ok, end_ok)
           case style
           when :no_space
@@ -165,13 +165,12 @@ module RuboCop
             compact_offenses(node, tokens, left, right, start_ok, end_ok)
           end
         end
-        # rubocop:enable Metrics/ParameterLists
 
         def next_to_comment?(tokens, token)
           tokens[index_for(tokens, token) + 1].comment?
         end
 
-        # rubocop:disable Metrics/ParameterLists
+        # rubocop:disable-next Metrics/ParameterLists
         def compact_offenses(node, tokens, left, right, start_ok, end_ok)
           if qualifies_for_compact?(tokens, left, side: :left)
             compact_offense(node, left, side: :left)
@@ -185,7 +184,6 @@ module RuboCop
             space_offenses(node, nil, right, MSG, start_ok: true, end_ok: end_ok)
           end
         end
-        # rubocop:enable Metrics/ParameterLists
 
         def qualifies_for_compact?(tokens, token, side: :right)
           if side == :right

data/lib/rubocop/cop/lint/ambiguous_range.rb

@@ -83,14 +83,13 @@ module RuboCop
           yield range.end if range.end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def acceptable?(node)
           node.begin_type? ||
             node.literal? || rational_literal?(node) ||
             node.variable? || node.const_type? || node.self_type? ||
             (node.call_type? && acceptable_call?(node))
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def acceptable_call?(node)
           return true if node.unary_operation?

data/lib/rubocop/cop/lint/argument_mismatch.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for calls that pass the wrong number of positional arguments to a
+      # method whose definition is known from the project index.
+      #
+      # The check is powered by the project-wide index, so it only runs when
+      # `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed.
+      # Without the index the cop does nothing.
+      #
+      # Only calls on constant receivers (`Foo.bar`) are considered, and only
+      # when the receiver resolves in the index, its entire ancestry is resolved
+      # (so a method inherited from a gem or the standard library never produces
+      # an offense), and the called method resolves to a single, unambiguous
+      # signature. Calls that forward arguments (`*`, `**`, `...`) are skipped
+      # because their argument count is not statically known. Keyword arguments
+      # passed to a method that declares no keyword parameters are counted as the
+      # single positional hash they collapse into, matching Ruby's semantics.
+      #
+      # Constructor calls (`Foo.new`) and keyword-argument validation are out of
+      # scope: only positional arity of explicitly defined singleton methods is
+      # checked.
+      #
+      # @example
+      #   # Given the project defines:
+      #   #   class Report
+      #   #     def self.generate(source, format); end
+      #   #   end
+      #
+      #   # bad
+      #   Report.generate(source)
+      #
+      #   # bad
+      #   Report.generate(source, :pdf, :extra)
+      #
+      #   # good
+      #   Report.generate(source, :pdf)
+      #
+      class ArgumentMismatch < Base
+        include ProjectIndexHelp
+        include IndexedMethodArity
+
+        MSG = 'Wrong number of arguments to `%<method>s` (given %<given>d, expected %<expected>s).'
+
+        def on_send(node)
+          return unless project_index
+          return unless node.receiver&.const_type?
+
+          shape = resolved_signature_shape(node)
+          return unless shape
+
+          min, max, has_keywords = shape
+          given = positional_argument_count(node, has_keywords)
+          return if given.nil? || arity_satisfied?(given, min, max)
+
+          add_offense(node.loc.selector, message: message(node, given, min, max))
+        end
+        alias on_csend on_send
+
+        private
+
+        def message(node, given, min, max)
+          format(MSG, method: node.method_name, given: given, expected: expected_range(min, max))
+        end
+
+        # `[min, max, has_keywords]` for the called singleton method, or nil when
+        # the receiver or its ancestry is not resolved.
+        def resolved_signature_shape(node)
+          declaration = resolve_constant_in_index(node.receiver)
+          return nil unless declaration.is_a?(Rubydex::Namespace)
+          return nil unless fully_resolved_index_ancestry?(declaration)
+
+          singleton_signature_shape(declaration, node.method_name)
+        rescue StandardError
+          nil
+        end
+
+        def singleton_signature_shape(declaration, method_name)
+          member = indexed_singleton_member(declaration, "#{method_name}()")
+          return nil unless member
+
+          indexed_member_shape(member)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/constant_reassignment.rb

@@ -175,10 +175,19 @@ module RuboCop
         end
 
         def ancestor_namespaces(node)
-          node
-            .each_ancestor(:class, :module)
-            .map { |ancestor| ancestor.identifier.short_name }
-            .reverse
+          ancestors = node.each_ancestor(:class, :module).reverse_each
+
+          ancestors.with_object([]) do |ancestor, namespaces|
+            append_namespaces(namespaces, ancestor.identifier)
+          end
+        end
+
+        # Compact definitions (e.g. `module A::B`) contribute every path segment,
+        # and an absolute one (e.g. `module ::A::B`) discards the enclosing namespaces.
+        def append_namespaces(namespaces, identifier)
+          namespaces.clear if identifier.absolute?
+          namespaces.concat(identifier_namespaces(identifier))
+          namespaces << identifier.short_name
         end
 
         def unconditional_definition?(node)
@@ -188,14 +197,11 @@ module RuboCop
         end
 
         def definition_name(node)
-          identifier = node.identifier
+          namespaces = ancestor_namespaces(node)
+          append_namespaces(namespaces, node.identifier)
+          constant = namespaces.pop
 
-          if identifier.namespace&.cbase_type?
-            fully_qualified_name_for([], identifier.short_name)
-          else
-            namespaces = ancestor_namespaces(node) + identifier_namespaces(identifier)
-            fully_qualified_name_for(namespaces, identifier.short_name)
-          end
+          fully_qualified_name_for(namespaces, constant)
         end
 
         def identifier_namespaces(identifier)