rubocop 1.71.1 → 1.91.0

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

@@ -26,17 +26,17 @@ module RuboCop
       #
       #   [source,ruby]
       #   ----
-      #     class MyString < String; end
-      #     strings = [MyString.new('test'), 'test']
-      #     strings.sort.last.class   #=> String
-      #     strings.max.class         #=> MyString
+      #   class MyString < String; end
+      #   strings = [MyString.new('test'), 'test']
+      #   strings.sort.last.class #=> String
+      #   strings.max.class       #=> MyString
       #   ----
       #
       #   [source,ruby]
       #   ----
-      #     words = %w(dog horse mouse)
-      #     words.sort_by { |word| word.length }.last   #=> 'mouse'
-      #     words.max_by { |word| word.length }         #=> 'horse'
+      #   words = %w(dog horse mouse)
+      #   words.sort_by { |word| word.length }.last #=> 'mouse'
+      #   words.max_by { |word| word.length }       #=> 'horse'
       #   ----
       #
       # @example

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

@@ -21,6 +21,7 @@ module RuboCop
 
         MSG_BLOCK = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'
         MSG_NUMBLOCK = 'Use `sort` instead of `sort_by { _1 }`.'
+        MSG_ITBLOCK = 'Use `sort` instead of `sort_by { it }`.'
 
         def on_block(node)
           redundant_sort_by_block(node) do |send, var_name|
@@ -36,7 +37,17 @@ module RuboCop
           redundant_sort_by_numblock(node) do |send|
             range = sort_by_range(send, node)
 
-            add_offense(range, message: format(MSG_NUMBLOCK)) do |corrector|
+            add_offense(range, message: MSG_NUMBLOCK) do |corrector|
+              corrector.replace(range, 'sort')
+            end
+          end
+        end
+
+        def on_itblock(node)
+          redundant_sort_by_itblock(node) do |send|
+            range = sort_by_range(send, node)
+
+            add_offense(range, message: MSG_ITBLOCK) do |corrector|
               corrector.replace(range, 'sort')
             end
           end
@@ -54,6 +65,11 @@ module RuboCop
           (numblock $(call _ :sort_by) 1 (lvar :_1))
         PATTERN
 
+        # @!method redundant_sort_by_itblock(node)
+        def_node_matcher :redundant_sort_by_itblock, <<~PATTERN
+          (itblock $(call _ :sort_by) _ (lvar :it))
+        PATTERN
+
         def sort_by_range(send, node)
           range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
         end

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

@@ -75,7 +75,7 @@ module RuboCop
           node.loc.to_hash.key?(:begin) && !node.loc.begin.nil?
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def allowed_escape?(node, range)
           escaped = range.source[(1..-1)]
 
