rubocop 1.71.1 → 1.92.1

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

@@ -9,7 +9,20 @@ module RuboCop
       # On the other hand, `ENV.fetch` raises `KeyError` or returns the explicitly
       # specified default value.
       #
-      # @example
+      # @example DefaultToNil: true (default)
+      #   # bad
+      #   ENV['X']
+      #   x = ENV['X']
+      #
+      #   # good
+      #   ENV.fetch('X', nil)
+      #   x = ENV.fetch('X', nil)
+      #
+      #   # also good
+      #   !ENV['X']
+      #   ENV['X'].some_method # (e.g. `.nil?`)
+      #
+      # @example DefaultToNil: false
       #   # bad
       #   ENV['X']
       #   x = ENV['X']
@@ -25,7 +38,8 @@ module RuboCop
       class FetchEnvVar < Base
         extend AutoCorrector
 
-        MSG = 'Use `ENV.fetch(%<key>s)` or `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
+        MSG_WITH_NIL = 'Use `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
+        MSG_WITHOUT_NIL = 'Use `ENV.fetch(%<key>s)` instead of `ENV[%<key>s]`.'
         RESTRICT_ON_SEND = [:[]].freeze
 
         # @!method env_with_bracket?(node)
@@ -37,7 +51,7 @@ module RuboCop
           env_with_bracket?(node) do |name_node|
             break unless offensive?(node)
 
-            message = format(MSG, key: name_node.source)
+            message = format(offense_message, key: name_node.source)
             add_offense(node, message: message) do |corrector|
               corrector.replace(node, new_code(name_node))
             end
@@ -46,19 +60,27 @@ module RuboCop
 
         private
 
+        def default_to_nil?
+          cop_config.fetch('DefaultToNil', true)
+        end
+
+        def offense_message
+          default_to_nil? ? MSG_WITH_NIL : MSG_WITHOUT_NIL
+        end
+
         def allowed_var?(node)
           env_key_node = node.children.last
-          env_key_node.str_type? && cop_config['AllowedVars'].include?(env_key_node.value)
+          env_key_node.str_type? && cop_config['AllowedVariables'].include?(env_key_node.value)
         end
 
         def used_as_flag?(node)
           return false if node.root?
-          return true if used_if_condition_in_body(node)
+          return true if used_if_condition_in_body?(node)
 
           node.parent.send_type? && (node.parent.prefix_bang? || node.parent.comparison_method?)
         end
 
-        def used_if_condition_in_body(node)
+        def used_if_condition_in_body?(node)
           if_node = node.ancestors.find(&:if_type?)
 
           return false unless (condition = if_node&.condition)
@@ -125,7 +147,11 @@ module RuboCop
         end
 
         def new_code(name_node)
-          "ENV.fetch(#{name_node.source}, nil)"
+          if default_to_nil?
+            "ENV.fetch(#{name_node.source}, nil)"
+          else
+            "ENV.fetch(#{name_node.source})"
+          end
         end
       end
     end

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

@@ -54,7 +54,7 @@ module RuboCop
           @contain_dev_null_string_in_file = ast.each_descendant(:str).any? do |str|
             content = str.str_content
 
-            valid_string?(content) && content.downcase == '/dev/null' # rubocop:disable Style/FileNull
+            valid_string?(content) && content.downcase == '/dev/null' # rubocop:disable Style/FileNull -- the cop needs the literal it is matching
           end
         end
 
@@ -62,7 +62,7 @@ module RuboCop
           value = node.value
           return unless valid_string?(value)
           return if acceptable?(node)
-          return if value.downcase == 'nul' && !@contain_dev_null_string_in_file # rubocop:disable Style/FileNull
+          return if value.downcase == 'nul' && !@contain_dev_null_string_in_file # rubocop:disable Style/FileNull -- the cop needs the literal it is matching
           return unless REGEXP.match?(value)
 
           add_offense(node, message: format(MSG, source: value)) do |corrector|
