rubocop 1.71.1 → 1.92.1

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

@@ -23,19 +23,20 @@ module RuboCop
       #   foo = bar unless condition
       #
       class RedundantSelfAssignmentBranch < Base
+        include RescueNode
         extend AutoCorrector
 
         MSG = 'Remove the self-assignment branch.'
 
-        # @!method bad_method?(node)
-        def_node_matcher :bad_method?, <<~PATTERN
-          (send nil? :bad_method ...)
-        PATTERN
+        STATEMENT_BODY_TYPES = %i[
+          kwbegin def defs block numblock itblock class module sclass rescue ensure
+        ].freeze
 
         def on_lvasgn(node)
           expression = node.expression
 
           return unless use_if_and_else_branch?(expression)
+          return unless statement?(node)
 
           if_branch = expression.if_branch
           else_branch = expression.else_branch
@@ -56,6 +57,28 @@ module RuboCop
           !expression.ternary? || !expression.else?
         end
 
+        def statement?(node)
+          parent = node.parent
+          return true if parent.nil? || parent.type?(*STATEMENT_BODY_TYPES)
+          return parent.loc.begin.nil? if parent.begin_type?
+          return !rescue_modifier?(parent) if parent.resbody_type?
+
+          statement_branch?(node, parent)
+        end
+
+        def statement_branch?(node, parent)
+          case parent.type
+          when :if
+            !parent.ternary? && !node.equal?(parent.condition)
+          when :when, :in_pattern, :while, :until, :for
+            node.equal?(parent.body)
+          when :case, :case_match
+            node.equal?(parent.else_branch)
+          else
+            false
+          end
+        end
+
         def inconvertible_to_modifier?(if_branch, else_branch)
           multiple_statements?(if_branch) || multiple_statements?(else_branch) ||
             (else_branch.respond_to?(:elsif?) && else_branch.elsif?)

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
@@ -123,12 +123,29 @@ module RuboCop
         end
 
         def register_offense(node, sort_node, sorter, accessor)
+          return if code_after_accessor_kept_apart?(node)
+
           message = message(node, sorter, accessor)
           add_offense(offense_range(sort_node, node), message: message) do |corrector|
             autocorrect(corrector, node, sort_node, sorter, accessor)
           end
         end
 
+        def code_after_accessor_kept_apart?(node)
+          return false if with_logical_operator?(node)
+
+          source = before_accessor_source(node)
+          return false if !source.include?("\n") || source.strip.empty?
+
+          rest = code_after_accessor(node)
+
+          !rest.empty? && !rest.match?(/\A(#|&?\.|[)\]},])/)
+        end
+
+        def code_after_accessor(node)
+          processed_source.lines[node.last_line - 1][node.source_range.last_column..].strip
+        end
+
         def offense_range(sort_node, node)
           range_between(sort_node.loc.selector.begin_pos, node.source_range.end_pos)
         end
@@ -146,12 +163,29 @@ module RuboCop
         end
 
         def autocorrect(corrector, node, sort_node, sorter, accessor)
-          # Remove accessor, e.g. `first` or `[-1]`.
-          corrector.remove(range_between(accessor_start(node), node.source_range.end_pos))
           # Replace "sort" or "sort_by" with the appropriate min/max method.
           corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
-          # Replace to avoid syntax errors when followed by a logical operator.
-          replace_with_logical_operator(corrector, node) if with_logical_operator?(node)
+          remove_accessor(corrector, node)
+        end
+
+        def remove_accessor(corrector, node)
+          if removable_line_break_before_accessor?(node)
+            corrector.remove(node.receiver.source_range.end.join(node.source_range.end))
+          else
+            corrector.remove(range_between(accessor_start(node), node.source_range.end_pos))
+
+            replace_with_logical_operator(corrector, node) if with_logical_operator?(node)
+          end
+        end
+
+        def removable_line_break_before_accessor?(node)
+          source = before_accessor_source(node)
+
+          source.include?("\n") && source.strip.empty?
+        end
+
+        def before_accessor_source(node)
+          node.receiver.source_range.end.join((node.loc.dot || node.loc.selector).begin).source
         end
 
         def replace_with_logical_operator(corrector, node)

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
@@ -99,25 +101,40 @@ module RuboCop
         end
 
         def find_previous_older_sibling(node) # rubocop:disable Metrics
-          search_node(node).left_siblings.reverse.find do |sibling|
+          oldest = nil
+          search_node(node).left_siblings.reverse_each do |sibling|
             next unless sibling.is_a?(AST::Node)
 
-            sibling = sibling_node(sibling)
-            break unless sibling&.send_type? && sibling.method?(node.method_name)
-            break unless sibling.arguments? && !sibling.receiver
-            break unless in_same_section?(sibling, node)
-            break unless node.first_argument.str_type? && sibling.first_argument.str_type?
+            required = sibling_node(sibling)
+            break unless required&.send_type? && required.method?(node.method_name)
+            break unless required.arguments? && !required.receiver
+            break unless in_same_section?(required, node)
+            break unless node.first_argument.str_type? && required.first_argument.str_type?
 
-            node.first_argument.value < sibling.first_argument.value
+            oldest = sibling if node.first_argument.value < required.first_argument.value
           end
+          oldest
+        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)
+          source = range2.source
+
+          unless source.end_with?("\n")
+            source += "\n"
+            range2 = range2.with(begin_pos: range2.begin_pos - 1)
+          end
 
           corrector.remove(range2)
-          corrector.insert_before(range1, range2.source)
+          corrector.insert_before(range1.begin, source)
         end
 
         def search_node(node)