rubocop 1.71.2 → 1.75.2

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

@@ -20,20 +20,30 @@ module RuboCop
 
         MSG = 'Remove the redundant current directory path.'
         RESTRICT_ON_SEND = %i[require_relative].freeze
-        CURRENT_DIRECTORY_PATH = './'
+        CURRENT_DIRECTORY_PREFIX = %r{./+}.freeze
+        REDUNDANT_CURRENT_DIRECTORY_PREFIX = /\A#{CURRENT_DIRECTORY_PREFIX}/.freeze
 
         def on_send(node)
           return unless (first_argument = node.first_argument)
-          return unless first_argument.str_content&.start_with?(CURRENT_DIRECTORY_PATH)
-          return unless (index = first_argument.source.index(CURRENT_DIRECTORY_PATH))
+          return unless (index = first_argument.source.index(CURRENT_DIRECTORY_PREFIX))
+          return unless (redundant_length = redundant_path_length(first_argument.str_content))
 
           begin_pos = first_argument.source_range.begin.begin_pos + index
-          range = range_between(begin_pos, begin_pos + 2)
+          end_pos = begin_pos + redundant_length
+          range = range_between(begin_pos, end_pos)
 
           add_offense(range) do |corrector|
             corrector.remove(range)
           end
         end
+
+        private
+
+        def redundant_path_length(path)
+          return unless (match = path&.match(REDUNDANT_CURRENT_DIRECTORY_PREFIX))
+
+          match[0].length
+        end
       end
     end
   end

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

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for calls to `Kernel#format` or `Kernel#sprintf` that are redundant.
+      #
+      # Calling `format` with only a single string or constant argument is redundant,
+      # as it can be replaced by the string or constant itself.
+      #
+      # Also looks for `format` calls where the arguments are literals that can be
+      # inlined into a string easily. This applies to the `%s`, `%d`, `%i`, `%u`, and
+      # `%f` format specifiers.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because string object returned by
+      #   `format` and `sprintf` are never frozen. If `format('string')` is autocorrected to
+      #   `'string'`, `FrozenError` may occur when calling a destructive method like `String#<<`.
+      #   Consider using `'string'.dup` instead of `format('string')`.
+      #   Additionally, since the necessity of `dup` cannot be determined automatically,
+      #   this autocorrection is inherently unsafe.
+      #
+      #   [source,ruby]
+      #   ----
+      #   # frozen_string_literal: true
+      #
+      #   format('template').frozen? # => false
+      #   'template'.frozen?         # => true
+      #   ----
+      #
+      # @example
+      #
+      #   # bad
+      #   format('the quick brown fox jumps over the lazy dog.')
+      #   sprintf('the quick brown fox jumps over the lazy dog.')
+      #
+      #   # good
+      #   'the quick brown fox jumps over the lazy dog.'
+      #
+      #   # bad
+      #   format(MESSAGE)
+      #   sprintf(MESSAGE)
+      #
+      #   # good
+      #   MESSAGE
+      #
+      #   # bad
+      #   format('%s %s', 'foo', 'bar')
+      #   sprintf('%s %s', 'foo', 'bar')
+      #
+      #   # good
+      #   'foo bar'
+      #
+      class RedundantFormat < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` directly instead of `%<method_name>s`.'
+
+        RESTRICT_ON_SEND = %i[format sprintf].to_set.freeze
+        ACCEPTABLE_LITERAL_TYPES = %i[str dstr sym dsym numeric boolean nil].freeze
+
+        # @!method format_without_additional_args?(node)
+        def_node_matcher :format_without_additional_args?, <<~PATTERN
+          (send {(const {nil? cbase} :Kernel) nil?} %RESTRICT_ON_SEND ${str dstr const})
+        PATTERN
+
+        # @!method rational_number?(node)
+        def_node_matcher :rational_number?, <<~PATTERN
+          {rational (send int :/ rational) (begin rational) (begin (send int :/ rational))}
+        PATTERN
+
+        # @!method complex_number?(node)
+        def_node_matcher :complex_number?, <<~PATTERN
+          {complex (send int :+ complex) (begin complex) (begin (send int :+ complex))}
+        PATTERN
+
+        # @!method find_hash_value_node(node, name)
+        def_node_search  :find_hash_value_node, <<~PATTERN
+          (pair (sym %1) $_)
+        PATTERN
+
+        # @!method splatted_arguments?(node)
+        def_node_matcher :splatted_arguments?, <<~PATTERN
+          (send _ %RESTRICT_ON_SEND <{
+            splat
+            (hash <kwsplat ...>)
+          } ...>)
+        PATTERN
+
+        def on_send(node)
+          format_without_additional_args?(node) do |value|
+            replacement = value.source
+
+            add_offense(node, message: message(node, replacement)) do |corrector|
+              corrector.replace(node, replacement)
+            end
+            return
+          end
+
+          detect_unnecessary_fields(node)
+        end
+
+        private
+
+        def message(node, prefer)
+          format(MSG, prefer: prefer, method_name: node.method_name)
+        end
+
+        def detect_unnecessary_fields(node)
+          return unless node.first_argument&.str_type?
+
+          string = node.first_argument.value
+          arguments = node.arguments[1..]
+
+          return unless string && arguments.any?
+          return if splatted_arguments?(node)
+
+          register_all_fields_literal(node, string, arguments)
+        end
+
+        def register_all_fields_literal(node, string, arguments)
+          return unless all_fields_literal?(string, arguments.dup)
+
+          formatted_string = format(string, *argument_values(arguments))
+          replacement = quote(formatted_string, node)
+
+          add_offense(node, message: message(node, replacement)) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        def all_fields_literal?(string, arguments)
+          count = 0
+          sequences = RuboCop::Cop::Utils::FormatString.new(string).format_sequences
+          return false unless sequences.any?
+
+          sequences.each do |sequence|
+            next if sequence.percent?
+
+            hash = arguments.detect(&:hash_type?)
+            next unless (argument = find_argument(sequence, arguments, hash))
+            next unless matching_argument?(sequence, argument)
+
+            count += 1
+          end
+
+          sequences.size == count
+        end
+
+        def find_argument(sequence, arguments, hash)
+          if hash && (sequence.annotated? || sequence.template?)
+            find_hash_value_node(hash, sequence.name.to_sym).first
+          elsif sequence.arg_number
+            arguments[sequence.arg_number.to_i - 1]
+          else
+            # If the specifier contains `*`, the following arguments will be used
+            # to specify the width and can be ignored.
+            (sequence.arity - 1).times { arguments.shift }
+            arguments.shift
+          end
+        end
+
+        def matching_argument?(sequence, argument)
+          # Template specifiers don't give a type, any acceptable literal type is ok.
+          return argument.type?(*ACCEPTABLE_LITERAL_TYPES) if sequence.template?
+
+          # An argument matches a specifier if it can be easily converted
+          # to that type.
+          case sequence.type
+          when 's'
+            argument.type?(*ACCEPTABLE_LITERAL_TYPES)
+          when 'd', 'i', 'u'
+            integer?(argument)
+          when 'f'
+            float?(argument)
+          else
+            false
+          end
+        end
+
+        def numeric?(argument)
+          argument.type?(:numeric, :str) ||
+            rational_number?(argument) ||
+            complex_number?(argument)
+        end
+
+        def integer?(argument)
+          numeric?(argument) && Integer(argument_value(argument), exception: false)
+        end
+
+        def float?(argument)
+          numeric?(argument) && Float(argument_value(argument), exception: false)
+        end
+
+        # Add correct quotes to the formatted string, preferring retaining the existing
+        # quotes if possible.
+        def quote(string, node)
+          str_node = node.first_argument
+          start_delimiter = str_node.loc.begin.source
+          end_delimiter = str_node.loc.end.source
+
+          # If there is any interpolation, the delimiters need to be changed potentially
+          if node.each_descendant(:dstr, :dsym).any?
+            case start_delimiter
+            when "'"
+              start_delimiter = end_delimiter = '"'
+            when /\A%q(.)/
+              start_delimiter = "%Q#{Regexp.last_match[1]}"
+            end
+          end
+
+          "#{start_delimiter}#{string}#{end_delimiter}"
+        end
+
+        def argument_values(arguments)
+          arguments.map { |argument| argument_value(argument) }
+        end
+
+        def argument_value(argument)
+          argument = argument.children.first if argument.begin_type?
+
+          if argument.dsym_type?
+            dsym_value(argument)
+          elsif argument.hash_type?
+            hash_value(argument)
+          elsif rational_number?(argument)
+            rational_value(argument)
+          elsif complex_number?(argument)
+            complex_value(argument)
+          elsif argument.respond_to?(:value)
+            argument.value
+          else
+            argument.source
+          end
+        end
+
+        def dsym_value(dsym_node)
+          dsym_node.children.first.source
+        end
+
+        def hash_value(hash_node)
+          hash_node.each_pair.with_object({}) do |pair, hash|
+            hash[pair.key.value] = argument_value(pair.value)
+          end
+        end
+
+        def rational_value(rational_node)
+          rational_node.source.to_r
+        end
+
+        def complex_value(complex_node)
+          Complex(complex_node.source)
+        end
+      end
+    end
+  end
+end

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

@@ -60,7 +60,7 @@ module RuboCop
             (begin (send !{(str _) array} {:+ :- :* :** :/ :%} {float int}))
             (begin (send _ {:== :=== :!= :<= :>= :< :>} _))
             (send _ {:count :length :size} ...)
-            (block (send _ {:count :length :size} ...) ...)
+            (any_block (send _ {:count :length :size} ...) ...)
           }
         PATTERN
       end

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

@@ -13,14 +13,16 @@ module RuboCop
       #   # good
       #   x if y.z.nil?
       #
-      class RedundantParentheses < Base
+      class RedundantParentheses < Base # rubocop:disable Metrics/ClassLength
         include Parentheses
         extend AutoCorrector
 
-        ALLOWED_NODE_TYPES = %i[and or send splat kwsplat].freeze
+        ALLOWED_NODE_TYPES = %i[or send splat kwsplat].freeze
 
         # @!method square_brackets?(node)
-        def_node_matcher :square_brackets?, '(send {(send _recv _msg) str array hash} :[] ...)'
+        def_node_matcher :square_brackets?, <<~PATTERN
+          (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 $...)'
@@ -39,6 +41,10 @@ module RuboCop
 
         private
 
+        def variable?(node)
+          node.respond_to?(:variable?) && node.variable?
+        end
+
         def parens_allowed?(node)
           empty_parentheses?(node) ||
             first_arg_begins_with_hash_literal?(node) ||
@@ -128,6 +134,8 @@ module RuboCop
           node = begin_node.children.first
 
           if (message = find_offense_message(begin_node, node))
+            begin_node = begin_node.parent if node.range_type?
+
             return offense(begin_node, message)
           end
 
@@ -137,7 +145,7 @@ module RuboCop
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def find_offense_message(begin_node, node)
           return 'a keyword' if keyword_with_redundant_parentheses?(node)
-          return 'a literal' if disallowed_literal?(begin_node, node)
+          return 'a literal' if node.literal? && disallowed_literal?(begin_node, node)
           return 'a variable' if node.variable?
           return 'a constant' if node.const_type?
           if node.assignment? && (begin_node.parent.nil? || begin_node.parent.begin_type?)
@@ -154,6 +162,7 @@ module RuboCop
             return if node.semantic_operator? && begin_node.parent
             return if node.multiline? && allow_in_multiline_conditions?
             return if ALLOWED_NODE_TYPES.include?(begin_node.parent&.type)
+            return if !node.and_type? && begin_node.parent&.and_type?
             return if begin_node.parent&.if_type? && begin_node.parent.ternary?
 
             'a logical expression'
@@ -207,7 +216,13 @@ module RuboCop
         end
 
         def disallowed_literal?(begin_node, node)
-          node.literal? && !node.range_type? && !raised_to_power_negative_numeric?(begin_node, node)
+          if node.range_type?
+            return false unless (parent = begin_node.parent)
+
+            parent.begin_type? && parent.children.one?
+          else
+            !raised_to_power_negative_numeric?(begin_node, node)
+          end
         end
 
         def raised_to_power_negative_numeric?(begin_node, node)

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

@@ -118,6 +118,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_if(node)
           # Allow conditional nodes to use `self` in the condition if that variable

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

@@ -58,7 +58,7 @@ module RuboCop
         # rubocop:disable 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]

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/rescue_modifier.rb

@@ -67,11 +67,13 @@ module RuboCop
           node.parent && parentheses?(node.parent)
         end
 
+        # rubocop:disable 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)
@@ -81,6 +83,7 @@ module RuboCop
             #{node_offset}end
           RESCUE_CLAUSE
         end
+        # rubocop:enable Metrics/AbcSize
 
         def indentation_and_offset(node, parenthesized)
           node_indentation = indentation(node)

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

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

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

@@ -59,6 +59,7 @@ module RuboCop
           {
             (block call (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
             (numblock call $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (itblock call $_ ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
           }
         PATTERN
 
@@ -137,6 +138,7 @@ module RuboCop
           return unless (block_arg_name, regexp_method_send_node = regexp_match?(block_node))
 
           block_arg_name = :"_#{block_arg_name}" if block_node.numblock_type?
+
           return unless calls_lvar?(regexp_method_send_node, block_arg_name)
 
           regexp_method_send_node
@@ -150,7 +152,8 @@ module RuboCop
           return node.child_nodes.first if node.match_with_lvasgn_type?
 
           if node.receiver.lvar_type? &&
-             (block.numblock_type? || node.receiver.source == block.first_argument.source)
+             (block.type?(:numblock, :itblock) ||
+              node.receiver.source == block.first_argument.source)
             node.first_argument
           elsif node.first_argument.lvar_type?
             node.receiver

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

@@ -56,11 +56,13 @@ module RuboCop
         end
         # rubocop:enable Metrics/AbcSize
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
         def do_line(node)
-          if node.numblock_type? || node.arguments.children.empty? || node.send_node.lambda_literal?
+          if node.type?(:numblock, :itblock) ||
+             node.arguments.children.empty? || node.send_node.lambda_literal?
             node.loc.begin
           else
             node.arguments

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

@@ -8,9 +8,9 @@ module RuboCop
       #
       # Endless methods added in Ruby 3.0 are also accepted by this cop.
       #
-      # If `Style/EndlessMethod` is enabled with `EnforcedStyle: allow_single_line` or
-      # `allow_always`, single-line methods will be autocorrected to endless
-      # methods if there is only one statement in the body.
+      # If `Style/EndlessMethod` is enabled with `EnforcedStyle: allow_single_line`, `allow_always`,
+      # `require_single_line`, or `require_always`, single-line methods will be autocorrected
+      # to endless methods if there is only one statement in the body.
       #
       # @example
       #   # bad