rubocop 1.79.2 → 1.87.0

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

@@ -27,67 +27,67 @@ module RuboCop
       # line as the last element of the array.
       #
       # @example EnforcedStyle: symmetrical (default)
-      #     # bad
-      #     [ :a,
-      #       :b
-      #     ]
-      #
-      #     # bad
-      #     [
-      #       :a,
-      #       :b ]
-      #
-      #     # good
-      #     [ :a,
-      #       :b ]
-      #
-      #     # good
-      #     [
-      #       :a,
-      #       :b
-      #     ]
+      #   # bad
+      #   [ :a,
+      #     :b
+      #   ]
+      #
+      #   # bad
+      #   [
+      #     :a,
+      #     :b ]
+      #
+      #   # good
+      #   [ :a,
+      #     :b ]
+      #
+      #   # good
+      #   [
+      #     :a,
+      #     :b
+      #   ]
       #
       # @example EnforcedStyle: new_line
-      #     # bad
-      #     [
-      #       :a,
-      #       :b ]
-      #
-      #     # bad
-      #     [ :a,
-      #       :b ]
-      #
-      #     # good
-      #     [ :a,
-      #       :b
-      #     ]
-      #
-      #     # good
-      #     [
-      #       :a,
-      #       :b
-      #     ]
+      #   # bad
+      #   [
+      #     :a,
+      #     :b ]
+      #
+      #   # bad
+      #   [ :a,
+      #     :b ]
+      #
+      #   # good
+      #   [ :a,
+      #     :b
+      #   ]
+      #
+      #   # good
+      #   [
+      #     :a,
+      #     :b
+      #   ]
       #
       # @example EnforcedStyle: same_line
-      #     # bad
-      #     [ :a,
-      #       :b
-      #     ]
-      #
-      #     # bad
-      #     [
-      #       :a,
-      #       :b
-      #     ]
-      #
-      #     # good
-      #     [
-      #       :a,
-      #       :b ]
-      #
-      #     # good
-      #     [ :a,
-      #       :b ]
+      #   # bad
+      #   [ :a,
+      #     :b
+      #   ]
+      #
+      #   # bad
+      #   [
+      #     :a,
+      #     :b
+      #   ]
+      #
+      #   # good
+      #   [
+      #     :a,
+      #     :b ]
+      #
+      #   # good
+      #   [ :a,
+      #     :b ]
       class MultilineArrayBraceLayout < Base
         include MultilineLiteralBraceLayout
         extend AutoCorrector

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

@@ -69,14 +69,18 @@ module RuboCop
         SAME_LINE_OFFENSE = 'Right hand side of multi-line assignment is not ' \
                             'on the same line as the assignment operator `=`.'
 
+        BLOCK_TYPES = %i[block numblock itblock].freeze
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_assignment(node, rhs)
           return if node.send_type? && node.loc.operator&.source != '='
           return unless rhs
           return unless supported_types.include?(rhs.type)
-          return if rhs.single_line?
+          return if rhs.single_line? && (!rhs.block_type? || same_line?(node, rhs.loc.begin))
 
           check_by_enforced_style(node, rhs)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def check_by_enforced_style(node, rhs)
           case style
@@ -109,7 +113,10 @@ module RuboCop
         private
 
         def supported_types
-          @supported_types ||= cop_config['SupportedTypes'].map(&:to_sym)
+          @supported_types ||= cop_config['SupportedTypes'].flat_map do |type|
+            sym = type.to_sym
+            sym == :block ? BLOCK_TYPES : sym
+          end
         end
       end
     end

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

@@ -78,6 +78,8 @@ module RuboCop
         end
 
         def line_break_necessary_in_args?(node)
+          return false unless max_line_length
+
           needed_length_for_args(node) > max_line_length
         end
 

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

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

@@ -124,7 +124,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,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,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 +269,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 +286,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 +303,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 +330,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 +339,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
 
-          node&.receiver&.source_range
+          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
+
+        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 +398,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

@@ -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)