rubocop 1.80.2 → 1.86.1

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

@@ -46,10 +46,12 @@ module RuboCop
       #                  .a
       #                  .b
       #                  .c
-      class MultilineMethodCallIndentation < Base
+      #
+      class MultilineMethodCallIndentation < Base # rubocop:disable Metrics/ClassLength
         include ConfigurableEnforcedStyle
         include Alignment
         include MultilineExpressionIndentation
+        include RangeHelp
         extend AutoCorrector
 
         def validate_config
@@ -64,8 +66,39 @@ module RuboCop
 
         private
 
+        def find_base_receiver(node)
+          base_receiver = node
+          base_receiver = base_receiver.receiver while base_receiver.receiver
+          base_receiver
+        end
+
+        def find_pair_ancestor(node)
+          node.each_ancestor.find(&:pair_type?)
+        end
+
+        def unwrap_block_node(node)
+          node&.any_block_type? ? node.send_node : node
+        end
+
         def autocorrect(corrector, node)
-          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+          if @send_node.block_node
+            correct_selector_only(corrector, node)
+            correct_block(corrector, @send_node.block_node)
+          else
+            AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+          end
+        end
+
+        def correct_selector_only(corrector, node)
+          selector_line = processed_source.buffer.line_range(node.first_line)
+          selector_range = range_between(selector_line.begin_pos, selector_line.end_pos)
+          AlignmentCorrector.correct(corrector, processed_source, selector_range, @column_delta)
+        end
+
+        def correct_block(corrector, block_node)
+          AlignmentCorrector.correct(corrector, processed_source, block_node.body, @column_delta)
+          end_range = range_by_whole_lines(block_node.loc.end, include_final_newline: false)
+          AlignmentCorrector.correct(corrector, processed_source, end_range, @column_delta)
         end
 
         def relevant_node?(send_node)
@@ -86,27 +119,113 @@ module RuboCop
 
         def offending_range(node, lhs, rhs, given_style)
           return false unless begins_its_line?(rhs)
-          return false if not_for_this_cop?(node)
 
+          @send_node = node # Store for use in autocorrect
+          pair_ancestor = find_pair_ancestor(node)
+          if hash_pair_aligned?(pair_ancestor, given_style)
+            return check_hash_pair_indentation(node, lhs, rhs)
+          end
+          if hash_pair_indented?(node, pair_ancestor, given_style)
+            return check_hash_pair_indented_style(rhs, pair_ancestor)
+          end
+          return false if skip_for_context?(node, pair_ancestor)
+
+          check_regular_indentation(node, lhs, rhs, given_style)
+        end
+
+        def skip_for_context?(node, pair_ancestor)
+          pair_ancestor ? inside_multiline_chain_arg?(node) : not_for_this_cop?(node)
+        end
+
+        def hash_pair_aligned?(pair_ancestor, given_style)
+          pair_ancestor && given_style == :aligned
+        end
+
+        def hash_pair_indented?(node, pair_ancestor, given_style)
+          pair_ancestor && given_style == :indented && find_base_receiver(node).hash_type?
+        end
+
+        def check_hash_pair_indented_style(rhs, pair_ancestor)
+          pair_key = pair_ancestor.key
+          double_indentation = configured_indentation_width * 2
+          correct_column = pair_key.source_range.column + double_indentation
+          @hash_pair_base_column = pair_key.source_range.column + configured_indentation_width
+
+          calculate_column_delta_offense(rhs, correct_column)
+        end
+
+        def check_hash_pair_indentation(node, lhs, rhs)
+          @base = find_hash_pair_alignment_base(node)
+          return false if !@base && inside_multiline_chain_arg?(node)
+
+          @base ||= lhs.source_range
+          return if aligned_with_first_line_dot?(node, rhs)
+
+          calculate_column_delta_offense(rhs, @base.column)
+        end
+
+        def find_hash_pair_alignment_base(node)
+          base_receiver = find_base_receiver(node.receiver)
+          return unless base_receiver.hash_type?
+
+          first_call = first_call_has_a_dot(node)
+          first_call.loc.dot.join(first_call.loc.selector)
+        end
+
+        def inside_multiline_chain_arg?(node)
+          enclosing_call = find_enclosing_chain_call(node)
+          return false unless enclosing_call
+
+          !same_line?(enclosing_call.loc.selector, enclosing_call.receiver.source_range)
+        end
+
+        def find_enclosing_chain_call(node)
+          hash_ancestor = find_pair_ancestor(node).parent
+          enclosing_call = hash_ancestor.parent
+          return unless hash_arg_in_chain?(enclosing_call, hash_ancestor)
+
+          enclosing_call
+        end
+
+        def hash_arg_in_chain?(call, hash_node)
+          call&.call_type? && call.receiver != hash_node && call.loc?(:dot)
+        end
+
+        def aligned_with_first_line_dot?(node, rhs)
+          return false unless rhs.source.start_with?('.', '&.')
+
+          first_call = first_call_has_a_dot(node)
+          return false if first_call == node.receiver
+
+          dot = first_call.loc.dot
+          dot.line == node.first_line && dot.column == rhs.column
+        end
+
+        def check_regular_indentation(node, lhs, rhs, given_style)
           @base = alignment_base(node, rhs, given_style)
           correct_column = if @base
