rubocop 1.71.1 → 1.91.0

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Looks for uses of `any?`, `all?`, `none?`, or `one?` with a block
+      # containing only an `is_a?`, `kind_of?`, or `instance_of?` check, and
+      # suggests using the predicate method with the class argument directly.
+      #
+      # @safety
+      #   This cop is unsafe because `instance_of?` checks for an exact class
+      #   match, while the pattern argument uses `===` which also matches
+      #   subclasses. For `is_a?` and `kind_of?`, the behavior is equivalent.
+      #
+      # @example
+      #   # bad
+      #   array.any? { |x| x.is_a?(Integer) }
+      #   array.all? { |x| x.kind_of?(String) }
+      #   array.none? { |x| x.is_a?(Float) }
+      #   array.one? { |x| x.instance_of?(Symbol) }
+      #
+      #   # good
+      #   array.any?(Integer)
+      #   array.all?(String)
+      #   array.none?(Float)
+      #   array.one?(Symbol)
+      class PredicateWithKind < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Prefer `%<replacement>s` to `%<original>s` with a kind check.'
+        RESTRICT_ON_SEND = %i[any? all? none? one?].freeze
+        KIND_METHODS = %i[is_a? kind_of? instance_of?].to_set.freeze
+
+        # @!method kind_check?(node)
+        def_node_matcher :kind_check?, <<~PATTERN
+          {
+            (block call (args (arg $_)) $(send (lvar _) %KIND_METHODS _))
+            (numblock call $1 $(send (lvar _) %KIND_METHODS _))
+            (itblock call $_ $(send (lvar _) %KIND_METHODS _))
+          }
+        PATTERN
+
+        # @!method kind_call?(node, name)
+        def_node_matcher :kind_call?, <<~PATTERN
+          (send (lvar %1) %KIND_METHODS _)
+        PATTERN
+
+        def on_send(node)
+          return unless (block_node = node.block_node)
+          return if block_node.body&.begin_type?
+          return unless (kind_check_node = extract_send_node(block_node))
+
+          klass = kind_check_node.first_argument
+          replacement = "#{node.method_name}(#{klass.source})"
+
+          register_offense(node, block_node, klass, replacement)
+        end
+        alias on_csend on_send
+
+        private
+
+        def extract_send_node(block_node)
+          return unless (block_arg_name, kind_check_node = kind_check?(block_node))
+
+          block_arg_name = :"_#{block_arg_name}" if block_node.numblock_type?
+          block_arg_name = :it if block_node.type?(:itblock)
+
+          kind_check_node if kind_call?(kind_check_node, block_arg_name)
+        end
+
+        def register_offense(node, block_node, klass, replacement)
+          original = "#{node.method_name} { ... }"
+          message = format(MSG, replacement: replacement, original: original)
+
+          add_offense(block_node, message: message) do |corrector|
+            range = range_between(node.loc.selector.begin_pos, block_node.loc.end.end_pos)
+            corrector.replace(range, "#{node.method_name}(#{klass.source})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -14,22 +14,22 @@ module RuboCop
       #   is a `Hash` or responds to the replacement methods.
       #
       # @example EnforcedStyle: short (default)
-      #  # bad
-      #  Hash#has_key?
-      #  Hash#has_value?
+      #   # bad
+      #   Hash#has_key?
+      #   Hash#has_value?
       #
-      #  # good
-      #  Hash#key?
-      #  Hash#value?
+      #   # good
+      #   Hash#key?
+      #   Hash#value?
       #
       # @example EnforcedStyle: verbose
-      #  # bad
-      #  Hash#key?
-      #  Hash#value?
+      #   # bad
+      #   Hash#key?
+      #   Hash#value?
       #
-      #  # good
-      #  Hash#has_key?
-      #  Hash#has_value?
+      #   # good
+      #   Hash#has_key?
+      #   Hash#has_value?
       class PreferredHashMethods < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector

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

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of Proc.new where Kernel#proc
-      # would be more appropriate.
+      # Checks for uses of `Proc.new` where `Kernel#proc`
+      # would be more appropriate. `proc` is the shorter and
+      # more idiomatic way to create procs in Ruby.
       #
       # @example
       #   # bad
@@ -30,6 +31,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
       end
     end
   end

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

@@ -3,15 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # Checks the args passed to `fail` and `raise`. For exploded
-      # style (default), it recommends passing the exception class and message
-      # to `raise`, rather than construct an instance of the error. It will
-      # still allow passing just a message, or the construction of an error
-      # with more than one argument.
+      # Checks the args passed to `fail` and `raise`.
       #
-      # The exploded style works identically, but with the addition that it
-      # will also suggest constructing error objects when the exception is
-      # passed multiple arguments.
+      # Exploded style (default) enforces passing the exception class and message
+      # arguments separately, rather than constructing an instance of the error.
+      #
+      # Compact style enforces constructing an error instance.
+      #
+      # Both styles allow passing just a message, or an error instance when there is more
+      # than one argument.
       #
       # The exploded style has an `AllowedCompactTypes` configuration
       # option that takes an `Array` of exception name Strings.
@@ -51,7 +51,7 @@ module RuboCop
         EXPLODED_MSG = 'Provide an exception class and message as arguments to `%<method>s`.'
         COMPACT_MSG = 'Provide an exception object as an argument to `%<method>s`.'
         ACCEPTABLE_ARG_TYPES = %i[
-          hash forwarded_restarg splat forwarded_restarg forwarded_args
+          hash forwarded_restarg splat forwarded_kwrestarg forwarded_args
         ].freeze
 
         RESTRICT_ON_SEND = %i[raise fail].freeze

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_array_flatten.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant calls of `Array#flatten`.
+      #
+      # `Array#join` joins nested arrays recursively, so flattening an array
+      # beforehand is redundant.
+      #
+      # @safety
+      #   Cop is unsafe because the receiver of `flatten` method might not
+      #   be an `Array`, so it's possible it won't respond to `join` method,
+      #   or the end result would be different.
+      #   Also, if the global variable `$,` is set to a value other than the default `nil`,
+      #   false positives may occur.
+      #
+      # @example
+      #   # bad
+      #   x.flatten.join
+      #   x.flatten(1).join
+      #
+      #   # good
+      #   x.join
+      #
+      class RedundantArrayFlatten < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `flatten`.'
+
+        RESTRICT_ON_SEND = %i[flatten].freeze
+
+        # @!method flatten_join?(node)
+        def_node_matcher :flatten_join?, <<~PATTERN
+          (call (call !nil? :flatten _?) :join (nil)?)
+        PATTERN
+
+        def on_send(node)
+          return unless flatten_join?(node.parent)
+
+          range = node.loc.dot.begin.join(node.source_range.end)
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -5,6 +5,9 @@ module RuboCop
     module Style
       # Checks for redundant assignment before returning.
       #
+      # When there are comments between the assignment and reference,
+      # the cop will report an offense but it will not autocorrect.
+      #
       # @example
       #   # bad
       #   def test
@@ -54,7 +57,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def check_branch(node)
           return unless node
 
@@ -69,7 +72,6 @@ module RuboCop
             check_begin_node(node)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def check_case_node(node)
           node.when_branches.each { |when_node| check_branch(when_node.body) }
@@ -99,6 +101,8 @@ module RuboCop
         def check_begin_node(node)
           if (assignment = redundant_assignment?(node))
             add_offense(assignment) do |corrector|
+              next if comments_between_assignment_and_reference?(assignment)
+
               expression = assignment.children[1]
               corrector.replace(assignment, expression.source)
               corrector.remove(assignment.right_sibling)
@@ -108,6 +112,12 @@ module RuboCop
             check_branch(last_expr)
           end
         end
+
+        def comments_between_assignment_and_reference?(assignment)
+          line_span = assignment.source_range.line..assignment.right_sibling.source_range.line
+
+          processed_source.each_comment_in_lines(line_span).any?
+        end
       end
     end
   end

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?
@@ -95,6 +118,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_kwbegin(node)
           return unless (target_node = offensive_kwbegins(node).to_a.last)
@@ -179,6 +203,8 @@ module RuboCop
         end
 
         def begin_block_has_multiline_statements?(node)
+          return false unless node.parent
+
           node.children.count >= 2
         end
 
@@ -198,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