@@ -95,7 +95,6 @@ module RuboCop
 
           false
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def interpolation_not_enabled?(node)
           single_quoted?(node) ||

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant `keyword_init` option for `Struct.new`.
+      #
+      # Since Ruby 3.2, `keyword_init` in `Struct.new` defaults to `nil` behavior.
+      # Therefore, this cop detects and autocorrects redundant `keyword_init: nil`
+      # and `keyword_init: true` in `Struct.new`.
+      #
+      # This cop is disabled by default because `keyword_init: true` is not purely
+      # redundant. It changes behavior in the following ways:
+      #
+      # - `Struct#keyword_init?` returns `true` instead of `nil`.
+      # - A `Struct` with `keyword_init: true` accepts a `Hash` argument and
+      #   expands it as keyword arguments, whereas without it the `Hash` is
+      #   treated as a positional argument.
+      # - `keyword_init: true` raises an `ArgumentError` for positional arguments,
+      #   enforcing keyword-only initialization.
+      #
+      # @safety
+      #   This autocorrect is unsafe because when the value of `keyword_init` changes
+      #   from `true` to `nil`, the return value of `Struct#keyword_init?` changes.
+      #
+      # @example
+      #
+      #   # bad
+      #   Struct.new(:foo, keyword_init: nil)
+      #   Struct.new(:foo, keyword_init: true)
+      #
+      #   # good
+      #   Struct.new(:foo)
+      #
+      class RedundantStructKeywordInit < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Remove the redundant `keyword_init: %<value>s`.'
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        minimum_target_ruby_version 3.2
+
+        # @!method struct_new?(node)
+        def_node_matcher :struct_new?, <<~PATTERN
+          (call (const {nil? cbase} :Struct) :new ...)
+        PATTERN
+
+        # @!method keyword_init?(node)
+        def_node_matcher :keyword_init?, <<~PATTERN
+          {#redundant_keyword_init? #keyword_init_false?}
+        PATTERN
+
+        # @!method redundant_keyword_init?(node)
+        def_node_matcher :redundant_keyword_init?, <<~PATTERN
+          (pair (sym :keyword_init) {(true) (nil)})
+        PATTERN
+
+        # @!method keyword_init_false?(node)
+        def_node_matcher :keyword_init_false?, <<~PATTERN
+          (pair (sym :keyword_init) (false))
+        PATTERN
+
+        def on_send(node)
+          return if !struct_new?(node) || node.arguments.none? || !node.last_argument.hash_type?
+
+          keyword_init_nodes = select_keyword_init_nodes(node)
+          return if keyword_init_nodes.any? { |node| keyword_init_false?(node) }
+
+          redundant_keyword_init_nodes = select_redundant_keyword_init_nodes(keyword_init_nodes)
+
+          redundant_keyword_init_nodes.each do |redundant_keyword_init|
+            register_offense(redundant_keyword_init)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def select_keyword_init_nodes(node)
+          node.last_argument.pairs.select do |pair|
+            keyword_init?(pair)
+          end
+        end
+
+        def select_redundant_keyword_init_nodes(keyword_init_nodes)
+          keyword_init_nodes.select do |keyword_init_node|
+            redundant_keyword_init?(keyword_init_node)
+          end
+        end
+
+        def register_offense(keyword_init)
+          message = format(MSG, value: keyword_init.value.source)
+
+          add_offense(keyword_init, message: message) do |corrector|
+            range = range(keyword_init)
+
+            corrector.remove(range)
+          end
+        end
+
+        def range(redundant_keyword_init)
+          if redundant_keyword_init.parent.pairs.all? { |pair| keyword_init?(pair) }
+            # The hash holds only `keyword_init` pairs, so it is emptied; anchor the
+            # removal before the hash to also drop the comma that precedes it.
+            range_emptying_hash(redundant_keyword_init)
+          else
+            # Other pairs remain, so just drop this pair and one adjacent comma.
+            range_within_hash(redundant_keyword_init)
+          end
+        end
+
+        def range_within_hash(pair)
+          if (left = pair.left_sibling)
+            left.source_range.end.join(pair.source_range.end)
+          elsif (right = pair.right_sibling)
+            pair.source_range.begin.join(right.source_range.begin)
+          else
+            pair.source_range
+          end
+        end
+
+        def range_emptying_hash(pair)
+          if (preceding = pair.parent.left_sibling).is_a?(AST::Node)
+            preceding.source_range.end.join(pair.source_range.end)
+          else
+            pair.source_range
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,8 +5,8 @@ module RuboCop
     module Style
       # Enforces using `//` or `%r` around regular expressions.
       #
-      # NOTE: The following `%r` cases using a regexp starts with a blank or `=`
-      # as a method argument allowed to prevent syntax errors.
+      # NOTE: The following `%r` cases using a regexp that starts with a blank or `=`
+      # as a method argument are allowed to prevent syntax errors.
       #
       # [source,ruby]
       # ----
@@ -98,7 +98,16 @@ module RuboCop
         MSG_USE_SLASHES = 'Use `//` around regular expression.'
         MSG_USE_PERCENT_R = 'Use `%r` around regular expression.'
 
+        PAIR_DELIMITER_PATTERNS = {
+          ['(', ')'] => /\\.|[()]/,
+          ['[', ']'] => /\\.|[\[\]]/,
+          ['{', '}'] => /\\.|[{}]/,
+          ['<', '>'] => /\\.|[<>]/
+        }.freeze
+
         def on_regexp(node)
+          return if slash_literal?(node) && percent_r_delimiters_conflict?(node)
+
           message = if slash_literal?(node)
                       MSG_USE_PERCENT_R unless allowed_slash_literal?(node)
                     else
@@ -115,6 +124,26 @@ module RuboCop
 
         private
 
+        def percent_r_delimiters_conflict?(node)
+          opening, closing = preferred_delimiters
+          return false unless (pattern = PAIR_DELIMITER_PATTERNS[[opening, closing]])
+
+          !balanced_delimiters?(node_body(node), opening, closing, pattern)
+        end
+
+        def balanced_delimiters?(text, opening, closing, pattern)
+          depth = 0
+          text.scan(pattern) do |match|
+            if match == opening
+              depth += 1
+            elsif match == closing
+              depth -= 1
+              return false if depth.negative?
+            end
+          end
+          depth.zero?
+        end
+
         def allowed_slash_literal?(node)
           (style == :slashes && !contains_disallowed_slash?(node)) || allowed_mixed_slash?(node)
         end
@@ -155,7 +184,7 @@ module RuboCop
         end
 
         def preferred_delimiters
-          config.for_cop('Style/PercentLiteralDelimiters') ['PreferredDelimiters']['%r'].chars
+          config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']['%r'].chars
         end
 
         def allowed_omit_parentheses_with_percent_r_literal?(node)

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

@@ -3,17 +3,17 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of `rescue` in its modifier form is added for following
+      # Checks for uses of `rescue` in its modifier form. It is added for the following
       # reasons:
       #
       # * The syntax of modifier form `rescue` can be misleading because it
       #   might lead us to believe that `rescue` handles the given exception
-      #   but it actually rescue all exceptions to return the given rescue
+      #   but it actually rescues all exceptions to return the given rescue
       #   block. In this case, value returned by handle_error or
       #   SomeException.
       #
       # * Modifier form `rescue` would rescue all the exceptions. It would
-      #   silently skip all exception or errors and handle the error.
+      #   silently skip all exceptions or errors and handle the error.
       #   Example: If `NoMethodError` is raised, modifier form rescue would
       #   handle the exception.
       #
@@ -67,11 +67,13 @@ module RuboCop
           node.parent && parentheses?(node.parent)
         end
 
+        # rubocop:disable-next Metrics/AbcSize
         def correct_rescue_block(corrector, node, parenthesized)
           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)

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.type?(:def, :defs) || node.lambda?
+          node.any_def_type? || node.lambda?
         end
 
         # @!method chained_send?(node)

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies places where `array.reverse.find` can be replaced by `array.rfind`.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is an `Array` or responds to the replacement method.
+      #
+      # @example
+      #   # bad
+      #   array.reverse.find { |item| item.even? }
+      #   array.reverse.detect { |item| item.even? }
+      #   array.reverse_each.find { |item| item.even? }
+      #   array.reverse_each.detect { |item| item.even? }
+      #
+      #   # good
+      #   array.rfind { |item| item.even? }
+      #
+      class ReverseFind < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `rfind` instead.'
+        RESTRICT_ON_SEND = %i[find detect].freeze
+
+        minimum_target_ruby_version 4.0
+
+        # @!method reverse_find?(node)
+        def_node_matcher :reverse_find?, <<~PATTERN
+          (call
+            (call
+              _ {:reverse :reverse_each}) {:find :detect} (block_pass sym)?)
+        PATTERN
+
+        def on_send(node)
+          return unless reverse_find?(node)
+
+          range = node.children.first.loc.selector.join(node.loc.selector)
+
+          add_offense(range) do |corrector|
+            corrector.replace(range, 'rfind')
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -37,6 +37,16 @@ module RuboCop
       #   x&.foo      # raises NoMethodError
       #   ----
       #