@@ -78,10 +78,12 @@ module RuboCop
 
         def acceptable?(node)
           # Using a hardcoded null device is acceptable when inside an array or
-          # inside a hash to ensure behavior doesn't change.
+          # inside a hash to ensure behavior doesn't change. A `str` that is part of
+          # an interpolated or concatenated string (`dstr`) is not a standalone null
+          # device either, and replacing it would corrupt the surrounding string.
           return false unless node.parent
 
-          node.parent.type?(:array, :pair)
+          node.parent.type?(:array, :pair, :dstr)
         end
       end
     end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `File.open` without a block, which can leak file descriptors.
+      #
+      # When `File.open` is called without a block, the caller is responsible
+      # for closing the file descriptor. If it is not explicitly closed, it
+      # will only be closed when the garbage collector runs, which may lead
+      # to resource exhaustion. Using the block form ensures the file is
+      # automatically closed when the block exits.
+      #
+      # This cop only registers an offense when the result of `File.open` is
+      # assigned to a variable or has a method chained on it, as those are the
+      # clearest indicators that the block form should be used instead. When
+      # `File.open` is used as a return value or passed as an argument, the
+      # caller is likely managing the file descriptor intentionally.
+      #
+      # @safety
+      #   This cop is unsafe because it relies on syntax heuristics and cannot
+      #   verify whether the file descriptor is safely managed. For example, it
+      #   still flags intentional one-shot reads (`File.open("f").read`) where
+      #   the file descriptor is closed by the garbage collector.
+      #
+      # @example
+      #   # bad
+      #   f = File.open('file')
+      #
+      #   # bad
+      #   File.open('file').read
+      #
+      #   # good
+      #   File.open('file') do |f|
+      #     f.read
+      #   end
+      #
+      #   # good
+      #   File.open('file', &:read)
+      #
+      #   # good - pass an open file object to an API that manages its lifecycle
+      #   process(io: File.open('file'))
+      #
+      #   # good - return an open file object for the caller to manage
+      #   def json_key_io
+      #     File.open('file')
+      #   end
+      #
+      #   # good - use File.read for one-shot reads
+      #   File.read('file')
+      #
+      class FileOpen < Base
+        MSG = '`File.open` without a block may leak a file descriptor; use the block form.'
+        RESTRICT_ON_SEND = %i[open].freeze
+
+        # @!method file_open?(node)
+        def_node_matcher :file_open?, <<~PATTERN
+          (send (const {nil? cbase} :File) :open ...)
+        PATTERN
+
+        def on_send(node)
+          return unless file_open?(node)
+          return if node.block_argument?
+          return unless offensive_usage?(node)
+
+          add_offense(node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def offensive_usage?(node)
+          return true unless node.value_used?
+
+          node.parent.lvasgn_type? || receiver_of_chained_call?(node)
+        end
+
+        def receiver_of_chained_call?(node)
+          node.parent.receiver == node
+        end
+      end
+    end
+  end
+end

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

@@ -104,28 +104,33 @@ module RuboCop
 
         def replacement(mode, filename, content, write_node)
           replacement = "#{write_method(mode)}(#{filename.source}, #{content.source})"
+          heredocs = removed_heredocs(filename, content, write_node)
+          return replacement if heredocs.empty?
 
-          if heredoc?(write_node)
-            first_argument = write_node.body.first_argument
+          [replacement, *heredocs.map { |heredoc| heredoc_range(heredoc).source }].join("\n")
+        end
 
-            <<~REPLACEMENT.chomp
-              #{replacement}
-              #{heredoc_range(first_argument).source}
-            REPLACEMENT
-          else
-            replacement
-          end
+        # Heredocs opened in the arguments keep working in the replacement, but their
+        # bodies are lost when they lie within the replaced range, so they need to be
+        # restored after the replacement.
+        def removed_heredocs(filename, content, write_node)
+          [filename, content].flat_map { |argument| find_heredocs(argument) }
+                             .select { |heredoc| removed?(heredoc, write_node) }
+                             .sort_by { |heredoc| heredoc.loc.heredoc_body.begin_pos }
         end
 
-        def heredoc?(write_node)
-          write_node.block_type? && (first_argument = write_node.body.first_argument) &&
-            first_argument.respond_to?(:heredoc?) && first_argument.heredoc?
+        def heredoc_range(heredoc)
+          range_between(heredoc.loc.heredoc_body.begin_pos, heredoc.loc.heredoc_end.end_pos)
         end
 
-        def heredoc_range(first_argument)
-          range_between(
-            first_argument.loc.heredoc_body.begin_pos, first_argument.loc.heredoc_end.end_pos
-          )
+        def find_heredocs(node)
+          [node, *node.each_descendant(:any_str)].select do |child|
+            child.respond_to?(:heredoc?) && child.heredoc?
+          end
+        end
+
+        def removed?(heredoc, write_node)
+          heredoc.loc.heredoc_end.end_pos <= write_node.source_range.end_pos
         end
       end
     end

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

@@ -7,9 +7,12 @@ module RuboCop
       # It is recommended to either always use `fdiv` or coerce one side only.
       # This cop also provides other options for code consistency.
       #
+      # For `Regexp.last_match` and nth reference (e.g., `$1`), it assumes that the value
+      # is a string matched by a regular expression, and allows conversion with `#to_f`.
+      #
       # @safety
       #   This cop is unsafe, because if the operand variable is a string object
-      #   then `.to_f` will be removed and an error will occur.
+      #   then `#to_f` will be removed and an error will occur.
       #
       #   [source,ruby]
       #   ----
@@ -84,8 +87,17 @@ module RuboCop
           (send !nil? :to_f)
         PATTERN
 
+        # @!method regexp_last_match?(node)
+        def_node_matcher :regexp_last_match?, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Regexp) :last_match int)
+            (:nth_ref _)
+          }
+        PATTERN
+
         def on_send(node)
           return unless offense_condition?(node)
