rubocop 1.71.1 → 1.92.1

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

@@ -0,0 +1,216 @@
+# 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 = element_source(expr_node)
+          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
+
+        def element_source(expr_node)
+          if command_call?(expr_node) || expr_node.assignment? || expr_node.rescue_type?
+            return "(#{expr_node.source})"
+          end
+          return "[#{expr_node.source}]" if expr_node.array_type? && !expr_node.bracketed?
+
+          expr_node.source
+        end
+
+        def command_call?(node)
+          node = node.send_node if node.any_block_type?
+          return false unless node.type?(:call, :super, :yield)
+
+          node.arguments? && !node.parenthesized? && !node.operator_method? && !node.setter_method?
+        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)
@@ -115,7 +139,7 @@ module RuboCop
           offense_range = node.loc.begin
 
           add_offense(offense_range) do |corrector|
-            if node.parent&.assignment?
+            if node.parent&.assignment? || node.parent&.type?(:return, :next, :break)
               replace_begin_with_statement(corrector, offense_range, node)
             else
               remove_begin(corrector, offense_range, node)
@@ -132,7 +156,7 @@ module RuboCop
           first_child = node.children.first
 
           source = first_child.source
-          source = "(#{source})" if first_child.if_type? && first_child.modifier_form?
+          source = "(#{source})" if low_precedence_statement?(first_child)
 
           corrector.replace(offense_range, source)
           corrector.remove(range_between(offense_range.end_pos, first_child.source_range.end_pos))
@@ -140,6 +164,13 @@ module RuboCop
           restore_removed_comments(corrector, offense_range, node, first_child)
         end
 
+        def low_precedence_statement?(node)
+          return node.modifier_form? if node.basic_conditional?
+          return node.prefix_not? if node.send_type?
+
+          node.operator_keyword? && node.semantic_operator?
+        end
+
         def remove_begin(corrector, offense_range, node)
           if node.parent.respond_to?(:endless?) && node.parent.endless?
             offense_range = range_with_surrounding_space(offense_range, newlines: true)
@@ -160,7 +191,8 @@ module RuboCop
         def use_modifier_form_after_multiline_begin_block?(node)
           return false unless (parent = node.parent)
 
-          node.multiline? && parent.if_type? && parent.modifier_form?
+          node.multiline? && parent.if_type? && parent.modifier_form? &&
+            !parent.condition.equal?(node)
         end
 
         def correct_modifier_form_after_multiline_begin_block(corrector, node)
@@ -179,6 +211,8 @@ module RuboCop
         end
 
         def begin_block_has_multiline_statements?(node)
+          return false unless node.parent
+
           node.children.count >= 2
         end
 
@@ -196,7 +230,26 @@ module RuboCop
         end
 
         def valid_begin_assignment?(node)
-          node.parent&.assignment? && !node.children.one?
+          node.parent&.assignment? && (!node.children.one? || too_long_when_joined?(node))
+        end
+
+        def too_long_when_joined?(node)
+          statement = node.children.first
+          max = config.for_enabled_cop('Layout/LineLength')['Max']
+          return false unless max && statement.single_line?
+
+          length = statement.source.length
+          length += 2 if low_precedence_statement?(statement)
+          node.loc.column + length > max
+        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

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

@@ -42,7 +42,31 @@ module RuboCop
       #     c
       #   end
       #
+      #   # bad
+      #   a.nil? ? true : a
+      #
+      #   # good
+      #   a.nil? || a
+      #
+      #   # bad
+      #   if a.nil?
+      #     true
+      #   else
+      #     a
+      #   end
+      #
+      #   # good
+      #   a.nil? || a
+      #
+      # @example AllowedMethods: ['infinite?', 'nonzero?'] (default)
+      #   # good
+      #   num.infinite? ? true : false
+      #
+      #   # good
+      #   num.nonzero? ? true : false
+      #
       class RedundantCondition < Base
+        include AllowedMethods
         include CommentsHelp
         include RangeHelp
         extend AutoCorrector
@@ -54,7 +78,10 @@ module RuboCop
         ].freeze
 
         def on_if(node)
-          return if node.modifier_form? || node.elsif_conditional? || !offense?(node)
+          return unless redundant_condition_offense?(node)
+          return if node.each_ancestor(:if).any? do |ancestor|
+            redundant_condition_offense?(ancestor)
+          end
 
           message = message(node)
 
@@ -65,6 +92,10 @@ module RuboCop
 
         private
 
+        def redundant_condition_offense?(node)
+          !node.modifier_form? && !node.elsif_conditional? && offense?(node)
+        end
+
         def message(node)
           if redundant_condition?(node)
             REDUNDANT_CONDITION
