rubocop 1.84.2 → 1.88.1

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

@@ -5,8 +5,10 @@ module RuboCop
     module Layout
       # Enforces empty line after guard clause.
       #
-      # This cop allows `# :nocov:` directive after guard clause because
-      # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+      # This cop allows a SimpleCov directive comment after guard clause because
+      # SimpleCov excludes code from the coverage report by wrapping it in such directives.
+      # Both the legacy `# :nocov:` comment and the newer `# simplecov:disable` /
+      # `# simplecov:enable` comments are recognized:
       #
       # [source,ruby]
       # ----
@@ -16,6 +18,13 @@ module RuboCop
       #   # :nocov:
       #   bar
       # end
+      #
+      # def foo
+      #   # simplecov:disable
+      #   return if condition
+      #   # simplecov:enable
+      #   bar
+      # end
       # ----
       #
       # Refer to SimpleCov's documentation for more details:
@@ -58,7 +67,12 @@ module RuboCop
 
         MSG = 'Add empty line after guard clause.'
         END_OF_HEREDOC_LINE = 1
-        SIMPLE_DIRECTIVE_COMMENT_PATTERN = /\A# *:nocov:\z/.freeze
+        SIMPLECOV_COMMENT_PATTERN = /\A#\s*(?::nocov:|simplecov\s*:\s*(?:disable|enable)\b)/.freeze
+
+        # @!method guard_clause_branch?(node)
+        def_node_matcher :guard_clause_branch?, <<~PATTERN
+          {(send nil? {:raise :fail} ...) return break next}
+        PATTERN
 
         def on_if(node)
           return if correct_style?(node)
@@ -97,14 +111,16 @@ module RuboCop
         end
 
         def correct_style?(node)
-          !contains_guard_clause?(node) ||
+          !node.if_branch&.guard_clause? ||
             next_line_rescue_or_ensure?(node) ||
             next_sibling_parent_empty_or_else?(node) ||
             next_sibling_empty_or_guard_clause?(node)
         end
 
         def contains_guard_clause?(node)
-          node.if_branch&.guard_clause?
+          return false unless (branch = node.if_branch)
+
+          branch.guard_clause? || guard_clause_branch?(branch)
         end
 
         def next_line_empty_or_allowed_directive_comment?(line)
@@ -206,10 +222,10 @@ module RuboCop
           parent.begin_type? && same_line?(node, node.right_sibling)
         end
 
-        # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+        # SimpleCov excludes code from the coverage report by wrapping it in directive comments:
         # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
         def simplecov_directive_comment?(comment)
-          SIMPLE_DIRECTIVE_COMMENT_PATTERN.match?(comment.text)
+          SIMPLECOV_COMMENT_PATTERN.match?(comment.text)
         end
       end
     end

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

@@ -185,7 +185,7 @@ module RuboCop
         end
 
         def empty_line_between_macros
-          cop_config.fetch('DefLikeMacros', []).map(&:to_sym)
+          @empty_line_between_macros ||= cop_config.fetch('DefLikeMacros', []).map(&:to_sym).freeze
         end
 
         def macro_candidate?(node)
@@ -274,7 +274,20 @@ module RuboCop
         end
 
         def end_loc(node)
-          node.source_range.end
+          end_location = node.source_range.end
+          trailing_heredoc_end(node, end_location) || end_location
+        end
+
+        # For an endless method whose body is a heredoc (e.g. `def a = <<~TEXT`), the
+        # node's source range ends at the heredoc opening line, before the heredoc body.
+        # Use the heredoc's closing delimiter so the def's real end is located after the
+        # heredoc and blank-line insertion does not land inside the heredoc body.
+        def trailing_heredoc_end(node, end_location)
+          heredocs = node.each_descendant(:any_str).select(&:heredoc?)
+          return if heredocs.empty?
+
+          heredoc_end = heredocs.map { |heredoc| heredoc.loc.heredoc_end }.max_by(&:end_pos)
+          heredoc_end if heredoc_end.end_pos > end_location.end_pos
         end
 
         def autocorrect_remove_lines(corrector, newline_pos, count)

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

