rubocop 1.71.1 → 1.88.2

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

@@ -0,0 +1,312 @@
+# 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|
+            next if string_with_format_sequence?(value)
+
+            replacement = escape_control_chars(value.source)
+
+            add_offense(node, message: message(node, replacement)) do |corrector|
+              corrector.replace(node, replacement)
+            end
+            return
+          end
+
+          detect_unnecessary_fields(node)
+        end
+
+        private
+
+        # A single-argument `format` whose string still contains a format sequence is
+        # not redundant: `format('%s')` raises at runtime, and `format('%%')` returns
+        # `'%'`, so replacing it with the literal would change behavior.
+        def string_with_format_sequence?(node)
+          string = static_string_value(node)
+          return false unless string
+
+          RuboCop::Cop::Utils::FormatString.new(string).format_sequences.any?
+        end
+
+        def static_string_value(node)
+          if node.str_type?
+            node.value
+          elsif node.dstr_type?
+            node.children.select(&:str_type?).map(&:value).join
+          end
+        end
+
+        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?
+          return if node.first_argument.heredoc?
+
+          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)
+
+          format_arguments = argument_values(arguments)
+          begin
+            formatted_string = format(string, *format_arguments)
+          rescue ArgumentError
+            return
+          end
+          replacement = quote(formatted_string, node)
+
+          add_offense(node, message: message(node, replacement)) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        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?
+            next if unknown_variable_width?(sequence, arguments)
+
+            hash = arguments.detect(&:hash_type?)
+            next unless (argument = find_argument(sequence, arguments, hash))
+            next unless matching_argument?(sequence, argument)
+            next if (sequence.width || sequence.precision) && argument.dstr_type?
+
+            count += 1
+          end
+
+          sequences.size == count
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        # If the sequence has a variable (`*`) width, it cannot be autocorrected
+        # if the width is not given as a numeric literal argument
+        def unknown_variable_width?(sequence, arguments)
+          return false unless sequence.variable_width?
+
+          argument = arguments[sequence.variable_width_argument_number - 1]
+          !numeric?(argument)
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def find_argument(sequence, arguments, hash)
+          if hash && (sequence.annotated? || sequence.template?)
+            find_hash_value_node(hash, sequence.name.to_sym).first
+          elsif sequence.variable_width?
+            # If the specifier contains `*`, the argument for the width can be ignored.
+            arguments.delete_at(sequence.variable_width_argument_number - 1)
+            arguments.shift
+          elsif sequence.arg_number
+            arguments[sequence.arg_number.to_i - 1]
+          else
+            arguments.shift
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        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}#{escape_control_chars(string)}#{end_delimiter}"
+        end
+
+        # Escape any control characters in the string (eg. `\t` or `\n` become `\\t` or `\\n`)
+        def escape_control_chars(string)
+          string.gsub(/\p{Cc}/) { |s| s.dump[1..-2] }
+        end
+
+        def argument_values(arguments)
+          arguments.map { |argument| argument_value(argument) }
+        end
+
+        def argument_value(argument)
+          argument = argument.children.first if argument.begin_type?
+
+          # `nil` formats to an empty string (`format('%s', nil) == ''`), not the
+          # literal `'nil'` that `argument.source` would return.
+          return if argument.nil_type?
+
+          typed_argument_value(argument)
+        end
+
+        def typed_argument_value(argument)
+          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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for uses of `Object#freeze` on immutable objects.
+      # Checks for uses of `Object#freeze` on immutable objects.
       #
       # NOTE: `Regexp` and `Range` literals are frozen objects since Ruby 3.0.
       #
@@ -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_heredoc_delimiter_quotes.rb

@@ -48,8 +48,13 @@ module RuboCop
         def need_heredoc_delimiter_quotes?(node)
           heredoc_delimiter = node.source.delete(heredoc_type(node))
           return true unless heredoc_delimiter.start_with?("'", '"')
+          return true if node.loc.heredoc_end.source.strip.match?(/\W/)
 
-          node.loc.heredoc_end.source.strip.match?(/\W/) ||
+          # A double-quoted delimiter interpolates exactly like an unquoted one,
+          # so its quotes are always redundant. A single-quoted delimiter is
+          # required when the body contains interpolation or escapes that would
+          # otherwise be evaluated.
+          heredoc_delimiter.start_with?("'") &&
             node.loc.heredoc_body.source.match?(STRING_INTERPOLATION_OR_ESCAPED_CHARACTER_PATTERN)
         end
       end

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

@@ -49,9 +49,10 @@ module RuboCop
         def on_dstr(node)
           return unless single_interpolation?(node)
 