@@ -95,7 +126,7 @@ module RuboCop
         end
 
         def offense?(node)
-          _condition, _if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          _condition, _if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
           return false if use_if_branch?(else_branch) || use_hash_key_assignment?(else_branch)
 
           synonymous_condition_and_branch?(node) && !node.elsif? &&
@@ -119,7 +150,7 @@ module RuboCop
         end
 
         def synonymous_condition_and_branch?(node)
-          condition, if_branch, _else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          condition, if_branch, _else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
           # e.g.
           #   if var
           #     var
@@ -128,6 +159,16 @@ module RuboCop
           #   end
           return true if condition == if_branch
 
+          # e.g.
+          #   a.nil? ? true : a
+          # or
+          #   if a.nil?
+          #     true
+          #   else
+          #     a
+          #   end
+          return true if if_branch_is_true_type_and_else_is_not?(node)
+
           # e.g.
           #   if foo
           #     @value = foo
@@ -146,8 +187,19 @@ module RuboCop
             !use_hash_key_access?(if_branch)
         end
 
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def if_branch_is_true_type_and_else_is_not?(node)
+          return false unless node.ternary? || node.if?
+
+          cond = node.condition
+          return false unless cond.call_type?
+          return false if !cond.predicate_method? || allowed_method?(cond.method_name)
+
+          node.if_branch&.true_type? && node.else_branch && !node.else_branch.true_type?
+        end
+
         def branches_have_assignment?(node)
-          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
 
           return false unless if_branch && else_branch
 
@@ -157,7 +209,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)
@@ -187,20 +239,33 @@ module RuboCop
           node.type?(:kwsplat, :forwarded_kwrestarg)
         end
 
-        def if_source(if_branch, arithmetic_operation)
+        def wrap_arguments_with_parens(condition)
+          method = condition.source_range.begin.join(condition.loc.selector.end)
+          arguments = condition.first_argument.source_range.begin.join(condition.source_range.end)
+
+          "#{method.source}(#{arguments.source})"
+        end
+
+        # rubocop:disable-next Metrics/AbcSize
+        def if_source(if_branch, binary_operator)
           if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
             if_branch.source.delete_suffix(')')
-          elsif arithmetic_operation
+          elsif binary_operator
             argument_source = if_branch.first_argument.source
 
             "#{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? || condition.parenthesized?
+
+            wrap_arguments_with_parens(condition)
           else
             if_branch.source
           end
         end
 
-        def else_source(else_branch, arithmetic_operation) # rubocop:disable Metrics/AbcSize
-          if arithmetic_operation
+        def else_source(else_branch, binary_operator) # rubocop:disable Metrics/AbcSize
+          if binary_operator
             "#{else_branch.first_argument.source})"
           elsif branches_have_method?(else_branch.parent)
             else_source_if_has_method(else_branch)
@@ -236,12 +301,12 @@ module RuboCop
         end
 
         def make_ternary_form(node)
-          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
-          arithmetic_operation = use_arithmetic_operation?(if_branch)
+          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
+          binary_operator = branches_have_method?(node) && binary_operator?(if_branch)
 
           ternary_form = [
-            if_source(if_branch, arithmetic_operation),
-            else_source(else_branch, arithmetic_operation)
+            if_source(if_branch, binary_operator),
+            else_source(else_branch, binary_operator)
           ].join(' || ')
           ternary_form += ')' if branches_have_method?(node) && if_branch.parenthesized?
 
@@ -262,17 +327,27 @@ module RuboCop
 
         def require_parentheses?(node)
           (node.basic_conditional? && node.modifier_form?) ||
-            node.range_type? ||
-            node.rescue_type? ||
-            (node.respond_to?(:semantic_operator?) && node.semantic_operator?)
+            node.range_type? || node.rescue_type? ||
+            (node.respond_to?(:semantic_operator?) && node.semantic_operator?) ||
+            low_precedence_keyword?(node)
+        end
+
+        # e.g. `not foo`, `return foo`, and `yield foo`
+        def low_precedence_keyword?(node)
+          return node.prefix_not? if node.send_type?
+
+          node.type?(:return, :next, :break, :yield, :super) &&
+            node.arguments? && !node.parenthesized?
         end
 
         def require_braces?(node)
           node.hash_type? && !node.braces?
         end
 
-        def use_arithmetic_operation?(node)
-          node.respond_to?(:arithmetic_operation?) && node.arithmetic_operation?
+        # Any binary operator binds tighter than `||`, so the fallback must be
+        # parenthesized as its argument, e.g. `stack << (foo || :new)`.
+        def binary_operator?(node)
+          node.binary_operation? && !node.dot?
         end
 
         def without_argument_parentheses_method?(node)