@@ -66,6 +66,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Add an empty line after attribute accessor.'
+        RESTRICT_ON_SEND = %i[attr_reader attr_writer attr_accessor attr].freeze
 
         def on_send(node)
           return unless node.attribute_accessor?

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

@@ -7,15 +7,25 @@ module RuboCop
       # the configuration.
       #
       # @example EnforcedStyle: no_empty_lines (default)
-      #   # good
+      #   # bad
+      #   foo do |bar|
+      #
+      #     # ...
+      #
+      #   end
       #
+      #   # good
       #   foo do |bar|
       #     # ...
       #   end
       #
       # @example EnforcedStyle: empty_lines
-      #   # good
+      #   # bad
+      #   foo do |bar|
+      #     # ...
+      #   end
       #
+      #   # good
       #   foo do |bar|
       #
       #     # ...

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

@@ -7,8 +7,16 @@ module RuboCop
       # the configuration.
       #
       # @example EnforcedStyle: no_empty_lines (default)
-      #   # good
+      #   # bad
+      #   class Foo
+      #
+      #     def bar
+      #       # ...
+      #     end
+      #
+      #   end
       #
+      #   # good
       #   class Foo
       #     def bar
       #       # ...
@@ -16,8 +24,14 @@ module RuboCop
       #   end
       #
       # @example EnforcedStyle: empty_lines
-      #   # good
+      #   # bad
+      #   class Foo
+      #     def bar
+      #       # ...
+      #     end
+      #   end
       #
+      #   # good
       #   class Foo
       #
       #     def bar

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

@@ -7,8 +7,16 @@ module RuboCop
       # the configuration.
       #
       # @example EnforcedStyle: no_empty_lines (default)
-      #   # good
+      #   # bad
+      #   module Foo
+      #
+      #     def bar
+      #       # ...
+      #     end
+      #
+      #   end
       #
+      #   # good
       #   module Foo
       #     def bar
       #       # ...
@@ -16,8 +24,14 @@ module RuboCop
       #   end
       #
       # @example EnforcedStyle: empty_lines
-      #   # good
+      #   # bad
+      #   module Foo
+      #     def bar
+      #       # ...
+      #     end
+      #   end
       #
+      #   # good
       #   module Foo
       #
       #     def bar

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

@@ -19,10 +19,10 @@ module RuboCop
       #
       # This `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
       # by default. On the other hand, `Layout/BeginEndAlignment` cop aligns with
-      # `EnforcedStyleAlignWith: start_of_line` by default due to `||= begin` tends
+      # `EnforcedStyleAlignWith: start_of_line` by default because `||= begin` tends
       # to align with the start of the line. `Layout/DefEndAlignment` cop also aligns with
       # `EnforcedStyleAlignWith: start_of_line` by default.
-      # These style can be configured by each cop.
+      # These styles can be configured by each cop.
       #
       # @example EnforcedStyleAlignWith: keyword (default)
       #   # bad
@@ -123,20 +123,23 @@ module RuboCop
           AlignmentCorrector.align_end(corrector, processed_source, node, alignment_node(node))
         end
 
+        # rubocop:disable 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
           # we check if it's an if/unless/while/until.
           return unless (rhs = first_part_of_call_chain(rhs))
 
-          # If `rhs` is a `begin` node, find the first non-`begin` child.
-          rhs = rhs.child_nodes.first while rhs.begin_type?
+          # If `rhs` is a `begin` node or a logical operator,
+          # unwrap to find the leading conditional.
+          rhs = rhs.child_nodes.first while rhs&.type?(:begin, :or, :and)
 
-          return unless rhs.conditional?
+          return unless rhs&.conditional?
           return if rhs.if_type? && rhs.ternary?
 
           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/first_hash_element_indentation.rb

