rubocop 1.67.0 → 1.75.5

data/lib/rubocop/cop/style/rescue_modifier.rb

@@ -67,21 +67,23 @@ module RuboCop
           node.parent && parentheses?(node.parent)
         end
 
+        # rubocop:disable Metrics/AbcSize
         def correct_rescue_block(corrector, node, parenthesized)
-          operation, rescue_modifier, = *node
-          *_, rescue_args = *rescue_modifier
+          operation = node.body
 
           node_indentation, node_offset = indentation_and_offset(node, parenthesized)
 
+          corrector.wrap(operation, '[', ']') if operation.array_type? && !operation.bracketed?
           corrector.remove(range_between(operation.source_range.end_pos, node.source_range.end_pos))
           corrector.insert_before(operation, "begin\n#{node_indentation}")
           corrector.insert_after(heredoc_end(operation) || operation, <<~RESCUE_CLAUSE.chop)
 
             #{node_offset}rescue
-            #{node_indentation}#{rescue_args.source}
+            #{node_indentation}#{node.resbody_branches.first.body.source}
             #{node_offset}end
           RESCUE_CLAUSE
         end
+        # rubocop:enable Metrics/AbcSize
 
         def indentation_and_offset(node, parenthesized)
           node_indentation = indentation(node)

data/lib/rubocop/cop/style/return_nil.rb

@@ -47,7 +47,7 @@ module RuboCop
 
         def on_return(node)
           # Check Lint/NonLocalExitFromIterator first before this cop
-          node.each_ancestor(:block, :def, :defs) do |n|
+          node.each_ancestor(:block, :any_def) do |n|
             break if scoped_node?(n)
 
             send_node, args_node, _body_node = *n
@@ -83,7 +83,7 @@ module RuboCop
         end
 
         def scoped_node?(node)
-          node.def_type? || node.defs_type? || node.lambda?
+          node.any_def_type? || node.lambda?
         end
 
         # @!method chained_send?(node)

data/lib/rubocop/cop/style/safe_navigation.rb

@@ -21,6 +21,11 @@ module RuboCop
       # We have limited the cop to not register an offense for method chains
       # that exceed this option's value.
       #
+      # NOTE: This cop will recognize offenses but not autocorrect code when the
+      # right hand side (RHS) of the `&&` statement is an `||` statement
+      # (eg. `foo && (foo.bar? || foo.baz?)`). It can be corrected
+      # manually by removing the `foo &&` and adding `&.` to each `foo` on the RHS.
+      #
       # @safety
       #   Autocorrection is unsafe because if a value is `false`, the resulting
       #   code will have different behavior or raise an error.
@@ -121,6 +126,9 @@ module RuboCop
           }
         PATTERN
 
+        # @!method and_with_rhs_or?(node)
+        def_node_matcher :and_with_rhs_or?, '(and _ {or (begin or)})'
+
         # @!method not_nil_check?(node)
         def_node_matcher :not_nil_check?, '(send (send $_ :nil?) :!)'
 
@@ -166,12 +174,21 @@ module RuboCop
               range_with_surrounding_space(range: lhs.source_range, side: :right),
               range_with_surrounding_space(range: lhs_operator_range, side: :right),
               offense_range: range_between(lhs.source_range.begin_pos, rhs.source_range.end_pos)
-            )
+            ) do |corrector|
+              corrector.replace(rhs_receiver, lhs_receiver.source)
+            end
+            ignore_node(node)
           end
         end
 
         def report_offense(node, rhs, rhs_receiver, *removal_ranges, offense_range: node)
           add_offense(offense_range) do |corrector|
+            next if ignored_node?(node)
+
+            # If the RHS is an `or` we cannot safely autocorrect because in order to remove
+            # the non-nil check we need to add safe-navs to all clauses where the receiver is used
+            next if and_with_rhs_or?(node)
+
             removal_ranges.each { |range| corrector.remove(range) }
             yield corrector if block_given?
 
@@ -215,7 +232,7 @@ module RuboCop
         end
 
         def offending_node?(node, lhs_receiver, rhs, rhs_receiver) # rubocop:disable Metrics/CyclomaticComplexity