-          add_offense(node) do |corrector|
-            embedded_node = node.children.first
+          embedded_node = node.children.first
+          return if use_match_pattern?(embedded_node)
 
+          add_offense(node) do |corrector|
             if variable_interpolation?(embedded_node)
               autocorrect_variable_interpolation(corrector, embedded_node, node)
             elsif single_variable_interpolation?(embedded_node)
@@ -71,6 +72,14 @@ module RuboCop
             !embedded_in_percent_array?(node)
         end
 
+        def use_match_pattern?(node)
+          return false if target_ruby_version <= 2.7
+
+          node.children.any? do |child|
+            child.respond_to?(:match_pattern_type?) && child.match_pattern_type?
+          end
+        end
+
         def single_variable_interpolation?(node)
           return false unless node.children.one?
 
@@ -130,7 +139,7 @@ module RuboCop
         end
 
         def require_parentheses?(node)
-          node.send_type? && !node.arguments.count.zero? && !node.parenthesized_call?
+          node.send_type? && node.arguments.any? && !node.parenthesized_call?
         end
       end
     end

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

@@ -15,6 +15,9 @@ module RuboCop
       #   # bad
       #   "#{foo} bar".dup
       #
+      #   # bad
+      #   String.new("#{foo} bar")
+      #
       #   # good
       #   "#{foo} bar"
       #
@@ -25,19 +28,32 @@ module RuboCop
 
         MSG = "Don't unfreeze interpolated strings as they are already unfrozen."
 
-        RESTRICT_ON_SEND = %i[+@ dup].freeze
-
         minimum_target_ruby_version 3.0
 
-        def on_send(node)
-          return if node.arguments?
-          return unless (receiver = node.receiver)
-          return unless receiver.dstr_type?
-          return if uninterpolated_string?(receiver) || uninterpolated_heredoc?(receiver)
+        # @!method redundant_unfreeze?(node)
+        def_node_matcher :redundant_unfreeze?, <<~PATTERN
+          {
+            (send dstr_type? {:+@ :dup})
+            (send (const nil? :String) :new dstr_type?)
+          }
+        PATTERN
+
+        def on_dstr(node)
+          return if uninterpolated_string?(node) || uninterpolated_heredoc?(node)
+          return unless redundant_unfreeze?(node.parent)
+
+          add_offense(offense_range(node.parent)) do |corrector|
+            corrector.replace(node.parent, node.source)
+          end
+        end
+
+        private
 
-          add_offense(node.loc.selector) do |corrector|
-            corrector.remove(node.loc.selector)
-            corrector.remove(node.loc.dot) unless node.unary_operation?
+        def offense_range(node)
+          if node.method?(:new)
+            node.source_range.begin.join(node.loc.selector)
+          else
+            node.loc.selector
           end
         end
       end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for redundant line continuation.
+      # Checks for redundant line continuation.
       #
       # This cop marks a line continuation as redundant if removing the backslash
       # does not result in a syntax error.
@@ -82,6 +82,7 @@ module RuboCop
           tIDENTIFIER kBREAK kNEXT kRETURN kSUPER kYIELD
         ].freeze
         ARITHMETIC_OPERATOR_TOKENS = %i[tDIVIDE tDSTAR tMINUS tPERCENT tPLUS tSTAR2].freeze
+        STRING_LITERAL_BEGIN_TOKENS = %i[tSTRING_BEG tXSTRING_BEG tREGEXP_BEG tSYMBEG].freeze
 
         def on_new_investigation
           return unless processed_source.ast
@@ -105,6 +106,7 @@ module RuboCop
             string_concatenation?(range.source_line) ||
             start_with_arithmetic_operator?(range) ||
             inside_string_literal_or_method_with_argument?(range) ||
+            inside_string_literal_with_interpolation?(range) ||
             leading_dot_method_chain_with_blank_line?(range)
         end
 
@@ -132,6 +134,20 @@ module RuboCop
           end
         end
 
+        def inside_string_literal_with_interpolation?(range)
+          string_depth = 0
+          processed_source.tokens.each do |token|
+            break if token.pos.begin_pos >= range.begin_pos
+
+            if STRING_LITERAL_BEGIN_TOKENS.include?(token.type)
+              string_depth += 1
+            elsif token.type == :tSTRING_END
+              string_depth -= 1
+            end
+          end
+          string_depth.positive?
+        end
+
         def leading_dot_method_chain_with_blank_line?(range)
           return false unless range.source_line.strip.start_with?('.', '&.')
 
@@ -149,11 +165,11 @@ module RuboCop
         end
 
         def inspect_end_of_ruby_code_line_continuation