@@ -28,10 +28,10 @@ module RuboCop
       #   # bad
       #   hash = {
       #     key: :value
-      #   }
-      #   and_in_a_method_call({
-      #     no: :difference
-      #                        })
+      #          }
+      #   in_a_method_call({
+      #     foo: :bar
+      #   })
       #   takes_multi_pairs_hash(x: {
       #     a: 1,
       #     b: 2
@@ -42,13 +42,12 @@ module RuboCop
       #                          })
       #
       #   # good
-      #   special_inside_parentheses
       #   hash = {
       #     key: :value
       #   }
-      #   but_in_a_method_call({
-      #                          its_like: :this
-      #                        })
+      #   in_a_method_call({
+      #                      foo: :bar
+      #                    })
       #   takes_multi_pairs_hash(x: {
       #                            a: 1,
       #                            b: 2
@@ -67,17 +66,17 @@ module RuboCop
       #   # bad
       #   hash = {
       #     key: :value
-      #   }
-      #   but_in_a_method_call({
-      #                          its_like: :this
-      #                         })
+      #          }
+      #   in_a_method_call({
+      #                     foo: :bar
+      #                   })
       #
       #   # good
       #   hash = {
       #     key: :value
       #   }
-      #   and_in_a_method_call({
-      #     no: :difference
+      #   in_a_method_call({
+      #     foo: :bar
       #   })
       #
       #
@@ -135,7 +134,13 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+          line_range = if !node.is_a?(AST::Node) || node.value.first_line <= node.key.first_line
+                         node
+                       else
+                         processed_source.buffer.line_range(node.loc.line)
+                       end
+
+          AlignmentCorrector.correct(corrector, processed_source, line_range, @column_delta)
         end
 
         def brace_alignment_style

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Check that the keys, separators, and values of a multi-line hash
+      # Checks that the keys, separators, and values of a multi-line hash
       # literal are aligned according to configuration. The configuration
       # options are:
       #

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

@@ -25,6 +25,17 @@ module RuboCop
       #     end
       #   end
       #
+      # @example
+      #   # bad
+      #   value = (
+      #   foo - bar
+      #   )
+      #
+      #   # good
+      #   value = (
+      #     foo - bar
+      #   )
+      #
       # @example AllowedPatterns: ['^\s*module']
       #   # bad
       #   module A
@@ -95,6 +106,16 @@ module RuboCop
           check_indentation(node.loc.end, node.children.first)
         end
 
+        def on_begin(node)
+          # Only a parenthesized grouping expression (e.g. `(\n  foo\n)`) has
+          # explicit delimiters. Indent the body one step from the line
+          # the opening parenthesis is on, but only when the closing parenthesis is
+          # first on its line (a body on the opening line is skipped downstream).
+          return unless parentheses?(node) && begins_its_line?(node.loc.end)
+
+          check_indentation(opening_line_start(node.loc.begin), node.children.first)
+        end
+
         def on_block(node)
           end_loc = node.loc.end
 
@@ -188,6 +209,13 @@ module RuboCop
           AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
         end
 
+        # Returns a range at the first non-space column of the line the opening parenthesis is on,
+        # used as the base to indent the body from.
+        def opening_line_start(begin_loc)
+          column = begin_loc.source_line =~ /\S/
+          source_range(processed_source.buffer, begin_loc.line, column)
+        end
+
         def check_members(base, members)
           check_indentation(base, select_check_member(members.first))
 
@@ -473,8 +501,12 @@ module RuboCop
         end
 
         def block_body_indentation_base(node, end_loc)
+          return end_loc unless style == :relative_to_receiver
+
           if dot_on_new_line?(node)
             node.send_node.loc.dot
+          elsif selector_on_new_line?(node)
+            node.send_node.loc.selector
           else
             end_loc
           end
