rubocop 1.71.1 → 1.92.0

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

@@ -55,10 +55,10 @@ module RuboCop
               ...))
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_lvasgn(node)
           return unless (rhs = node.rhs)
-          return unless rhs.call_type? && method_returning_self?(rhs.method_name)
+          return unless rhs.type?(:any_block, :call) && method_returning_self?(rhs.method_name)
           return unless (receiver = rhs.receiver)
 
           receiver_type = ASSIGNMENT_TYPE_TO_RECEIVER_TYPE[node.type]
@@ -69,7 +69,6 @@ module RuboCop
             corrector.replace(node, rhs.source)
           end
         end
-        # rubocop:enable Metrics/AbcSize
         alias on_ivasgn on_lvasgn
         alias on_cvasgn on_lvasgn
         alias on_gvasgn on_lvasgn

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_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,17 @@ module RuboCop
         MSG_USE_SLASHES = 'Use `//` around regular expression.'
         MSG_USE_PERCENT_R = 'Use `%r` around regular expression.'
 
+        PAIR_DELIMITER_PATTERNS = {
+          ['(', ')'] => /\\.|[()]/,
+          ['[', ']'] => /\\.|[\[\]]/,
+          ['{', '}'] => /\\.|[{}]/,
+          ['<', '>'] => /\\.|[<>]/
+        }.freeze
+        DELIMITERS_KEEPING_ESCAPE = %w[$ * + . ? ^ | ( ) [ ] { } < >].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
@@ -110,11 +120,32 @@ module RuboCop
           add_offense(node, message: message) do |corrector|
             correct_delimiters(node, corrector)
             correct_inner_slashes(node, corrector)
+            correct_escaped_delimiters(node, corrector)
           end
         end
 
         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
@@ -145,9 +176,8 @@ module RuboCop
           cop_config['AllowInnerSlashes']
         end
 
-        def node_body(node, include_begin_nodes: false)
-          types = include_begin_nodes ? %i[str begin] : %i[str]
-          node.each_child_node(*types).map(&:source).join
+        def node_body(node)
+          node.each_child_node(:str).map(&:source).join
         end
 
         def slash_literal?(node)
@@ -155,18 +185,26 @@ 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)
           return false unless node.parent&.call_type?
           return true if node.content.start_with?(' ', '=')
+          return true if first_argument_of_command?(node) && node.content.match?(/\A\s/)
 
           enforced_style = config.for_cop('Style/MethodCallWithArgsParentheses')['EnforcedStyle']
 
           enforced_style == 'omit_parentheses'
         end
 
+        def first_argument_of_command?(node)
+          call = node.parent
+          return false unless call.first_argument.equal?(node)
+
+          !call.parenthesized? && !call.operator_method? && !call.setter_method?
+        end
+
         def correct_delimiters(node, corrector)
           replacement = calculate_replacement(node)
           corrector.replace(node.loc.begin, replacement.first)
@@ -174,32 +212,16 @@ module RuboCop
         end
 
         def correct_inner_slashes(node, corrector)
-          regexp_begin = node.loc.begin.end_pos
-
-          inner_slash_indices(node).each do |index|
-            start = regexp_begin + index
-
-            corrector.replace(
-              range_between(
-                start,
-                start + inner_slash_before_correction(node).length
-              ),
-              inner_slash_after_correction(node)
-            )
-          end
-        end
-
-        def inner_slash_indices(node)
-          text    = node_body(node, include_begin_nodes: true)
           pattern = inner_slash_before_correction(node)
-          index   = -1
-          indices = []
+          replacement = inner_slash_after_correction(node)
 
-          while (index = text.index(pattern, index + 1))
-            indices << index
-          end
+          node.each_child_node(:str) do |str_node|
+            inner_slash_indices(str_node.source, pattern).each do |index|
+              start = str_node.source_range.begin_pos + index
 
-          indices
+              corrector.replace(range_between(start, start + pattern.length), replacement)
+            end
+          end
         end
 
         def inner_slash_before_correction(node)
@@ -210,6 +232,17 @@ module RuboCop
           inner_slash_for(calculate_replacement(node).first)
         end
 
+        def inner_slash_indices(text, pattern)
+          index = -1
+          indices = []
+
+          while (index = text.index(pattern, index + 1))
+            indices << index
+          end
+
+          indices
+        end
+
         def inner_slash_for(opening_delimiter)
           if ['/', '%r/'].include?(opening_delimiter)
             '\/'
@@ -225,6 +258,51 @@ module RuboCop
             %w[/ /]
           end
         end
