rubocop 1.79.2 → 1.88.0

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

@@ -24,9 +24,6 @@ module RuboCop
           (send `{(send _recv _msg) str array hash const #variable?} :[] ...)
         PATTERN
 
-        # @!method method_node_and_args(node)
-        def_node_matcher :method_node_and_args, '$(call _recv _msg $...)'
-
         # @!method rescue?(node)
         def_node_matcher :rescue?, '{^resbody ^^resbody}'
 
@@ -117,7 +114,7 @@ module RuboCop
         def first_arg_begins_with_hash_literal?(node)
           # Don't flag `method ({key: value})` or `method ({key: value}.method)`
           hash_literal = method_chain_begins_with_hash_literal(node.children.first)
-          if (root_method = node.each_ancestor(:send).to_a.last)
+          if (root_method = node.each_ancestor(:call).to_a.last)
             parenthesized = root_method.parenthesized_call?
           end
           hash_literal && first_argument?(node) && !parentheses?(hash_literal) && !parenthesized
@@ -142,6 +139,8 @@ module RuboCop
           node = begin_node.children.first
 
           if (message = find_offense_message(begin_node, node))
+            return offense(begin_node, message) if message == 'block body'
+
             if node.range_type? && !argument_of_parenthesized_method_call?(begin_node, node)
               begin_node = begin_node.parent
             end
@@ -158,6 +157,8 @@ module RuboCop
           return 'a literal' if node.literal? && disallowed_literal?(begin_node, node)
           return 'a variable' if node.variable?
           return 'a constant' if node.const_type?
+          return 'block body' if begin_node.parent&.any_block_type? || body_range?(begin_node, node)
+
           if node.assignment? && (begin_node.parent.nil? || begin_node.parent.begin_type?)
             return 'an assignment'
           end
@@ -205,6 +206,7 @@ module RuboCop
           return false unless node.rescue_type?
           return false unless (parent = begin_node.parent)
           return false if parent.if_type? && parent.ternary?
+          return false if parent.conditional? && parent.condition == begin_node
 
           !parent.type?(:call, :array, :pair)
         end
@@ -220,7 +222,7 @@ module RuboCop
         end
 
         def call_node?(node)
-          node.call_type? || (node.any_block_type? && !node.lambda_or_proc?)
+          node.call_type? || (node.any_block_type? && node.braces? && !node.lambda_or_proc?)
         end
 
         def check_send(begin_node, node)
@@ -228,7 +230,7 @@ module RuboCop
 
           return check_unary(begin_node, node) if node.unary_operation?
 
-          return unless method_call_with_redundant_parentheses?(node)
+          return unless method_call_with_redundant_parentheses?(begin_node, node)
           return if call_chain_starts_with_int?(begin_node, node) ||
                     do_end_block_in_method_chain?(begin_node, node)
 
@@ -239,8 +241,7 @@ module RuboCop
           return if begin_node.chained?
 
           node = node.children.first while suspect_unary?(node)
-
-          return if node.send_type? && !method_call_with_redundant_parentheses?(node)
+          return unless method_call_with_redundant_parentheses?(begin_node, node)
 
           offense(begin_node, 'a unary operation')
         end
@@ -269,6 +270,18 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def body_range?(begin_node, node)
+          return false if begin_node.chained?
+          return false unless node.range_type?
+          return false unless (parent = begin_node.parent)
+          return false unless parent.begin_type?
+
+          (node.begin.nil? && begin_node == parent.children.first) ||
+            (node.end.nil? && begin_node == parent.children.last)
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
         def disallowed_one_line_pattern_matching?(begin_node, node)
           if (parent = begin_node.parent)
             return false if parent.any_def_type? && parent.endless?
@@ -302,13 +315,19 @@ module RuboCop
           end
         end
 
-        def method_call_with_redundant_parentheses?(node)
-          return false unless node.call_type?
+        def method_call_with_redundant_parentheses?(begin_node, node)
+          return false unless node.type?(:call, :super, :yield, :defined?)
           return false if node.prefix_not?
+          return true if singular_parenthesized_parent?(begin_node)
+
+          node.arguments.empty? || parentheses?(node) || square_brackets?(node)
+        end
 
-          send_node, args = method_node_and_args(node)
+        def singular_parenthesized_parent?(begin_node)
+          return true unless (parent = begin_node.parent)
+          return false if parent.type?(:splat, :kwsplat)
 
-          args.empty? || parentheses?(send_node) || square_brackets?(send_node)
+          parent.children.one?
         end
 
         def only_begin_arg?(args)
@@ -316,28 +335,15 @@ module RuboCop
         end
 
         def first_argument?(node)
-          if first_send_argument?(node) ||
-             first_super_argument?(node) ||
-             first_yield_argument?(node)
-            return true
-          end
+          return true if first_call_argument?(node)
 
           node.each_ancestor.any? { |ancestor| first_argument?(ancestor) }
         end
 
-        # @!method first_send_argument?(node)
-        def_node_matcher :first_send_argument?, <<~PATTERN
-          ^(send _ _ equal?(%0) ...)
-        PATTERN
-
-        # @!method first_super_argument?(node)
-        def_node_matcher :first_super_argument?, <<~PATTERN
-          ^(super equal?(%0) ...)
-        PATTERN
-
-        # @!method first_yield_argument?(node)
-        def_node_matcher :first_yield_argument?, <<~PATTERN
-          ^(yield equal?(%0) ...)
+        # @!method first_call_argument?(node)
+        def_node_matcher :first_call_argument?, <<~PATTERN
+          {^(call _ _ equal?(%0) ...)
+           ^({super yield} equal?(%0) ...)}
         PATTERN
 
         def call_chain_starts_with_int?(begin_node, send_node)

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

@@ -80,8 +80,7 @@ module RuboCop
         end
 
         def string_literal?(node)
-          node.loc.respond_to?(:begin) && node.loc.respond_to?(:end) &&
-            node.loc.begin && node.loc.end
+          node.loc?(:begin) && node.loc?(:end)
         end
 
         def start_with_percent_q_variant?(string)
@@ -91,7 +90,10 @@ module RuboCop
         def acceptable_q?(node)
           src = node.source
 
-          return true if STRING_INTERPOLATION_REGEXP.match?(src)
+          # If the string contains interpolation-like syntax and would be
+          # converted to a double-quoted string (because it contains single
+          # quotes), the replacement would activate interpolation.
+          return true if STRING_INTERPOLATION_REGEXP.match?(src) && src.include?(SINGLE_QUOTE)
 
           src.scan(/\\./).any?(ESCAPED_NON_BACKSLASH)
         end

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

@@ -66,6 +66,7 @@ module RuboCop
           DETERMINISTIC_REGEX.match?(regexp_node.source)
         end
 
+        # rubocop:disable Metrics/MethodLength
         def preferred_argument(regexp_node)
           new_argument = replacement(regexp_node)
 
@@ -73,6 +74,13 @@ module RuboCop
             new_argument.gsub!("'", "\\\\'")
             new_argument.gsub!('\"', '"')
             quote = "'"
+          elsif new_argument.include?("\\'")
+            # Add a backslash before single quotes preceded by an even number of backslashes.
+            # An even number (including zero) of backslashes before a quote means the quote itself
+            # is not escaped.
+            # Otherwise an odd number means the quote is already escaped so this doesn't touch it.
+            new_argument.gsub!(/(?<!\\)((?:\\\\)*)'/) { "#{::Regexp.last_match(1)}\\'" }
+            quote = "'"
           elsif new_argument.include?('\'')
             new_argument.gsub!("'", "\\\\'")
             quote = "'"
@@ -84,6 +92,7 @@ module RuboCop
 
           "#{quote}#{new_argument}#{quote}"
         end
+        # rubocop:enable Metrics/MethodLength
 
         def replacement(regexp_node)
           regexp_content = regexp_node.content

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for the instantiation of regexp using redundant `Regexp.new` or `Regexp.compile`.
-      # Autocorrect replaces to regexp literal which is the simplest and fastest.
+      # Checks for the instantiation of a regexp using a redundant `Regexp.new` or `Regexp.compile`.
+      # Autocorrect replaces it with a regexp literal which is the simplest and fastest.
       #
       # @example
       #

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

@@ -41,6 +41,7 @@ module RuboCop
         ALLOWED_ALWAYS_ESCAPES = " \n[]^\\#".chars.freeze
         ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = '-'.chars.freeze
         ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = '.*+?{}()|$'.chars.freeze
+        INTERPOLATION_SIGILS = %w[@ $].freeze
 
         def on_regexp(node)
           each_escape(node) do |char, index, within_character_class|
@@ -64,6 +65,7 @@ module RuboCop
           # different versions of Ruby so that e.g. /\i/ != /i/
           return true if /[[:alnum:]]/.match?(char)
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
+          return true if requires_escape_to_avoid_interpolation?(node.source[index], char)
 
           if within_character_class
             ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char) &&
@@ -95,6 +97,12 @@ module RuboCop
           delimiters.include?(char)
         end
 
+        def requires_escape_to_avoid_interpolation?(char_before_escape, escaped_char)
+          # Preserve escapes after '#' that would otherwise trigger interpolation:
+          # '#@ivar', '#@@cvar', and '#$gvar'.
+          char_before_escape == '#' && INTERPOLATION_SIGILS.include?(escaped_char)
+        end
+
         def each_escape(node)
           node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
             yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for redundant `return` expressions.
+      # Checks for redundant `return` expressions. Ruby methods
+      # implicitly return the value of the last evaluated expression,
+      # so an explicit `return` at the end of a method body is unnecessary.
       #
       # @example
       #   # These bad cases should be extended to handle methods whose body is

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

@@ -59,7 +59,7 @@ module RuboCop
 
         def initialize(config = nil, options = nil)
           super
-          @allowed_send_nodes = []
+          @allowed_send_nodes = Set.new.compare_by_identity
           @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }.compare_by_identity
         end
 
@@ -187,7 +187,7 @@ module RuboCop
         def allow_self(node)
           return unless node.send_type? && node.self_receiver?
 
-          @allowed_send_nodes << node
+          @allowed_send_nodes.add(node)
         end
 
         def add_lhs_to_local_variables_scopes(rhs, lhs)

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

@@ -27,11 +27,6 @@ module RuboCop
 
         MSG = 'Remove the self-assignment branch.'
 
-        # @!method bad_method?(node)
-        def_node_matcher :bad_method?, <<~PATTERN
-          (send nil? :bad_method ...)
-        PATTERN
-
         def on_lvasgn(node)
           expression = node.expression
 

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_struct_keyword_init.rb

@@ -0,0 +1,114 @@
+# 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.left_siblings.last.is_a?(AST::Node)
+            beginning_of_range = redundant_keyword_init.parent.left_siblings.last.source_range.end
+
+            beginning_of_range.join(redundant_keyword_init.source_range.end)
+          else
+            redundant_keyword_init
+          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

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.
       #

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

@@ -142,6 +142,7 @@ module RuboCop
         # @!method strip_begin(node)
         def_node_matcher :strip_begin, '{ (begin $!begin) $!(begin) }'
 
+        # rubocop:disable Metrics/AbcSize
         def on_if(node)
           return if allowed_if_condition?(node)
 
@@ -155,9 +156,11 @@ module RuboCop
           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
+        # rubocop:enable Metrics/AbcSize
 
         def on_and(node) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
           collect_and_clauses(node).each do |(lhs, lhs_operator_range), (rhs, _rhs_operator_range)|
@@ -259,8 +262,14 @@ module RuboCop
         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?
@@ -335,8 +344,16 @@ module RuboCop
 
         def matching_call_nodes?(left, right)
           return false unless left && right.respond_to?(:call_type?)
+          return false unless left.call_type? && right.call_type?
 
-          left.call_type? && right.call_type? && left.children == right.children
+          # 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)
@@ -350,13 +367,13 @@ module RuboCop
         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?(node, 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?(node, send_node)
@@ -392,7 +409,7 @@ module RuboCop
                                                  start_method,
                                                  method_chain)
           start_method.each_ancestor do |ancestor|
-            break unless %i[send block].include?(ancestor.type)
+            break unless ancestor.type?(:call, :any_block)
             next if !ancestor.send_type? || ancestor.operator_method?
 
             corrector.insert_before(ancestor.loc.dot, '&')