-          last_line = processed_source.lines[processed_source.ast.last_line - 1]
+          last_line_number = processed_source.ast.last_line
+          last_line = processed_source.lines[last_line_number - 1]
           return unless code_ends_with_continuation?(last_line)
 
-          last_column = last_line.length
-          line_continuation_range = range_between(last_column - 1, last_column)
+          line_continuation_range = trailing_line_continuation_range(last_line_number)
 
           add_offense(line_continuation_range) do |corrector|
             corrector.remove_trailing(line_continuation_range, 1)
@@ -166,6 +182,14 @@ module RuboCop
           last_line.end_with?(LINE_CONTINUATION)
         end
 
+        # The backslash is the last character of the line; locate it by the line's
+        # position in the buffer rather than treating the column as an absolute offset
+        # (which corrupts an earlier line in multi-line files).
+        def trailing_line_continuation_range(line_number)
+          line_range = processed_source.buffer.line_range(line_number)
+          range_between(line_range.end_pos - 1, line_range.end_pos)
+        end
+
         def inside_string_literal?(range, token)
           ALLOWED_STRING_TOKENS.include?(token.type) && token.pos.overlaps?(range)
         end
@@ -181,9 +205,7 @@ module RuboCop
           ARGUMENT_TYPES.include?(next_token.type)
         end
 
-        # rubocop:disable Metrics/AbcSize
         def argument_newline?(node)
-          node = node.to_a.last if node.assignment?
           return false if node.parenthesized_call?
 
           node = node.children.first if node.root? && node.begin_type?
@@ -196,7 +218,6 @@ module RuboCop
             node.loc.selector.line != node.first_argument.loc.line
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def find_node_for_line(last_line)
           processed_source.ast.each_node do |node|

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies places where `max_by { ... }`, `min_by { ... }`, or
+      # `minmax_by { ... }` can be replaced by `max`, `min`, or `minmax`.
+      #
+      # @example
+      #   # bad
+      #   array.max_by { |x| x }
+      #   array.min_by { |x| x }
+      #   array.minmax_by { |x| x }
+      #
+      #   # good
+      #   array.max
+      #   array.min
+      #   array.minmax
+      class RedundantMinMaxBy < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_BLOCK = 'Use `%<replacement>s` instead of `%<original>s { |%<var>s| %<var>s }`.'
+        MSG_NUMBLOCK = 'Use `%<replacement>s` instead of `%<original>s { _1 }`.'
+        MSG_ITBLOCK = 'Use `%<replacement>s` instead of `%<original>s { it }`.'
+
+        REPLACEMENTS = { max_by: 'max', min_by: 'min', minmax_by: 'minmax' }.freeze
+
+        def on_block(node)
+          redundant_minmax_by_block(node) do |send, var_name|
+            register_offense(send, node, message_block(send, var_name))
+          end
+        end
+
+        def on_numblock(node)
+          redundant_minmax_by_numblock(node) do |send|
+            register_offense(send, node, message_numblock(send))
+          end
+        end
+
+        def on_itblock(node)
+          redundant_minmax_by_itblock(node) do |send|
+            register_offense(send, node, message_itblock(send))
+          end
+        end
+
+        private
+
+        # @!method redundant_minmax_by_block(node)
+        def_node_matcher :redundant_minmax_by_block, <<~PATTERN
+          (block $(call _ {:max_by :min_by :minmax_by}) (args (arg $_x)) (lvar _x))
+        PATTERN
+
+        # @!method redundant_minmax_by_numblock(node)
+        def_node_matcher :redundant_minmax_by_numblock, <<~PATTERN
+          (numblock $(call _ {:max_by :min_by :minmax_by}) 1 (lvar :_1))
+        PATTERN
+
+        # @!method redundant_minmax_by_itblock(node)
+        def_node_matcher :redundant_minmax_by_itblock, <<~PATTERN
+          (itblock $(call _ {:max_by :min_by :minmax_by}) _ (lvar :it))
+        PATTERN
+
+        def register_offense(send, node, message)
+          range = offense_range(send, node)
+
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, REPLACEMENTS[send.method_name])
+          end
+        end
+
+        def offense_range(send, node)
+          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
+        end
+
+        def message_block(send, var_name)
+          method = send.method_name
+          format(MSG_BLOCK, replacement: REPLACEMENTS[method], original: method, var: var_name)
+        end
+
+        def message_numblock(send)
+          method = send.method_name
+          format(MSG_NUMBLOCK, replacement: REPLACEMENTS[method], original: method)
+        end
+
+        def message_itblock(send)
+          method = send.method_name
+          format(MSG_ITBLOCK, replacement: REPLACEMENTS[method], original: method)
+        end
+      end
+    end
+  end
+end