rubocop 1.71.1 → 1.92.0

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

@@ -28,66 +28,66 @@ module RuboCop
       #
       # @example EnforcedStyle: symmetrical (default)
       #
-      #     # bad
-      #     { a: 1,
-      #       b: 2
-      #     }
-      #     # bad
-      #     {
-      #       a: 1,
-      #       b: 2 }
-      #
-      #     # good
-      #     { a: 1,
-      #       b: 2 }
-      #
-      #     # good
-      #     {
-      #       a: 1,
-      #       b: 2
-      #     }
+      #   # bad
+      #   { a: 1,
+      #     b: 2
+      #   }
+      #   # bad
+      #   {
+      #     a: 1,
+      #     b: 2 }
+      #
+      #   # good
+      #   { a: 1,
+      #     b: 2 }
+      #
+      #   # good
+      #   {
+      #     a: 1,
+      #     b: 2
+      #   }
       #
       # @example EnforcedStyle: new_line
-      #     # bad
-      #     {
-      #       a: 1,
-      #       b: 2 }
-      #
-      #     # bad
-      #     { a: 1,
-      #       b: 2 }
-      #
-      #     # good
-      #     { a: 1,
-      #       b: 2
-      #     }
-      #
-      #     # good
-      #     {
-      #       a: 1,
-      #       b: 2
-      #     }
+      #   # bad
+      #   {
+      #     a: 1,
+      #     b: 2 }
+      #
+      #   # bad
+      #   { a: 1,
+      #     b: 2 }
+      #
+      #   # good
+      #   { a: 1,
+      #     b: 2
+      #   }
+      #
+      #   # good
+      #   {
+      #     a: 1,
+      #     b: 2
+      #   }
       #
       # @example EnforcedStyle: same_line
-      #     # bad
-      #     { a: 1,
-      #       b: 2
-      #     }
-      #
-      #     # bad
-      #     {
-      #       a: 1,
-      #       b: 2
-      #     }
-      #
-      #     # good
-      #     {
-      #       a: 1,
-      #       b: 2 }
-      #
-      #     # good
-      #     { a: 1,
-      #       b: 2 }
+      #   # bad
+      #   { a: 1,
+      #     b: 2
+      #   }
+      #
+      #   # bad
+      #   {
+      #     a: 1,
+      #     b: 2
+      #   }
+      #
+      #   # good
+      #   {
+      #     a: 1,
+      #     b: 2 }
+      #
+      #   # good
+      #   { a: 1,
+      #     b: 2 }
       class MultilineHashBraceLayout < Base
         include MultilineLiteralBraceLayout
         extend AutoCorrector
@@ -106,6 +106,13 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'Closing hash brace must be on the same ' \
                                    'line as the last hash element.'
 
+        # Moving the closing brace while `Style/HashAsLastArrayItem` or
+        # `Style/RedundantDoubleSplatHashBraces` removes the braces in the same pass leaves
+        # the brace behind.
+        def self.autocorrect_incompatible_with
+          [Style::HashAsLastArrayItem, Style::RedundantDoubleSplatHashBraces]
+        end
+
         def on_hash(node)
           check_brace_layout(node)
         end

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

@@ -106,6 +106,12 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'Closing method call brace must be on ' \
                                    'the same line as the last argument.'
 
+        # Moving the closing parenthesis and removing it under `omit_parentheses` in the same pass
+        # leaves the moved parenthesis behind.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           check_brace_layout(node)
         end
@@ -124,7 +130,7 @@ module RuboCop
         def single_line_ignoring_receiver?(node)
           return false unless node.loc.begin && node.loc.end
 
-          node.loc.begin.line == node.loc.end.line
+          same_line?(node.loc.begin, node.loc.end)
         end
       end
     end

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,58 @@ 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)
+          child = node
+          node.each_ancestor do |ancestor|
+            return ancestor if ancestor.pair_type?
+            break if grouped_expression?(ancestor) || inside_arg_list_parentheses?(node, ancestor)
+            break if inside_body?(ancestor, child)
+
+            child = ancestor
+          end
+
+          nil
+        end
+
+        # A block, `begin`, `if` or loop body is a separate set of statements, so
+        # a method chain in it is not the value of a hash pair the body is nested in.
+        # The send node of a block is still part of the value.
+        def inside_body?(ancestor, child)
+          return !child.equal?(ancestor.send_node) if ancestor.any_block_type?
+          return !ancestor.ternary? if ancestor.if_type?
+
+          ancestor.type?(:kwbegin, :while, :until, :for)
+        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 +138,138 @@ 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 ||= first_dot_alignment_base(node, rhs) || 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 first_dot_alignment_base(node, rhs)
+          return unless rhs.source.start_with?('.', '&.')
+
+          first_call = first_call_has_a_dot(node)
+          dot = first_call.loc.dot
+          return unless dot
+          return if first_call == node
+
+          after_block_base = after_multiline_block_base(first_call, node)
+          return after_block_base if after_block_base
+
+          return unless same_line?(dot, first_call.receiver.source_range)
+
+          dot.join(first_call.loc.selector)
+        end
+
+        def after_multiline_block_base(first_call, node)
+          return unless first_call.block_node&.multiline?
+
+          after_block = first_call.block_node.parent
+          return unless after_block&.call_type? && after_block.loc?(:dot) && after_block != node
+
+          after_block.loc.dot.join(after_block.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 +288,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 +305,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 +322,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 +349,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,32 +358,58 @@ 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.respond_to?(:dot) && a.loc.dot
+            dot = a.loc.dot if a.loc?(:dot)
             next unless dot
 
             dot.line == node.loc.dot.line - 1 && dot.column == node.loc.dot.column
@@ -224,23 +417,49 @@ 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
+          handle_descendant_block(node)
+        end
+
+        def find_continuation_node(node)
+          receiver = node.receiver
+          return leftmost_call_on_same_line(receiver) 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 leftmost_call_on_same_line(node)
+          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
 
-        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
-          node = node.parent until node.loc.respond_to?(:dot) && node.loc.dot
+        def handle_descendant_block(node)
+          receiver = node.receiver
+          return leftmost_call_on_same_line(receiver) 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)
+          base = find_base_receiver(node)
+          node = base.parent
+          node = node.parent until node.loc?(:dot)
           node
         end
 

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

@@ -118,6 +118,10 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'Closing method definition brace must be ' \
                                    'on the same line as the last parameter.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MultilineMethodSignature]
+        end
+
         def on_def(node)
           check_brace_layout(node.arguments)
         end

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

@@ -65,6 +65,7 @@ module RuboCop
 
           check_line_breaks(node, node.arguments, ignore_last: ignore_last_element?)
         end
+        alias on_defs on_def
 
         private
 

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

@@ -10,6 +10,8 @@ module RuboCop
       # condition, an explicit `return` statement, etc. In other contexts, the second operand should
       # be indented regardless of enforced style.
       #
+      # In both styles, operators should be aligned when an assignment begins on the next line.
+      #
       # @example EnforcedStyle: aligned (default)
       #   # bad
       #   if a +
@@ -100,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)
@@ -118,7 +122,7 @@ module RuboCop
         end
 
         def right_hand_side(send_node)
-          send_node.first_argument.source_range
+          send_node.first_argument&.source_range
         end
       end
     end

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.