+      #   Additionally, when a method chain is converted, a `NoMethodError` that
+      #   the original code raised for an intermediate `nil` value is suppressed:
+      #
+      #   [source,ruby]
+      #   ----
+      #   x = Struct.new(:foo).new(nil)
+      #   x && x.foo.bar  # raises NoMethodError
+      #   x&.foo&.bar     # returns nil
+      #   ----
+      #
       # @example
       #   # bad
       #   foo.bar if foo
@@ -86,6 +96,10 @@ module RuboCop
       #   foo.baz = bar if foo
       #   foo.baz + bar if foo
       #   foo.bar > 2 if foo
+      #
+      #   foo ? foo[index] : nil    # Ignored `foo&.[](index)` due to unclear readability benefit.
+      #   foo ? foo[idx] = v : nil  # Ignored `foo&.[]=(idx, v)` due to unclear readability benefit.
+      #   foo ? foo * 42 : nil      # Ignored `foo&.*(42)` due to unclear readability benefit.
       class SafeNavigation < Base # rubocop:disable Metrics/ClassLength
         include NilMethods
         include RangeHelp
@@ -138,6 +152,7 @@ module RuboCop
         # @!method strip_begin(node)
         def_node_matcher :strip_begin, '{ (begin $!begin) $!(begin) }'
 
+        # rubocop:disable-next Metrics/AbcSize
         def on_if(node)
           return if allowed_if_condition?(node)
 
@@ -146,10 +161,12 @@ module RuboCop
 
           body = extract_if_body(node)
           method_call = receiver.parent
+          return if dotless_operator_call?(method_call) || method_call.double_colon?
 
           removal_ranges = [begin_range(node, body), end_range(node, body)]
 
           report_offense(node, method_chain, method_call, *removal_ranges) do |corrector|
+            corrector.replace(receiver, checked_variable.source) if checked_variable.csend_type?
             corrector.insert_before(method_call.loc.dot, '&') unless method_call.safe_navigation?
           end
         end
@@ -174,12 +191,19 @@ 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
 
+        private
+
         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)
@@ -193,8 +217,6 @@ module RuboCop
           end
         end
 