-          return false if lhs_receiver != rhs_receiver || rhs_receiver.nil?
+          return false if !matching_nodes?(lhs_receiver, rhs_receiver) || rhs_receiver.nil?
           return false if use_var_only_in_unless_modifier?(node, lhs_receiver)
           return false if chain_length(rhs, rhs_receiver) > max_chain_length
           return false if unsafe_method_used?(rhs, rhs_receiver.parent)
@@ -294,13 +311,23 @@ module RuboCop
 
           receiver = method_chain.receiver
 
-          return receiver if receiver == checked_variable
+          return receiver if matching_nodes?(receiver, checked_variable)
 
           find_matching_receiver_invocation(receiver, checked_variable)
         end
 
+        def matching_nodes?(left, right)
+          left == right || matching_call_nodes?(left, right)
+        end
+
+        def matching_call_nodes?(left, right)
+          return false unless left && right.respond_to?(:call_type?)
+
+          left.call_type? && right.call_type? && left.children == right.children
+        end
+
         def chain_length(method_chain, method)
-          method.each_ancestor(:send).inject(0) do |total, ancestor|
+          method.each_ancestor(:call).inject(0) do |total, ancestor|
             break total + 1 if ancestor == method_chain
 
             total + 1
@@ -311,7 +338,7 @@ module RuboCop
           return true if unsafe_method?(method)
 
           method.each_ancestor(:send).any? do |ancestor|
-            break true unless config.for_cop('Lint/SafeNavigationChain')['Enabled']
+            break true unless config.cop_enabled?('Lint/SafeNavigationChain')
 
             break true if unsafe_method?(ancestor)
             break true if nil_methods.include?(ancestor.method_name)