+          return if comment_before_to_f?(node)
 
           add_offense(node) do |corrector|
             case style
@@ -96,7 +108,7 @@ module RuboCop
               remove_to_f_method(corrector, node.receiver)
               add_to_f_method(corrector, node.first_argument)
             when :fdiv
-              correct_from_slash_to_fdiv(corrector, node, node.receiver, node.first_argument)
+              correct_from_slash_to_fdiv(corrector, node.receiver, node.first_argument)
             end
           end
         end
@@ -104,6 +116,9 @@ module RuboCop
         private
 
         def offense_condition?(node)
+          return false if regexp_last_match?(node.receiver.receiver) ||
+                          regexp_last_match?(node.first_argument.receiver)
+
           case style
           when :left_coerce
             right_coerce?(node)
@@ -127,28 +142,41 @@ module RuboCop
         end
 
         def remove_to_f_method(corrector, send_node)
-          corrector.remove(send_node.loc.dot)
-          corrector.remove(send_node.loc.selector)
+          corrector.remove(send_node.receiver.source_range.end.join(send_node.loc.selector.end))
         end
 
-        def correct_from_slash_to_fdiv(corrector, node, receiver, argument)
-          receiver_source = extract_receiver_source(receiver)
-          argument_source = extract_receiver_source(argument)
+        def comment_before_to_f?(node)
+          operands_losing_to_f(node).any? do |operand|
+            next false unless to_f_method?(operand)
 
-          if argument.respond_to?(:parenthesized?) && !argument.parenthesized?
-            argument_source = "(#{argument_source})"
+            range = operand.receiver.source_range.end.join(operand.loc.selector.begin)
+            processed_source.contains_comment?(range)
           end
-
-          corrector.replace(node, "#{receiver_source}.fdiv#{argument_source}")
         end
 
-        def extract_receiver_source(node)
-          if node.send_type? && node.method?(:to_f)
-            node.receiver.source
+        def operands_losing_to_f(node)
+          case style
+          when :left_coerce, :single_coerce
+            [node.first_argument]
+          when :right_coerce
+            [node.receiver]
           else