-                             @base.column + extra_indentation(given_style, node.parent)
+                             parent = node.parent
+                             parent = parent.parent if parent&.any_block_type?
+                             @base.column + extra_indentation(given_style, parent)
                            else
                              indentation(lhs) + correct_indentation(node)
                            end
+
+          calculate_column_delta_offense(rhs, correct_column)
+        end
+
+        def calculate_column_delta_offense(rhs, correct_column)
           @column_delta = correct_column - rhs.column
           rhs if @column_delta.nonzero?
         end
 
         def extra_indentation(given_style, parent)
-          if given_style == :indented_relative_to_receiver
-            if parent&.type?(:splat, :kwsplat)
-              configured_indentation_width - parent.loc.operator.length
-            else
-              configured_indentation_width
-            end
+          return 0 unless given_style == :indented_relative_to_receiver
+
+          if parent&.type?(:splat, :kwsplat)
+            configured_indentation_width - parent.loc.operator.length
           else
-            0
+            configured_indentation_width
           end
         end
 
@@ -125,7 +244,7 @@ module RuboCop
         end
 
         def should_align_with_base?
-          @base && style != :indented_relative_to_receiver
+          @base && style == :aligned
         end
 
         def relative_to_receiver_message(rhs)
@@ -142,10 +261,16 @@ module RuboCop
         end
 
         def no_base_message(lhs, rhs, node)
-          used_indentation = rhs.column - indentation(lhs)
+          if @hash_pair_base_column
+            used_indentation = rhs.column - @hash_pair_base_column
+            expected_indentation = configured_indentation_width
+          else
+            used_indentation = rhs.column - indentation(lhs)
+            expected_indentation = correct_indentation(node)
+          end
           what = operation_description(node, rhs)
 
-          "Use #{correct_indentation(node)} (not #{used_indentation}) " \
+          "Use #{expected_indentation} (not #{used_indentation}) " \
             "spaces for indenting #{what} spanning multiple lines."
         end
 
@@ -153,8 +278,6 @@ module RuboCop
           case given_style
           when :aligned
             semantic_alignment_base(node, rhs) || syntactic_alignment_base(node, rhs)
-          when :indented
-            nil
           when :indented_relative_to_receiver
             receiver_alignment_base(node)
           end
@@ -182,7 +305,7 @@ module RuboCop
           return unless rhs.source.start_with?('.', '&.')
 
           node = semantic_alignment_node(node)
-          return unless node&.loc&.selector && node.loc.dot
+          return unless node&.loc?(:selector) && node.loc.dot
 
           node.loc.dot.join(node.loc.selector)
         end
@@ -191,29 +314,55 @@ module RuboCop
         #   .b
         #   .c
         def receiver_alignment_base(node)