-        private
-
         def find_method_chain(node)
           return node unless node&.parent&.call_type?
 
@@ -227,10 +249,10 @@ 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)
+          return false if unsafe_method_used?(node, rhs, rhs_receiver.parent)
           return false if rhs.send_type? && rhs.method?(:empty?)
 
           true
@@ -248,6 +270,20 @@ module RuboCop
           end
         end
 
+        def dotless_operator_call?(method_call)
+          return true if dotless_operator_method?(method_call)
+
+          method_call = method_call.parent while method_call.parent.send_type?
+
+          dotless_operator_method?(method_call)
+        end
+
+        def dotless_operator_method?(method_call)
+          return false if method_call.loc.dot
+
+          method_call.method?(:[]) || method_call.method?(:[]=) || method_call.operator_method?
+        end
+
         def handle_comments(corrector, node, method_call)
           comments = comments(node)
           return if comments.empty?
@@ -306,11 +342,29 @@ 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?)
+          return false unless left.call_type? && right.call_type?
+
+          # Compare receiver and method name, but ignore the difference between
+          # safe navigation method call (`&.`) and dot method call (`.`).
+          left_receiver, left_method, *left_args = left.children
+          right_receiver, right_method, *right_args = right.children
+
+          left_method == right_method &&
+            matching_nodes?(left_receiver, right_receiver) &&
+            left_args == right_args
+        end
+
         def chain_length(method_chain, method)
           method.each_ancestor(:call).inject(0) do |total, ancestor|
             break total + 1 if ancestor == method_chain
@@ -319,21 +373,24 @@ module RuboCop
           end
         end
 
-        def unsafe_method_used?(method_chain, method)
-          return true if unsafe_method?(method)
+        def unsafe_method_used?(node, method_chain, method)
+          return true if unsafe_method?(node, method)
 
-          method.each_ancestor(:send).any? do |ancestor|
-            break true unless config.cop_enabled?('Lint/SafeNavigationChain')
-
-            break true if unsafe_method?(ancestor)
-            break true if nil_methods.include?(ancestor.method_name)
-            break false if ancestor == method_chain
+          method.each_ancestor(:send) do |ancestor|
+            return true unless config.cop_enabled?('Lint/SafeNavigationChain')
+            return true if unsafe_method?(node, ancestor)
+            return true if nil_methods.include?(ancestor.method_name)
+            return false if ancestor == method_chain
           end
+          false
         end
 
-        def unsafe_method?(send_node)
-          negated?(send_node) ||
-            send_node.assignment? ||
+        def unsafe_method?(node, send_node)
+          return true if negated?(send_node)
+
+          return false if node.respond_to?(:ternary?) && node.ternary?
+
+          send_node.assignment? ||
             (!send_node.dot? && !send_node.safe_navigation?)
         end
 
@@ -361,9 +418,8 @@ module RuboCop
                                                  start_method,
                                                  method_chain)
           start_method.each_ancestor do |ancestor|
-            break unless %i[send block].include?(ancestor.type)
-            next unless ancestor.send_type?
-            next if ancestor.safe_navigation?
+            break unless ancestor.type?(:call, :any_block)
+            next if !ancestor.send_type? || ancestor.operator_method?
 
             corrector.insert_before(ancestor.loc.dot, '&')
 

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

@@ -7,6 +7,10 @@ module RuboCop
       # `shuffle.last`, and `shuffle[]` and change them to use
       # `sample` instead.
       #
+      # NOTE: An offense involving a `random:` argument is registered but not autocorrected:
+      # `shuffle` and `sample` consume the given generator differently, so for a seeded generator
+      # the correction would select different elements.
+      #
       # @example
       #   # bad
       #   [1, 2, 3].shuffle.first
@@ -45,10 +49,12 @@ module RuboCop
             range = source_range(shuffle_node, node)
             message = message(shuffle_arg, method, method_args, range)
 
-            add_offense(range, message: message) do |corrector|
-              corrector.replace(
-                source_range(shuffle_node, node), correction(shuffle_arg, method, method_args)
-              )
+            if shuffle_arg.empty?
+              add_offense(range, message: message) do |corrector|
+                corrector.replace(range, correction(shuffle_arg, method, method_args))
+              end
+            else
+              add_offense(range, message: message)
             end
           end
         end
@@ -92,7 +98,7 @@ module RuboCop
           second.int_type? ? second.to_a.first : :unknown
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def range_size(range_node)
           vals = range_node.to_a
           return :unknown unless vals.all? { |val| val.nil? || val.int_type? }
@@ -107,7 +113,6 @@ module RuboCop
             (low..high).size
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def source_range(shuffle_node, node)
           shuffle_node.loc.selector.join(node.source_range.end)