+
+        def correct_escaped_delimiters(node, corrector)
+          return unless (delimiter = delimiter_to_unescape(node))
+
+          node.each_child_node(:str) do |str_node|
+            text = str_node.source
+
+            escaped_delimiter_indices(text, delimiter).each do |index|
+              start = str_node.source_range.begin_pos + index
+              replacement = escaped_delimiter_replacement(node, delimiter, text[index + 2])
+
+              corrector.replace(range_between(start, start + 2), replacement)
+            end
+          end
+        end
+
+        def delimiter_to_unescape(node)
+          return if slash_literal?(node)
+
+          delimiter = node.delimiters.first
+
+          delimiter unless delimiter == '/' || DELIMITERS_KEEPING_ESCAPE.include?(delimiter)
+        end
+
+        def escaped_delimiter_indices(text, delimiter)
+          indices = []
+          index = 0
+
+          while (index = text.index('\\', index))
+            indices << index if text[index + 1] == delimiter
+            index += 2
+          end
+
+          indices
+        end
+
+        # A bare `#` before `{`, `@` or `$` would start an interpolation between slashes.
+        # `\#` still reads as a literal `#` there, except in extended mode, where `%r#a\#{b}#x`
+        # reads `#{b}` as a comment; `#\{` keeps both that comment and a `#` inside
+        # a character class.
+        def escaped_delimiter_replacement(node, delimiter, next_char)
+          return delimiter unless delimiter == '#' && next_char&.match?(/[{@$]/)
+
+          node.extended? ? '#\\' : '\\#'
+        end
       end
     end
   end

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

@@ -88,6 +88,8 @@ module RuboCop
           return unless previous_older_sibling
 
           add_offense(node, message: format(MSG, name: node.method_name)) do |corrector|
+            next unless own_lines?(previous_older_sibling) && own_lines?(search_node(node))
+
             autocorrect(corrector, node, previous_older_sibling)
           end
         end
@@ -112,6 +114,13 @@ module RuboCop
           end
         end
 
+        def own_lines?(node)
+          range = node.source_range
+          rest_of_line = range.source_buffer.source_line(range.last_line)[range.last_column..]
+
+          begins_its_line?(range) && rest_of_line.match?(/\A\s*(#.*)?\z/)
+        end
+
         def autocorrect(corrector, node, previous_older_sibling)
           range1 = range_with_comments_and_lines(previous_older_sibling)
           range2 = range_with_comments_and_lines(node.parent.if_type? ? node.parent : 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.
       #
@@ -54,6 +54,9 @@ module RuboCop
 
           rescue_node = node.parent
           add_offense(rescue_node) do |corrector|
+            # The heredoc body would be left behind when the rescue body is moved.
+            next if heredoc_end(node)
+
             parenthesized = parenthesized?(rescue_node)
 
             correct_rescue_block(corrector, rescue_node, parenthesized)
@@ -67,11 +70,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)
@@ -93,15 +98,8 @@ module RuboCop
         end
 
         def heredoc_end(node)
-          return unless node.call_type?
-
-          heredoc = node.arguments.reverse.find do |argument|
-            argument.respond_to?(:heredoc?) && argument.heredoc?
-          end
-
-          return unless heredoc
-
-          heredoc.loc.heredoc_end
+          node.each_node(:any_str).select(&:heredoc?).map { |heredoc| heredoc.loc.heredoc_end }
+              .max_by(&:end_pos)
         end
       end
     end

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
@@ -65,7 +65,7 @@ module RuboCop
           return if correct_style?(node)
 
           add_offense(node) do |corrector|
-            corrected = style == :return ? 'return' : 'return nil'
+            corrected = style == :return ? 'return' : return_nil(node)
 
             corrector.replace(node, corrected)
           end
@@ -79,11 +79,26 @@ module RuboCop
 
         def correct_style?(node)
           (style == :return && !return_nil_node?(node)) ||
-            (style == :return_nil && !return_node?(node))
+            (style == :return_nil && (!return_node?(node) || top_level_return?(node)))
+        end
+
+        def top_level_return?(node)
+          node.each_ancestor(:any_block, :any_def).none?
         end
 
         def scoped_node?(node)
-          node.type?(:def, :defs) || node.lambda?
+          node.any_def_type? || node.lambda?
+        end
+
+        def return_nil(node)
+          return 'return nil' unless (parent = node.parent)
+
+          if (parent.operator_keyword? && parent.logical_operator?) ||
+             (parent.if_type? && parent.ternary?)
+            '(return nil)'
+          else
+            'return nil'
+          end
         end
 
         # @!method chained_send?(node)

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

@@ -116,7 +116,17 @@ module RuboCop
         end
 
         def handle_return(return_node)
-          register_offense(return_node, 'return false') if return_nil?(return_node)
+          return unless return_nil?(return_node)
+
+          replacement = requires_parentheses?(return_node) ? '(return false)' : 'return false'
+          register_offense(return_node, replacement)
+        end
+
+        def requires_parentheses?(node)
+          parent = node.parent
+
+          (parent.operator_keyword? && parent.logical_operator?) ||
+            (parent.if_type? && parent.ternary?)
         end
 
         def handle_nil(nil_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