-          node = node.receiver while node.receiver
-          node = node.parent
-          node = node.parent until node.loc.dot
+          hash_method_base = find_hash_method_base_in_receiver_chain(node)
+          return hash_method_base if hash_method_base
+
+          first_call = first_call_has_a_dot(node)
+          first_call.receiver.source_range
+        end
+
+        def find_hash_method_base_in_receiver_chain(node)
+          receiver_chain = unwrap_block_node(node.receiver)
+          while receiver_chain&.call_type?
+            base_receiver = unwrap_block_node(receiver_chain.receiver)
+            if alignment_base_for_chained_receiver?(receiver_chain, base_receiver)
+              return receiver_chain.loc.dot.join(receiver_chain.loc.selector)
+            end
+
+            receiver_chain = base_receiver
+          end
+        end
 
-          node&.receiver&.source_range
+        def alignment_base_for_chained_receiver?(receiver_chain, base_receiver)
+          base_receiver&.hash_type? ||
+            method_on_receiver_last_line?(receiver_chain, base_receiver, :begin)
         end
 
         def semantic_alignment_node(node)
           return if argument_in_method_call(node, :with_parentheses)
 
-          dot_right_above = get_dot_right_above(node)
-          return dot_right_above if dot_right_above
-
-          if (multiline_block_chain_node = find_multiline_block_chain_node(node))
-            return multiline_block_chain_node
-          end
+          get_dot_right_above(node) ||
+            find_multiline_block_chain_node(node) ||
+            first_call_alignment_node(node)
+        end
 
+        def first_call_alignment_node(node)
           node = first_call_has_a_dot(node)
+          base_receiver = find_base_receiver(node)
+
+          return node if method_on_receiver_last_line?(node, base_receiver, :array)
           return if node.loc.dot.line != node.first_line
+          return if method_on_receiver_last_line?(node, base_receiver, :begin)
 
           node
         end
 
+        def method_on_receiver_last_line?(node, base_receiver, type)
+          return false unless base_receiver
+
+          same_line?(node.loc.dot, base_receiver.source_range.end) && base_receiver.type?(type)
+        end
+
         def get_dot_right_above(node)
           node.each_ancestor.find do |a|
             dot = a.loc.dot if a.loc?(:dot)
@@ -224,23 +373,39 @@ module RuboCop
         end
 
         def find_multiline_block_chain_node(node)
-          return unless (block_node = node.each_descendant(:any_block).first)
-          return unless block_node.multiline? && block_node.parent.call_type?
+          return find_continuation_node(node) if node.block_node
 
-          if node.receiver.call_type?
-            node.receiver
-          else
-            block_node.parent
-          end
+          handle_descendant_block(node)
+        end
+
+        def find_continuation_node(node)
+          receiver = node.receiver
+          return receiver.send_node if single_line_block_receiver?(receiver)
+          return unless receiver.call_type? && receiver.loc.dot
+          return receiver if receiver.receiver.begin_type? && node.block_node.single_line?
+          return unless receiver.loc.dot.line > receiver.receiver.last_line
+
+          receiver
+        end
+
+        def single_line_block_receiver?(receiver)
+          receiver.single_line? && receiver.any_block_type?
+        end
+
+        def handle_descendant_block(node)
+          receiver = node.receiver
+          return receiver.send_node if single_line_block_receiver?(receiver)
+
+          block_node = node.each_descendant(:any_block).first
+          return unless block_node&.multiline?
+
+          receiver.call_type? ? receiver : block_node.parent
         end
 
         def first_call_has_a_dot(node)
-          # descend to root of method chain
-          node = node.receiver while node.receiver
-          # ascend to first call which has a dot
-          node = node.parent
+          base = find_base_receiver(node)
+          node = base.parent
           node = node.parent until node.loc?(:dot)
-
           node
         end
 

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

@@ -102,10 +102,12 @@ module RuboCop
             return true if begins_its_line?(assignment_rhs.source_range)
           end
 