data/lib/rubocop/cop/style/safe_navigation_chain_length.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces safe navigation chains length to not exceed the configured maximum.
+      # The longer the chain is, the harder it becomes to track what on it could be
+      # returning `nil`.
+      #
+      # There is a potential interplay with `Style/SafeNavigation` - if both are enabled
+      # and their settings are "incompatible", one of the cops will complain about what
+      # the other proposes.
+      #
+      # E.g. if `Style/SafeNavigation` is configured with `MaxChainLength: 2` (default)
+      # and this cop is configured with `Max: 1`, then for `foo.bar.baz if foo` the former
+      # will suggest `foo&.bar&.baz`, which is an offense for the latter.
+      #
+      # @example Max: 2 (default)
+      #   # bad
+      #   user&.address&.zip&.upcase
+      #
+      #   # good
+      #   user&.address&.zip
+      #   user.address.zip if user
+      #
+      class SafeNavigationChainLength < Base
+        MSG = 'Avoid safe navigation chains longer than %<max>d calls.'
+
+        def on_csend(node)
+          safe_navigation_chains = safe_navigation_chains(node)
+          return if safe_navigation_chains.size < max
+
+          add_offense(safe_navigation_chains.last, message: format(MSG, max: max))
+        end
+
+        private
+
+        def safe_navigation_chains(node)
+          node.each_ancestor.with_object([]) do |parent, chains|
+            break chains unless parent.csend_type?
+
+            chains << parent
+          end
+        end
+
+        def max
+          cop_config['Max'] || 2
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/select_by_regexp.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Looks for places where an subset of an Enumerable (array,
+      # Looks for places where a subset of an Enumerable (array,
       # range, set, etc.; see note below) is calculated based on a `Regexp`
       # match, and suggests `grep` or `grep_v` instead.
       #
@@ -59,6 +59,7 @@ module RuboCop
           {
             (block call (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
             (numblock call $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (itblock call $_ ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
           }
         PATTERN
 
@@ -137,6 +138,7 @@ module RuboCop
           return unless (block_arg_name, regexp_method_send_node = regexp_match?(block_node))
 
           block_arg_name = :"_#{block_arg_name}" if block_node.numblock_type?
+
           return unless calls_lvar?(regexp_method_send_node, block_arg_name)
 
           regexp_method_send_node
@@ -150,7 +152,8 @@ module RuboCop
           return node.child_nodes.first if node.match_with_lvasgn_type?
 
           if node.receiver.lvar_type? &&
-             (block.numblock_type? || node.receiver.source == block.first_argument.source)
+             (block.type?(:numblock, :itblock) ||
+              node.receiver.source == block.first_argument.source)
             node.first_argument
           elsif node.first_argument.lvar_type?
             node.receiver

data/lib/rubocop/cop/style/self_assignment.rb

@@ -37,33 +37,29 @@ module RuboCop
         private
 
         def check(node, var_type)
-          var_name, rhs = *node
-          return unless rhs
+          return unless (rhs = node.expression)
 
-          if rhs.send_type?
-            check_send_node(node, rhs, var_name, var_type)
+          if rhs.send_type? && rhs.arguments.one?
+            check_send_node(node, rhs, node.name, var_type)
           elsif rhs.operator_keyword?
-            check_boolean_node(node, rhs, var_name, var_type)
+            check_boolean_node(node, rhs, node.name, var_type)
           end
         end
 
         def check_send_node(node, rhs, var_name, var_type)
-          receiver, method_name, *_args = *rhs
-          return unless OPS.include?(method_name)
+          return unless OPS.include?(rhs.method_name)
 
           target_node = s(var_type, var_name)
-          return unless receiver == target_node
+          return unless rhs.receiver == target_node
 
-          add_offense(node, message: format(MSG, method: method_name)) do |corrector|
+          add_offense(node, message: format(MSG, method: rhs.method_name)) do |corrector|
             autocorrect(corrector, node)
           end
         end
 
         def check_boolean_node(node, rhs, var_name, var_type)
-          first_operand, _second_operand = *rhs
-
           target_node = s(var_type, var_name)
-          return unless first_operand == target_node
+          return unless rhs.lhs == target_node
 
           operator = rhs.loc.operator.source
           add_offense(node, message: format(MSG, method: operator)) do |corrector|
@@ -72,7 +68,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          _var_name, rhs = *node
+          rhs = node.expression
 
           if rhs.send_type?
             autocorrect_send_node(corrector, node, rhs)
@@ -82,13 +78,11 @@ module RuboCop
         end
 
         def autocorrect_send_node(corrector, node, rhs)
-          _receiver, method_name, args = *rhs
-          apply_autocorrect(corrector, node, rhs, method_name.to_s, args)
+          apply_autocorrect(corrector, node, rhs, rhs.method_name, rhs.first_argument)
         end
 
         def autocorrect_boolean_node(corrector, node, rhs)
-          _first_operand, second_operand = *rhs
-          apply_autocorrect(corrector, node, rhs, rhs.loc.operator.source, second_operand)
+          apply_autocorrect(corrector, node, rhs, rhs.loc.operator.source, rhs.rhs)
         end
 
         def apply_autocorrect(corrector, node, rhs, operator, new_rhs)

data/lib/rubocop/cop/style/semicolon.rb

@@ -164,7 +164,7 @@ module RuboCop
 
           ast = processed_source.ast
           @range_nodes = ast.range_type? ? [ast] : []
-          @range_nodes.concat(ast.each_descendant(:irange, :erange).to_a)
+          @range_nodes.concat(ast.each_descendant(:range).to_a)
         end
       end
     end

data/lib/rubocop/cop/style/send_with_literal_method_name.rb

@@ -68,7 +68,7 @@ module RuboCop
         def on_send(node)
           return if allow_send? && !node.method?(:public_send)
           return unless (first_argument = node.first_argument)
-          return unless STATIC_METHOD_NAME_NODE_TYPES.include?(first_argument.type)
+          return unless first_argument.type?(*STATIC_METHOD_NAME_NODE_TYPES)
 
           offense_range = offense_range(node)
           method_name = first_argument.value
@@ -83,6 +83,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private

data/lib/rubocop/cop/style/signal_exception.rb

@@ -122,10 +122,9 @@ module RuboCop
         def on_rescue(node)
           return unless style == :semantic
 
-          begin_node, *rescue_nodes, _else_node = *node
-          check_scope(:raise, begin_node)
+          check_scope(:raise, node.body)
 
-          rescue_nodes.each do |rescue_node|
+          node.resbody_branches.each do |rescue_node|
             check_scope(:fail, rescue_node)
             allow(:raise, rescue_node)
           end

data/lib/rubocop/cop/style/single_argument_dig.rb

@@ -33,22 +33,19 @@ module RuboCop
       #
       class SingleArgumentDig < Base
         extend AutoCorrector
+        include DigHelp
 
         MSG = 'Use `%<receiver>s[%<argument>s]` instead of `%<original>s`.'
         RESTRICT_ON_SEND = %i[dig].freeze
         IGNORED_ARGUMENT_TYPES = %i[block_pass forwarded_restarg forwarded_args hash].freeze
 
-        # @!method single_argument_dig?(node)
-        def_node_matcher :single_argument_dig?, <<~PATTERN
-          (send _ :dig $!splat)
-        PATTERN
-
         def on_send(node)
           return unless node.receiver
 
           expression = single_argument_dig?(node)
           return unless expression
           return if IGNORED_ARGUMENT_TYPES.include?(expression.type)
+          return if ignore_dig_chain?(node)
 
           receiver = node.receiver.source
           argument = expression.source
@@ -63,6 +60,13 @@ module RuboCop
 
           ignore_node(node)
         end
+
+        private
+
+        def ignore_dig_chain?(node)
+          dig_chain_enabled? &&
+            (dig?(node.receiver) || dig?(node.parent))
+        end
       end
     end
   end

data/lib/rubocop/cop/style/single_line_block_params.rb

@@ -10,7 +10,7 @@ module RuboCop
       # parameters.
       #
       # Configuration option: Methods
-      # Should be set to use this cop. Array of hashes, where each key is the
+      # Should be set to use this cop. `Array` of hashes, where each key is the
       # method name and value - array of argument names.
       #
       # @example Methods: [{reduce: %w[a b]}]

data/lib/rubocop/cop/style/single_line_do_end_block.rb

@@ -6,8 +6,13 @@ module RuboCop
       # Checks for single-line `do`...`end` block.
       #
       # In practice a single line `do`...`end` is autocorrected when `EnforcedStyle: semantic`
-      # in `Style/BlockDelimiters`. The autocorrection maintains the `do` ... `end` syntax to
-      # preserve semantics and does not change it to `{`...`}` block.
+      # is configured for `Style/BlockDelimiters`. The autocorrection maintains the
+      # `do` ... `end` syntax to preserve semantics and does not change it to `{`...`}` block.
+      #
+      # NOTE: If `InspectBlocks` is set to `true` for `Layout/RedundantLineBreak`, blocks will
+      # be autocorrected to be on a single line if possible. This cop respects that configuration
+      # by not registering an offense if it would subsequently cause a
+      # `Layout/RedundantLineBreak` offense.
       #
       # @example
       #
@@ -27,12 +32,14 @@ module RuboCop
       #
       class SingleLineDoEndBlock < Base
         extend AutoCorrector
+        include CheckSingleLineSuitability
 
         MSG = 'Prefer multiline `do`...`end` block.'
 
         # rubocop:disable Metrics/AbcSize
         def on_block(node)
           return if !node.single_line? || node.braces?
+          return if single_line_blocks_preferred? && suitable_as_single_line?(node)
 
           add_offense(node) do |corrector|
             corrector.insert_after(do_line(node), "\n")
@@ -49,18 +56,22 @@ module RuboCop
         end
         # rubocop:enable Metrics/AbcSize
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
         def do_line(node)
-          if node.numblock_type? || node.arguments.children.empty? || node.send_node.lambda_literal?
+          if node.type?(:numblock, :itblock) ||
+             node.arguments.children.empty? || node.send_node.lambda_literal?
             node.loc.begin
           else
             node.arguments
           end
         end
 
-        def x(corrector, node); end
+        def single_line_blocks_preferred?
+          @config.for_enabled_cop('Layout/RedundantLineBreak')['InspectBlocks']
+        end
       end
     end
   end

data/lib/rubocop/cop/style/single_line_methods.rb

@@ -8,9 +8,9 @@ module RuboCop
       #
       # Endless methods added in Ruby 3.0 are also accepted by this cop.
       #
-      # If `Style/EndlessMethod` is enabled with `EnforcedStyle: allow_single_line` or
-      # `allow_always`, single-line methods will be autocorrected to endless
-      # methods if there is only one statement in the body.
+      # If `Style/EndlessMethod` is enabled with `EnforcedStyle: allow_single_line`, `allow_always`,
+      # `require_single_line`, or `require_always`, single-line methods will be autocorrected
+      # to endless methods if there is only one statement in the body.
       #
       # @example
       #   # bad
@@ -68,7 +68,7 @@ module RuboCop
           return false if body_node.parent.assignment_method? ||
                           NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)
 
-          !(body_node.begin_type? || body_node.kwbegin_type?)
+          !body_node.type?(:begin, :kwbegin)
         end
 
         def correct_to_multiline(corrector, node)
@@ -134,10 +134,9 @@ module RuboCop
         end
 
         def disallow_endless_method_style?
-          endless_method_config = config.for_cop('Style/EndlessMethod')
-          return true unless endless_method_config['Enabled']
+          return true unless config.cop_enabled?('Style/EndlessMethod')
 
-          endless_method_config['EnforcedStyle'] == 'disallow'
+          config.for_cop('Style/EndlessMethod')['EnforcedStyle'] == 'disallow'
         end
       end
     end

data/lib/rubocop/cop/style/slicing_with_range.rb

@@ -78,38 +78,67 @@ module RuboCop
           return unless node.arguments.one?
 
           range_node = node.first_argument
-          selector = node.loc.selector
-          unless (message, removal_range = offense_message_with_removal_range(range_node, selector))
-            return
-          end
+          offense_range = find_offense_range(node)
+          return unless (message, removal_range =
+                           offense_message_with_removal_range(node, range_node, offense_range))
+
+          # Changing the range to beginningless or endless when unparenthesized
+          # changes the semantics of the code, and thus will not be considered
+          # an offense.
+          return if removal_range != offense_range && unparenthesized_call?(node)
 
-          add_offense(selector, message: message) do |corrector|
+          add_offense(offense_range, message: message) do |corrector|
             corrector.remove(removal_range)
           end
         end
+        alias on_csend on_send
 
         private
 
-        def offense_message_with_removal_range(range_node, selector)
+        def unparenthesized_call?(node)
+          node.loc.dot && !node.parenthesized?
+        end
+
+        def find_offense_range(node)
+          if node.loc.dot
+            node.loc.dot.join(node.source_range.end)
+          else
+            node.loc.selector
+          end
+        end
+
+        def offense_message_with_removal_range(node, range_node, offense_range)
           if range_from_zero_till_minus_one?(range_node)
-            [format(MSG_USELESS_RANGE, prefer: selector.source), selector]
+            [format(MSG_USELESS_RANGE, prefer: offense_range.source), offense_range]
           elsif range_till_minus_one?(range_node)
             [
-              format(MSG, prefer: endless(range_node), current: selector.source), range_node.end
+              offense_message_for_partial_range(node, endless(range_node), offense_range),
+              range_node.end
             ]
           elsif range_from_zero?(range_node) && target_ruby_version >= 2.7
             [
-              format(MSG, prefer: beginless(range_node), current: selector.source), range_node.begin
+              offense_message_for_partial_range(node, beginless(range_node), offense_range),
+              range_node.begin
             ]
           end
         end
 
+        def offense_message_for_partial_range(node, prefer, offense_range)
+          current = node.loc.dot ? arguments_source(node) : offense_range.source
+          prefer = "[#{prefer}]" unless node.loc.dot
+          format(MSG, prefer: prefer, current: current)
+        end
+
         def endless(range_node)
-          "[#{range_node.begin.source}#{range_node.loc.operator.source}]"
+          "#{range_node.begin.source}#{range_node.loc.operator.source}"
         end
 
         def beginless(range_node)
-          "[#{range_node.loc.operator.source}#{range_node.end.source}]"
+          "#{range_node.loc.operator.source}#{range_node.end.source}"
+        end
+
+        def arguments_source(node)
+          node.first_argument.source_range.join(node.last_argument.source_range.end).source
         end
       end
     end