rubocop 1.79.2 → 1.88.0

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

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `each_with_object`, `inject`, and `reduce` calls that build
+      # a hash from an enumerable, where `to_h` with a block could be used instead.
+      #
+      # This cop complements `Style/HashTransformKeys` and `Style/HashTransformValues`,
+      # which handle hash-to-hash transformations with destructured key-value pairs.
+      # This cop targets the case where a hash is built from individual elements
+      # (non-destructured block parameter).
+      #
+      # @safety
+      #   This cop is unsafe because it cannot guarantee that the receiver
+      #   is an `Enumerable` by static analysis, so the correction may
+      #   not be actually equivalent. Additionally, `each_with_object` returns
+      #   the hash object while `to_h` returns a new hash, which could matter
+      #   if the hash object identity is important.
+      #
+      # @example
+      #   # bad
+      #   array.each_with_object({}) { |elem, hash| hash[elem.id] = elem.name }
+      #
+      #   # bad
+      #   array.inject({}) { |hash, elem| hash[elem.id] = elem.name; hash }
+      #
+      #   # bad
+      #   array.reduce({}) { |hash, elem| hash[elem.id] = elem.name; hash }
+      #
+      #   # bad
+      #   array.each_with_object({}) { |elem, hash| hash[elem] = elem.to_s }
+      #
+      #   # good
+      #   array.to_h { |elem| [elem.id, elem.name] }
+      #
+      #   # good
+      #   array.to_h { |elem| [elem, elem.to_s] }
+      #
+      class ReduceToHash < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+        include RangeHelp
+
+        minimum_target_ruby_version 2.6
+
+        MSG = 'Use `to_h { ... }` instead of `%<method>s`.'
+        RESTRICT_ON_SEND = %i[each_with_object inject reduce].freeze
+
+        # each_with_object({}) { |elem, hash| hash[key] = value }
+        # @!method each_with_object_to_hash?(node)
+        def_node_matcher :each_with_object_to_hash?, <<~PATTERN
+          {
+            (block
+              (call _ :each_with_object (hash))
+              (args (arg _elem) (arg _hash))
+              (send (lvar _hash) :[]= $_key $_value))
+            (numblock
+              (call _ :each_with_object (hash))
+              2
+              (send (lvar :_2) :[]= $_key $_value))
+          }
+        PATTERN
+
+        # inject/reduce({}) { |hash, elem| hash[key] = value; hash }
+        # @!method inject_to_hash?(node)
+        def_node_matcher :inject_to_hash?, <<~PATTERN
+          {
+            (block
+              (call _ {:inject :reduce} (hash))
+              (args (arg _hash) (arg _elem))
+              (begin
+                (send (lvar _hash) :[]= $_key $_value)
+                (lvar _hash)))
+            (numblock
+              (call _ {:inject :reduce} (hash))
+              2
+              (begin
+                (send (lvar :_1) :[]= $_key $_value)
+                (lvar :_1)))
+          }
+        PATTERN
+
+        def on_send(node)
+          block_node = node.block_node
+          return unless block_node
+
+          check_offense(node, block_node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_offense(node, block_node)
+          key, value = if node.method?(:each_with_object)
+                         each_with_object_to_hash?(block_node)
+                       else
+                         inject_to_hash?(block_node)
+                       end
+          return unless key
+          return if accumulator_used_in_expressions?(block_node, key, value)
+          return if nested_match?(key) || nested_match?(value)
+
+          register_offense(node, block_node, key, value)
+        end
+
+        def accumulator_used_in_expressions?(block_node, key, value)
+          acc_name = accumulator_name(block_node)
+          references_variable?(key, acc_name) || references_variable?(value, acc_name)
+        end
+
+        def nested_match?(node)
+          node.each_node(:call).any? do |send_node|
+            next false unless RESTRICT_ON_SEND.include?(send_node.method_name)
+
+            inner_block = send_node.block_node
+            next false unless inner_block
+
+            if send_node.method?(:each_with_object)
+              each_with_object_to_hash?(inner_block)
+            else
+              inject_to_hash?(inner_block)
+            end
+          end
+        end
+
+        def accumulator_name(block_node)
+          index = block_node.method?(:each_with_object) ? 1 : 0
+          block_node.argument_list[index].name
+        end
+
+        def references_variable?(node, name)
+          node.each_node(:lvar).any? { |lvar| lvar.children.first == name }
+        end
+
+        def register_offense(send_node, block_node, key_expr, value_expr)
+          message = format(MSG, method: send_node.method_name)
+
+          add_offense(send_node.loc.selector, message: message) do |corrector|
+            corrector.replace(
+              replacement_range(send_node, block_node),
+              replacement(block_node, key_expr, value_expr)
+            )
+          end
+        end
+
+        def replacement(block_node, key_expr, value_expr)
+          key_source = adjusted_source(key_expr, block_node)
+          value_source = adjusted_source(value_expr, block_node)
+          body = "[#{key_source}, #{value_source}]"
+
+          if block_node.numblock_type?
+            block_node.braces? ? "to_h { #{body} }" : do_end_replacement(block_node, body)
+          else
+            named_block_replacement(block_node, body)
+          end
+        end
+
+        def named_block_replacement(block_node, body)
+          arg = element_arg_source(block_node)
+          if block_node.braces?
+            "to_h { |#{arg}| #{body} }"
+          else
+            do_end_replacement(block_node, body, arg)
+          end
+        end
+
+        def do_end_replacement(block_node, body, arg = nil)
+          args = arg ? " |#{arg}|" : ''
+          "to_h do#{args}\n#{indent(block_node)}  #{body}\n#{indent(block_node)}end"
+        end
+
+        def replacement_range(send_node, block_node)
+          range_between(send_node.loc.selector.begin_pos, block_node.source_range.end_pos)
+        end
+
+        def element_arg_source(block_node)
+          if block_node.method?(:each_with_object)
+            block_node.first_argument.source
+          else
+            block_node.arguments[1].source
+          end
+        end
+
+        def adjusted_source(expr_node, block_node)
+          source = expr_node.source
+          return source unless block_node.numblock_type?
+          return source if block_node.method?(:each_with_object)
+
+          # For inject/reduce numblocks, _2 is the element (becomes _1)
+          source.gsub('_2', '_1')
+        end
+
+        def indent(node)
+          ' ' * node.source_range.column
+        end
+      end
+    end
+  end
+end

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

@@ -37,6 +37,7 @@ module RuboCop
       #   array.sum(0)
       #   exit(true)
       #   exit!(false)
+      #   string.to_i(10)
       #   string.split(" ")
       #   "first\nsecond".split(" ")
       #   string.chomp("\n")
@@ -49,6 +50,7 @@ module RuboCop
       #   array.sum
       #   exit
       #   exit!
+      #   string.to_i
       #   string.split
       #   "first second".split
       #   string.chomp

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for the instantiation of array using redundant `Array` constructor.
-      # Autocorrect replaces to array literal which is the simplest and fastest.
+      # Checks for the instantiation of an array using a redundant `Array` constructor.
+      # Autocorrect replaces it with an array literal which is the simplest and fastest.
       #
       # @example
       #

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

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for redundant `begin` blocks.
-      #
-      # Currently it checks for code like this:
+      # Checks for redundant `begin` blocks. A `begin` block is redundant
+      # when the `rescue`/`ensure` can be handled by the enclosing method
+      # or block definition directly, avoiding unnecessary indentation.
       #
       # @example
       #
@@ -85,6 +85,29 @@ module RuboCop
         end
         alias on_defs on_def
 
+        def on_if(node)
+          return if node.modifier_form?
+
+          inspect_branches(node)
+        end
+
+        def on_case(node)
+          inspect_branches(node)
+        end
+        alias on_case_match on_case
+
+        def on_while(node)
+          return if node.modifier_form?
+
+          body = node.body
+
+          return unless body&.kwbegin_type?
+          return if body.rescue_node || body.ensure_node
+
+          register_offense(body)
+        end
+        alias on_until on_while
+
         def on_block(node)
           return if target_ruby_version < 2.5
           return if node.send_node.lambda_literal?
@@ -180,6 +203,8 @@ module RuboCop
         end
 
         def begin_block_has_multiline_statements?(node)
+          return false unless node.parent
+
           node.children.count >= 2
         end
 
@@ -199,6 +224,15 @@ module RuboCop
         def valid_begin_assignment?(node)
           node.parent&.assignment? && !node.children.one?
         end
+
+        def inspect_branches(node)
+          node.branches.each do |branch|
+            next unless branch&.kwbegin_type?
+            next if branch.rescue_node || branch.ensure_node
+
+            register_offense(branch)
+          end
+        end
       end
     end
   end

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

@@ -58,7 +58,10 @@ module RuboCop
       #   # good
       #   a.nil? || a
       #
-      # @example AllowedMethods: ['nonzero?'] (default)
+      # @example AllowedMethods: ['infinite?', 'nonzero?'] (default)
+      #   # good
+      #   num.infinite? ? true : false
+      #
       #   # good
       #   num.nonzero? ? true : false
       #
@@ -200,7 +203,7 @@ module RuboCop
         end
 
         def asgn_type?(node)
-          node.type?(:lvasgn, :ivasgn, :cvasgn, :gvasgn)
+          node.type?(:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn)
         end
 
         def branches_have_method?(node)
@@ -247,7 +250,7 @@ module RuboCop
             "#{if_branch.receiver.source} #{if_branch.method_name} (#{argument_source}"
           elsif if_branch.true_type?
             condition = if_branch.parent.condition
-            return condition.source if condition.arguments.empty?
+            return condition.source if condition.arguments.empty? || condition.parenthesized?
 
             wrap_arguments_with_parens(condition)
           else

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

@@ -3,16 +3,16 @@
 module RuboCop
   module Cop
     module Style
-      # Avoid redundant `::` prefix on constant.
+      # Avoid redundant `::` prefix on a constant.
       #
-      # How Ruby searches constant is a bit complicated, and it can often be difficult to
+      # How Ruby searches constants is a bit complicated, and it can often be difficult to
       # understand from the code whether the `::` is intended or not. Where `Module.nesting`
       # is empty, there is no need to prepend `::`, so it would be nice to consistently
       # avoid such meaningless `::` prefix to avoid confusion.
       #
-      # NOTE: This cop is disabled if `Lint/ConstantResolution` cop is enabled to prevent
-      # conflicting rules. Because it respects user configurations that want to enable
-      # `Lint/ConstantResolution` cop which is disabled by default.
+      # NOTE: This cop is disabled if `Lint/ConstantResolution` cop is enabled,
+      # to prevent conflicting rules. This is because it respects user configurations
+      # that want to enable `Lint/ConstantResolution` cop which is disabled by default.
       #
       # @example
       #   # bad

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

@@ -64,7 +64,7 @@ module RuboCop
         def redundant_each_method(node)
           return if node.last_argument&.block_pass_type?
 
-          if node.method?(:each) && !node.parent&.block_type?
+          if node.method?(:each) && !node.parent&.any_block_type?
             ancestor_node = node.each_ancestor(:call).detect do |ancestor|
               ancestor.receiver == node &&
                 (RESTRICT_ON_SEND.include?(ancestor.method_name) || ancestor.method?(:reverse_each))
@@ -74,8 +74,8 @@ module RuboCop
           end
 
           return unless (prev_method = node.children.first)
-          return if !prev_method.send_type? ||
-                    prev_method.parent.block_type? || prev_method.last_argument&.block_pass_type?
+          return if !prev_method.call_type? || prev_method.parent.any_block_type? ||
+                    prev_method.last_argument&.block_pass_type?
 
           detected = prev_method.method_name.to_s.start_with?('each_') unless node.method?(:each)
 

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

@@ -51,7 +51,7 @@ module RuboCop
         end
 
         def string_message?(message)
-          message.type?(:str, :dstr, :xstr)
+          message.any_str_type?
         end
 
         def fix_compact(node)

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

@@ -52,7 +52,7 @@ module RuboCop
             ${nil? basic_literal? const_type?})
         PATTERN
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           redundant_fetch_block_candidate?(node) do |send, body|
             return if should_not_check?(send, body)
 

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

@@ -89,7 +89,7 @@ module RuboCop
 
         def on_send(node)
           format_without_additional_args?(node) do |value|
-            replacement = value.source
+            replacement = escape_control_chars(value.source)
 
             add_offense(node, message: message(node, replacement)) do |corrector|
               corrector.replace(node, replacement)
@@ -108,6 +108,7 @@ module RuboCop
 
         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..]
@@ -134,6 +135,7 @@ module RuboCop
           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
@@ -141,29 +143,44 @@ module RuboCop
 
           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
-            # 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
+        # rubocop:enable Metrics/AbcSize
 
         def matching_argument?(sequence, argument)
           # Template specifiers don't give a type, any acceptable literal type is ok.
@@ -214,7 +231,12 @@ module RuboCop
             end
           end
 
-          "#{start_delimiter}#{string}#{end_delimiter}"
+          "#{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)

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?
 

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

@@ -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?('.', '&.')
 

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