-          given_style == :aligned &&
-            (kw_node_with_special_indentation(node) ||
-             assignment_node ||
-             argument_in_method_call(node, :with_or_without_parentheses))
+          return false unless given_style == :aligned
+          return true if kw_node_with_special_indentation(node) || assignment_node
+
+          node = argument_in_method_call(node, :with_or_without_parentheses)
+
+          node.respond_to?(:def_modifier?) && !node.def_modifier?
         end
 
         def message(node, lhs, rhs)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Check that the parameters on a multi-line method call or definition are aligned.
+      # Checks that the parameters on a multi-line method call or definition are aligned.
       #
       # To set the alignment of the first argument, use the
       # `Layout/FirstParameterIndentation` cop.

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

@@ -114,7 +114,7 @@ module RuboCop
 
         def other_cop_takes_precedence?(node)
           single_line_block_chain_enabled? && any_descendant?(node, :any_block) do |block_node|
-            block_node.parent.send_type? && block_node.parent.loc.dot && !block_node.multiline?
+            block_node.parent.send_type? && block_node.parent.loc.dot && block_node.single_line?
           end
         end
 

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

@@ -29,7 +29,7 @@ module RuboCop
         MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
               'aligned with `%<beginning>s` at ' \
               '%<begin_loc_line>d, %<begin_loc_column>d.'
-        ANCESTOR_TYPES = %i[kwbegin any_def class module any_block].freeze
+        ANCESTOR_TYPES = %i[kwbegin any_def class module sclass any_block].freeze
         ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method private_class_method].freeze
 
         def on_resbody(node)
@@ -91,7 +91,7 @@ module RuboCop
           )
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
@@ -100,6 +100,8 @@ module RuboCop
             when :def, :defs, :class, :module,
                  :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
               node.loc.name
+            when :sclass
+              node.identifier.source_range
             when :masgn
               node.lhs.source_range
             else
@@ -109,7 +111,7 @@ module RuboCop
 
           range_between(starting_loc.begin_pos, ending_loc.end_pos).source
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         # We will use ancestor or wrapper with access modifier.
 
@@ -194,6 +196,14 @@ module RuboCop
         def alignment_location(alignment_node)
           if begin_end_alignment_style == 'start_of_line'
             start_line_range(alignment_node)
+          elsif alignment_node.any_block_type?
+            # If the alignment node is a block, the `rescue`/`ensure` keyword should
+            # be aligned to the start of the block. It is possible that the block's
+            # `send_node` spans multiple lines, in which case it should align to the
+            # start of the last line.
+            send_node = alignment_node.send_node
+            range = processed_source.buffer.line_range(send_node.last_line)
+            range.adjust(begin_pos: range.source =~ /\S/)
           else
             alignment_node.source_range
           end

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

@@ -23,16 +23,8 @@ module RuboCop
           cfg['EnforcedStyle'] || 'space'
         end
 
-        def kind(token)
-          'comma' if token.comma? && !before_semicolon?(token)
-        end
-
-        private
-
-        def before_semicolon?(token)
-          tokens = processed_source.tokens
-
-          tokens[tokens.index(token) + 1].semicolon?
+        def kind(token, next_token)
+          'comma' if token.comma? && !next_token.semicolon?
         end
       end
     end

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

@@ -20,7 +20,7 @@ module RuboCop
           cfg['EnforcedStyle'] || 'space'
         end
 
-        def kind(token)
+        def kind(token, _next_token)
           'semicolon' if token.semicolon?
         end
 

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

@@ -29,7 +29,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           arguments = node.arguments
 
           return unless node.arguments? && pipes?(arguments)

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

@@ -47,9 +47,11 @@ module RuboCop
           check(node, [:operator].freeze) if node.keyword?
         end
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node)
           check(node, %i[begin end].freeze)
         end
+        alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_break(node)
           check(node, [:keyword].freeze)
@@ -167,7 +169,7 @@ module RuboCop
 
         def check(node, locations, begin_keyword = DO)
           locations.each do |loc|
-            next unless node.loc.respond_to?(loc)
+            next unless node.loc?(loc)
 
             range = node.loc.public_send(loc)
             next unless range

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

@@ -7,18 +7,18 @@ module RuboCop
       # parenthesis (`(`) in lambda literals.
       #
       # @example EnforcedStyle: require_no_space (default)