-            node.source
+            [node.receiver, node.first_argument]
           end
         end
+
+        def correct_from_slash_to_fdiv(corrector, receiver, argument)
+          remove_to_f_method(corrector, receiver) if to_f_method?(receiver)
+
+          argument_parenthesized = argument.begin_type?
+          corrector.replace(
+            receiver.source_range.end.join(argument.source_range.begin),
+            argument_parenthesized ? '.fdiv' : '.fdiv('
+          )
+
+          remove_to_f_method(corrector, argument) if to_f_method?(argument)
+          corrector.insert_after(argument, ')') unless argument_parenthesized
+        end
       end
     end
   end

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

@@ -8,6 +8,9 @@ module RuboCop
       # parameter. An `each` call with a block on a single line is always
       # allowed.
       #
+      # NOTE: `each` is preferred in idiomatic Ruby because `for` leaks
+      # its loop variable into the surrounding scope.
+      #
       # @example EnforcedStyle: each (default)
       #   # bad
       #   def foo
@@ -49,12 +52,23 @@ module RuboCop
         EACH_LENGTH = 'each'.length
         PREFER_EACH = 'Prefer `each` over `for`.'
         PREFER_FOR = 'Prefer `for` over `each`.'
+        IMPLICIT_PARAMETERS = %i[_1 _2 _3 _4 _5 _6 _7 _8 _9 it].to_set.freeze
+
+        # `Style/RedundantBegin` removes the `begin` of a block body in the same pass,
+        # leaving a `rescue` or `ensure` clause directly in the `for` body.
+        # `Style/ItBlockParameter` replaces block parameter references in the body
+        # with `it` in the same pass, while they become `for` loop variables.
+        def self.autocorrect_incompatible_with
+          [Style::RedundantBegin, Style::ItBlockParameter]
+        end
 
         def on_for(node)
           if style == :each
             add_offense(node, message: PREFER_EACH) do |corrector|
-              ForToEachCorrector.new(node).call(corrector)
               opposite_style_detected
+              next unless convertible_to_each?(node)
+
+              ForToEachCorrector.new(node).call(corrector)
             end
           else
             correct_style_detected
@@ -66,6 +80,8 @@ module RuboCop
 
           if style == :for
             return unless node.receiver
+            return unless convertible_to_for?(node)
+            return if rescue_or_ensure_body?(node) || do_end_block_in_collection?(node)
 
             add_offense(node, message: PREFER_FOR) do |corrector|
               EachToForCorrector.new(node).call(corrector)
@@ -77,12 +93,56 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
+        # The loop variable becomes a block parameter, which can only be a local
+        # variable, and the body can't refer to an implicit block parameter
+        # (`_1` or `it`) once the block has an explicit one.
+        def convertible_to_each?(node)
+          return false unless node.variable.each_node.all? { |n| n.type?(:lvasgn, :mlhs, :splat) }
+          return true unless node.body
+
+          node.body.each_node(:send, :lvar).none? { |ref| implicit_parameter?(ref, node) }
+        end
+
+        # Inside a numbered or `it` block, `_1` and `it` are local variables
+        # rather than method calls.
+        def implicit_parameter?(ref, for_node)
+          return false unless implicit_parameter_reference?(ref)
+
+          ref.each_ancestor.take_while { |ancestor| !ancestor.equal?(for_node) }
+             .none?(&:any_block_type?)
+        end
+
+        def implicit_parameter_reference?(ref)
+          return IMPLICIT_PARAMETERS.include?(ref.name) if ref.lvar_type?
+
+          IMPLICIT_PARAMETERS.include?(ref.method_name) && !ref.receiver && !ref.arguments?
+        end
+
         def suspect_enumerable?(node)
           node.multiline? && node.method?(:each) && !node.send_node.arguments?
         end