@@ -487,6 +519,14 @@ module RuboCop
           receiver = send_node.receiver
           receiver && receiver.last_line < send_node.loc.dot.line
         end
+
+        def selector_on_new_line?(node)
+          send_node = node.send_node
+          return false unless send_node.loc?(:dot) && send_node.loc?(:selector)
+
+          receiver = send_node.receiver
+          receiver && receiver.last_line < send_node.loc.selector.line
+        end
       end
     end
   end

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

@@ -406,9 +406,11 @@ module RuboCop
         end
 
         def string_delimiter(node)
-          delimiter = node.loc.begin
-          delimiter ||= node.parent.loc.begin if node.parent&.dstr_type? && node.parent.loc?(:begin)
-          delimiter = delimiter&.source
+          delimiter = if node.loc?(:begin)
+                        node.loc.begin
+                      elsif node.parent&.dstr_type? && node.parent.loc?(:begin)
+                        node.parent.loc.begin
+                      end&.source
 
           delimiter if %w[' "].include?(delimiter)
         end

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_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

@@ -128,12 +128,15 @@ module RuboCop
           if hash_pair_indented?(node, pair_ancestor, given_style)
             return check_hash_pair_indented_style(rhs, pair_ancestor)
           end
-
-          return false if !pair_ancestor && not_for_this_cop?(node)
+          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
@@ -152,7 +155,10 @@ module RuboCop
         end
 
         def check_hash_pair_indentation(node, lhs, rhs)
-          @base = find_hash_pair_alignment_base(node) || lhs.source_range
+          @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)
@@ -166,6 +172,50 @@ module RuboCop
           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?('.', '&.')
 

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,9 @@ 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?
+            next unless (parent = block_node.parent)
+
+            parent.call_type? && parent.loc.dot && block_node.single_line?
           end
         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)

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

@@ -204,10 +204,14 @@ module RuboCop
 
         def autocorrect(corrector, range, right_operand)
           range_source = range.source
+          # Match the operator exactly, not by substring, so compound assignments
+          # like `**=` and `/=` are not mistaken for `**` and `/` (which would drop
+          # the `=` and silently change the program's behavior).
+          operator = range_source.strip
 
-          if range_source.include?('**') && !space_around_exponent_operator?
+          if operator == '**' && !space_around_exponent_operator?
             corrector.replace(range, '**')
-          elsif range_source.include?('/') && !space_around_slash_operator?(right_operand)
+          elsif operator == '/' && !space_around_slash_operator?(right_operand)
             corrector.replace(range, '/')
           elsif range_source.end_with?("\n")
             corrector.replace(range, " #{range_source.strip}\n")

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Layout
       # Checks for space between the name of a receiver and a left
-      # brackets.
+      # bracket.
       #
       # @example
       #

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

@@ -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/lint/ambiguous_assignment.rb

@@ -28,7 +28,7 @@ module RuboCop
         MISTAKES = { '=-' => '-=', '=+' => '+=', '=*' => '*=', '=!' => '!=' }.freeze
 
         def on_asgn(node)
-          return unless (rhs = rhs(node))
+          return unless (rhs = node.expression)
 
           range = range_between(node.loc.operator.end_pos - 1, rhs.source_range.begin_pos + 1)
           source = range.source
@@ -38,16 +38,6 @@ module RuboCop
         end
 
         SIMPLE_ASSIGNMENT_TYPES.each { |asgn_type| alias_method :"on_#{asgn_type}", :on_asgn }
-
-        private
-
-        def rhs(node)
-          if node.casgn_type?
-            node.children[2]
-          else
-            node.children[1]
-          end
-        end
       end
     end
   end

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

@@ -7,7 +7,7 @@ module RuboCop
       # when param passed without parentheses.
       #
       # This cop can customize allowed methods with `AllowedMethods`.
-      # By default, there are no methods to allowed.
+      # By default, there are no allowed methods.
       #
       # @example
       #