-      #     # bad
-      #     a = -> (x, y) { x + y }
+      #   # bad
+      #   a = -> (x, y) { x + y }
       #
-      #     # good
-      #     a = ->(x, y) { x + y }
+      #   # good
+      #   a = ->(x, y) { x + y }
       #
       # @example EnforcedStyle: require_space
-      #     # bad
-      #     a = ->(x, y) { x + y }
+      #   # bad
+      #   a = ->(x, y) { x + y }
       #
-      #     # good
-      #     a = -> (x, y) { x + y }
+      #   # good
+      #   a = -> (x, y) { x + y }
       class SpaceInLambdaLiteral < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
@@ -26,6 +26,7 @@ module RuboCop
 
         MSG_REQUIRE_SPACE = 'Use a space between `->` and `(` in lambda literals.'
         MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and `(` in lambda literals.'
+        RESTRICT_ON_SEND = %i[lambda].freeze
 
         def on_send(node)
           return unless arrow_lambda_with_args?(node)

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

@@ -113,7 +113,7 @@ module RuboCop
           return [] unless ast
 
           heredocs = []
-          ast.each_node(:str, :dstr, :xstr) do |node|
+          ast.each_node(:any_str) do |node|
             next unless node.heredoc?
 
             body = node.location.heredoc_body

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

@@ -35,6 +35,26 @@ module RuboCop
       #   def cook(dry_ingredients = self.dry_ingredients)
       #     dry_ingredients.combine
       #   end
+      #
+      #   # bad
+      #   def foo(pie = pie = pie)
+      #     pie.heat_up
+      #   end
+      #
+      #   # good
+      #   def foo(pie)
+      #     pie.heat_up
+      #   end
+      #
+      #   # bad
+      #   def foo(pie = cake = pie)
+      #     [pie, cake].each(&:heat_up)
+      #   end
+      #
+      #   # good
+      #   def foo(cake = pie)
+      #     [pie, cake].each(&:heat_up)
+      #   end
       class CircularArgumentReference < Base
         extend TargetRubyVersion
 
@@ -51,11 +71,35 @@ module RuboCop
         private
 
         def check_for_circular_argument_references(arg_name, arg_value)
-          return unless arg_value.lvar_type?
-          return unless arg_value.to_a == [arg_name]
+          if arg_value.lvar_type? && arg_value.to_a == [arg_name]
+            add_offense(arg_value, message: format(MSG, arg_name: arg_name))
+
+            return
+          end
+
+          check_assignment_chain(arg_name, arg_value)
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def check_assignment_chain(arg_name, node)
+          return unless node.lvasgn_type?
+
+          seen_variables = Set[]
+          current_node = node
+
+          while current_node.lvasgn_type?
+            seen_variables << current_node.children.first if current_node.lvasgn_type?
+            current_node = current_node.children.last
+          end
+
+          return unless current_node.lvar_type?
+
+          variable_node = current_node.children.first
+          return unless seen_variables.include?(variable_node) || variable_node == arg_name
 
-          add_offense(arg_value, message: format(MSG, arg_name: arg_name))
+          add_offense(current_node, message: format(MSG, arg_name: arg_name))
         end
+        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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

@@ -31,7 +31,7 @@ module RuboCop
 
         # @!method overwritten_constant(node)
         def_node_matcher :overwritten_constant, <<~PATTERN
-          (resbody nil? (casgn nil? $_) nil?)
+          (resbody nil? $(casgn _ _) nil?)
         PATTERN
 
         def self.autocorrect_incompatible_with
@@ -41,7 +41,8 @@ module RuboCop
         def on_resbody(node)
           return unless (constant = overwritten_constant(node))
 
-          add_offense(node.loc.assoc, message: format(MSG, constant: constant)) do |corrector|
+          message = format(MSG, constant: constant.source)
+          add_offense(node.loc.assoc, message: message) do |corrector|
             corrector.remove(range_between(node.loc.keyword.end_pos, node.loc.assoc.end_pos))
           end
         end