+
+        def convertible_to_for?(node)
+          return false if node.type?(:numblock, :itblock)
+          return true unless node.arguments?
+
+          arguments = node.arguments
+          return false if arguments.children.one? && arguments.children.first.restarg_type?
+
+          arguments.each_descendant.all? { |arg| arg.type?(:arg, :restarg, :mlhs) }
+        end
+
+        def rescue_or_ensure_body?(node)
+          node.body&.type?(:rescue, :ensure)
+        end
+
+        def do_end_block_in_collection?(node)
+          node.receiver.each_node(:any_block).any?(&:keywords?)
+        end
       end
     end
   end

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

@@ -11,9 +11,10 @@ module RuboCop
       # if the first argument is a string literal and if the second
       # argument is an array literal.
       #
-      # Autocorrection will be applied when using argument is a literal or known built-in conversion
-      # methods such as `to_d`, `to_f`, `to_h`, `to_i`, `to_r`, `to_s`, and `to_sym` on variables,
-      # provided that their return value is not an array. For example, when using `to_s`,
+      # Autocorrection will be applied when the argument is a literal or uses a known
+      # built-in conversion method such as `to_d`, `to_f`, `to_h`, `to_i`, `to_r`, `to_s`,
+      # and `to_sym` on variables, provided that their return value is not an array.
+      # For example, when using `to_s`,
       # `'%s' % [1, 2, 3].to_s` can be autocorrected without any incompatibility:
       #
       # [source,ruby]
@@ -68,9 +69,13 @@ module RuboCop
 
         # @!method variable_argument?(node)
         def_node_matcher :variable_argument?, <<~PATTERN
-          (send {str dstr} :% #autocorrectable?)
+          (send {str dstr} :% !#autocorrectable?)
         PATTERN
 
+        def on_new_investigation
+          @corrected_ranges = nil
+        end
+
         def on_send(node)
           formatter(node) do |selector|
             detected_style = selector == :% ? :percent : selector
@@ -85,10 +90,12 @@ module RuboCop
 
         private
 
+        # Only an argument that is provably not an array can be corrected,
+        # because `String#%` spreads an array argument and `format` does not.
         def autocorrectable?(node)
-          return true if node.lvar_type?
+          return true if node.literal?
 
-          node.send_type? && !AUTOCORRECTABLE_METHODS.include?(node.method_name)
+          node.call_type? && AUTOCORRECTABLE_METHODS.include?(node.method_name)
         end
 
         def message(detected_style)
@@ -100,7 +107,9 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          return if variable_argument?(node)
+          return if variable_argument?(node) || within_corrected_range?(node)
+
+          corrected_ranges << node.source_range
 
           case node.method_name
           when :%
@@ -115,6 +124,14 @@ module RuboCop
           end
         end
 
+        def within_corrected_range?(node)
+          corrected_ranges.any? { |range| range.contains?(node.source_range) }
+        end
+
+        def corrected_ranges
+          @corrected_ranges ||= []
+        end
+
         def autocorrect_from_percent(corrector, node)
           percent_rhs = node.first_argument
           args = case percent_rhs.type
@@ -143,10 +160,28 @@ module RuboCop
         end
 
         def format_single_parameter(arg)
+          # `format(fmt, *args)` is equivalent to `fmt % args`, so unwrap the splat
+          # and render the argument it splats.
+          return format_splatted_parameter(arg.children.first) if arg.splat_type?
+
           source = arg.source
-          return "{ #{source} }" if arg.hash_type?
+          return "{ #{source} }" if arg.hash_type? && !arg.braces?
+
+          requires_parentheses?(arg) ? "(#{source})" : source
+        end
+
+        def format_splatted_parameter(arg)
+          return "#{arg.source}.to_a" if arg.hash_type?
+
+          format_single_parameter(arg)
+        end
+
+        # An argument that binds looser than `%` (a ternary, range, assignment, or
+        # operator call) must be parenthesized to keep its meaning.
+        def requires_parentheses?(arg)
+          return true if arg.assignment? || arg.type?(:if, :and, :or, :range)
 
-          arg.send_type? && arg.operator_method? && !arg.parenthesized? ? "(#{source})" : source
+          arg.send_type? && arg.operator_method? && !arg.parenthesized?
         end
       end
     end