rubocop 1.81.7 → 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_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
       #
@@ -139,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)
@@ -156,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))
@@ -164,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)
@@ -184,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)
@@ -222,7 +230,17 @@ 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)

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
       #
@@ -75,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)
 
@@ -86,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
@@ -116,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? &&
@@ -140,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
@@ -177,7 +187,7 @@ module RuboCop
             !use_hash_key_access?(if_branch)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # 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?
 
@@ -187,10 +197,9 @@ module RuboCop
 
           node.if_branch&.true_type? && node.else_branch && !node.else_branch.true_type?
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         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
 
@@ -200,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)
@@ -237,11 +246,11 @@ module RuboCop
           "#{method.source}(#{arguments.source})"
         end
 
-        # rubocop:disable Metrics/AbcSize
-        def if_source(if_branch, arithmetic_operation)
+        # 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}"
@@ -254,10 +263,9 @@ module RuboCop
             if_branch.source
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
-        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)
@@ -293,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?
 
@@ -319,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)

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

@@ -3,16 +3,21 @@
 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.
+      #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is
+      # installed, a leading `::` inside a namespace is also reported when the
+      # constant provably resolves to the same declaration with and without
+      # the base, i.e. nothing in the surrounding nesting shadows it.
       #
       # @example
       #   # bad
@@ -41,13 +46,14 @@ module RuboCop
       #     ::Const
       #   end
       class RedundantConstantBase < Base
+        include ProjectIndexHelp
         extend AutoCorrector
 
         MSG = 'Remove redundant `::`.'
 
         def on_cbase(node)
           return if lint_constant_resolution_cop_enabled?
-          return unless bad?(node)
+          return unless bad?(node) || provably_unshadowed?(node)
 
           add_offense(node) do |corrector|
             corrector.remove(node)
@@ -56,6 +62,36 @@ module RuboCop
 
         private
 
+        # When `AllCops/UseProjectIndex` is enabled, `::` inside a namespace is
+        # also redundant when the first constant segment resolves to the same
+        # declaration with and without the base, i.e. nothing in the
+        # surrounding nesting shadows it.
+        def provably_unshadowed?(node)
+          return false unless project_index
+          return false unless (segment = first_constant_segment(node))
+
+          nesting = module_nesting_ancestors_of(node)
+                    .map { |ancestor| ancestor.identifier.const_name }.reverse
+
+          !nesting.empty? && same_resolution?(segment, nesting)
+        rescue StandardError
+          false
+        end
+
+        def same_resolution?(segment, nesting)
+          relative = project_index.resolve_constant(segment, nesting)
+          absolute = project_index.resolve_constant(segment, [])
+
+          !relative.nil? && !absolute.nil? && relative.name == absolute.name
+        end
+
+        def first_constant_segment(node)
+          parent = node.parent
+          return nil unless parent&.const_type?
+
+          parent.short_name.to_s
+        end
+
         def lint_constant_resolution_cop_enabled?
           lint_constant_resolution_config.fetch('Enabled', false)
         end

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

@@ -26,7 +26,9 @@ module RuboCop
         def on_send(node)
           return unless (first_argument = node.first_argument)
           return unless (index = first_argument.source.index(CURRENT_DIRECTORY_PREFIX))
-          return unless (redundant_length = redundant_path_length(first_argument.str_content))
+
+          content = leading_path_content(first_argument)
+          return unless (redundant_length = redundant_path_length(content))
 
           begin_pos = first_argument.source_range.begin.begin_pos + index
           end_pos = begin_pos + redundant_length
@@ -39,6 +41,16 @@ module RuboCop
 
         private
 
+        # The literal text at the start of the path, which is the whole string
+        # for a plain string and the leading literal segment for an interpolated
+        # one (`nil` when it starts with interpolation).
+        def leading_path_content(node)
+          return node.str_content if node.str_type?
+          return unless node.dstr_type? && (first = node.children.first)&.str_type?
+
+          first.str_content
+        end
+
         def redundant_path_length(path)
           return unless (match = path&.match(REDUNDANT_CURRENT_DIRECTORY_PREFIX))
 

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

@@ -25,7 +25,13 @@ module RuboCop
         MSG = 'Remove the redundant double splat and braces, use keyword arguments directly.'
         MERGE_METHODS = %i[merge merge!].freeze
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # `Style/TrailingCommaInHashLiteral` adds a comma to the hash literal whose braces
+        # this cop removes in the same pass, which would leave a dangling comma.
+        def self.autocorrect_incompatible_with
+          [Style::TrailingCommaInHashLiteral]
+        end
+
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_hash(node)
           return if node.pairs.empty? || node.pairs.any?(&:hash_rocket?)
           return unless (parent = node.parent)
@@ -38,7 +44,6 @@ module RuboCop
             autocorrect(corrector, node, kwsplat)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
@@ -109,7 +114,7 @@ module RuboCop
 
           node.arguments.map do |arg|
             if arg.hash_type?
-              arg.source
+              hash_argument_source(arg)
             else
               "**#{arg.source}"
             end
@@ -123,6 +128,15 @@ module RuboCop
 
           mergeable?(parent)
         end
+
+        # A braced hash literal passed to `merge` must have its braces stripped so
+        # its pairs join the surrounding keyword arguments. Keeping the braces would
+        # produce a positional hash after keyword arguments, which is invalid Ruby.
+        def hash_argument_source(hash)
+          return hash.source unless hash.braces?
+
+          hash.pairs.map(&:source).join(', ')
+        end
       end
     end
   end