rubocop 1.71.1 → 1.91.0

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,6 +87,14 @@ 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)
 
@@ -96,7 +107,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 +115,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)
@@ -131,23 +145,17 @@ module RuboCop
           corrector.remove(send_node.loc.selector)
         end
 
-        def correct_from_slash_to_fdiv(corrector, node, receiver, argument)
-          receiver_source = extract_receiver_source(receiver)
-          argument_source = extract_receiver_source(argument)
+        def correct_from_slash_to_fdiv(corrector, receiver, argument)
+          remove_to_f_method(corrector, receiver) if to_f_method?(receiver)
 
-          if argument.respond_to?(:parenthesized?) && !argument.parenthesized?
-            argument_source = "(#{argument_source})"
-          end
+          argument_parenthesized = argument.begin_type?
+          corrector.replace(
+            receiver.source_range.end.join(argument.source_range.begin),
+            argument_parenthesized ? '.fdiv' : '.fdiv('
+          )
 
-          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
-          else
-            node.source
-          end
+          remove_to_f_method(corrector, argument) if to_f_method?(argument)
+          corrector.insert_after(argument, ')') unless argument_parenthesized
         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
@@ -66,6 +69,7 @@ module RuboCop
 
           if style == :for
             return unless node.receiver
+            return if rescue_or_ensure_body?(node)
 
             add_offense(node, message: PREFER_FOR) do |corrector|
               EachToForCorrector.new(node).call(corrector)
@@ -77,12 +81,17 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
         def suspect_enumerable?(node)
           node.multiline? && node.method?(:each) && !node.send_node.arguments?
         end
+
+        def rescue_or_ensure_body?(node)
+          node.body&.type?(:rescue, :ensure)
+        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]
@@ -143,10 +144,22 @@ 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_single_parameter(arg.children.first) if arg.splat_type?
+
           source = arg.source
           return "{ #{source} }" if arg.hash_type?
 
-          arg.send_type? && arg.operator_method? && !arg.parenthesized? ? "(#{source})" : source
+          requires_parentheses?(arg) ? "(#{source})" : source
+        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?
         end
       end
     end

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

@@ -3,16 +3,29 @@
 module RuboCop
   module Cop
     module Style
-      # Use a consistent style for named format string tokens.
+      # Use a consistent style for tokens within a format string.
       #
-      # NOTE: `unannotated` style cop only works for strings
-      # which are passed as arguments to those methods:
-      # `printf`, `sprintf`, `format`, `%`.
-      # The reason is that _unannotated_ format is very similar
-      # to encoded URLs or Date/Time formatting strings.
+      # By default, all strings are evaluated. In some cases, this may be undesirable,
+      # as they could be used as arguments to a method that does not consider
+      # them to be tokens, but rather other identifiers or just part of the string.
       #
-      # This cop's allowed methods can be customized with `AllowedMethods`.
-      # By default, there are no allowed methods.
+      # `AllowedMethods` or `AllowedPatterns` can be configured with in order to mark specific
+      # methods as always allowed, thereby avoiding an offense from the cop. By default, there
+      # are no allowed methods.
+      #
+      # Additionally, the cop can be made conservative by configuring it with
+      # `Mode: conservative` (default `aggressive`). In this mode, tokens (regardless
+      # of `EnforcedStyle`) are only considered if used in the format string argument to the
+      # methods `printf`, `sprintf`, `format` and `%`.
+      #
+      # NOTE: In `aggressive` mode, offenses are registered for all strings containing tokens,
+      # but autocorrection is only applied when the string appears in a known formatting context
+      # (`format`, `sprintf`, `printf`, or `%`). This is done in order to prevent false
+      # autocorrections for strings that are not actually format strings.
+      #
+      # NOTE: Tokens in the `unannotated` style (eg. `%s`) are always treated as if
+      # configured with `Conservative: true`. This is done in order to prevent false positives,
+      # because this format is very similar to encoded URLs or Date/Time formatting strings.
       #
       # @example EnforcedStyle: annotated (default)
       #
@@ -82,6 +95,42 @@ module RuboCop
       #   # good
       #   redirect('foo/%{bar_id}')
       #
+      # @example Mode: aggressive (default), EnforcedStyle: annotated
+      #
+      #   # bad
+      #   "%{greeting}"
+      #   foo("%{greeting}")
+      #
+      #   # bad
+      #   format("%{greeting}", greeting: 'Hello')
+      #   printf("%{greeting}", greeting: 'Hello')
+      #   sprintf("%{greeting}", greeting: 'Hello')
+      #   "%{greeting}" % { greeting: 'Hello' }
+      #
+      #   # good
+      #   format("%<greeting>s", greeting: 'Hello')
+      #   printf("%<greeting>s", greeting: 'Hello')
+      #   sprintf("%<greeting>s", greeting: 'Hello')
+      #   "%<greeting>s" % { greeting: 'Hello' }
+      #
+      # @example Mode: conservative, EnforcedStyle: annotated
+      #
+      #   # good
+      #   "%{greeting}"
+      #   foo("%{greeting}")
+      #
+      #   # bad
+      #   format("%{greeting}", greeting: 'Hello')
+      #   printf("%{greeting}", greeting: 'Hello')
+      #   sprintf("%{greeting}", greeting: 'Hello')
+      #   "%{greeting}" % { greeting: 'Hello' }
+      #
+      #   # good
+      #   format("%<greeting>s", greeting: 'Hello')
+      #   printf("%<greeting>s", greeting: 'Hello')
+      #   sprintf("%<greeting>s", greeting: 'Hello')
+      #   "%<greeting>s" % { greeting: 'Hello' }
+      #
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
         include AllowedMethods
@@ -96,7 +145,7 @@ module RuboCop
           return if allowed_unannotated?(detections)
 
           detections.each do |detected_sequence, token_range|
-            check_sequence(detected_sequence, token_range)
+            check_sequence(node, detected_sequence, token_range)
           end
         end
 
@@ -121,17 +170,34 @@ module RuboCop
             matches_allowed_pattern?(send_parent.method_name))
         end
 
-        def check_sequence(detected_sequence, token_range)
+        def check_sequence(node, detected_sequence, token_range)
           if detected_sequence.style == style
             correct_style_detected
           elsif correctable_sequence?(detected_sequence.type)
             style_detected(detected_sequence.style)
-            add_offense(token_range, message: message(detected_sequence.style)) do |corrector|
+            register_offense(node, detected_sequence, token_range)
+          end
+        end
+
+        def register_offense(node, detected_sequence, token_range)
+          msg = message(detected_sequence.style)
+
+          if format_string_context?(node)
+            add_offense(token_range, message: msg) do |corrector|
               autocorrect_sequence(corrector, detected_sequence, token_range)
             end
+          else
+            add_offense(token_range, message: msg)
           end
         end
 
+        def format_string_context?(node)
+          format_string_in_typical_context?(node) ||
+            node.each_ancestor(:dstr).any? do |dstr_node|
+              format_string_in_typical_context?(dstr_node)
+            end
+        end
+
         def correctable_sequence?(detected_type)
           detected_type == 's' || style == :annotated || style == :unannotated
         end
@@ -153,15 +219,16 @@ module RuboCop
           corrector.replace(token_range, correction)
         end
 
-        def unannotated_format?(node, detected_style)
-          detected_style == :unannotated && !format_string_in_typical_context?(node)
+        def allowed_string?(node, detected_style)
+          (detected_style == :unannotated || conservative?) &&
+            !format_string_in_typical_context?(node)
         end
 
         def message(detected_style)
           "Prefer #{message_text(style)} over #{message_text(detected_style)}."
         end
 
-        # rubocop:disable Style/FormatStringToken
+        # rubocop:disable-next Style/FormatStringToken -- the cop needs the token style it is matching
         def message_text(style)
           {
             annotated: 'annotated tokens (like `%<foo>s`)',
@@ -169,7 +236,6 @@ module RuboCop
             unannotated: 'unannotated tokens (like `%s`)'
           }[style]
         end
-        # rubocop:enable Style/FormatStringToken
 
         def tokens(str_node, &block)
           return if str_node.source == '__FILE__'
@@ -203,7 +269,7 @@ module RuboCop
         def collect_detections(node)
           detections = []
           tokens(node) do |detected_sequence, token_range|
-            unless unannotated_format?(node, detected_sequence.style)
+            unless allowed_string?(node, detected_sequence.style)
               detections << [detected_sequence, token_range]
             end
           end
@@ -222,6 +288,10 @@ module RuboCop
         def max_unannotated_placeholders_allowed
           cop_config['MaxUnannotatedPlaceholdersAllowed']
         end
+
+        def conservative?
+          cop_config.fetch('Mode', :aggressive).to_sym == :conservative
+        end
       end
     end
   end

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

@@ -151,7 +151,7 @@ module RuboCop
 
         def frozen_string_literal_comment(processed_source)
           processed_source.tokens.find do |token|
-            token.text.start_with?(FROZEN_STRING_LITERAL_REGEXP)
+            MagicComment.parse(token.text).frozen_string_literal_specified?
           end
         end
 
@@ -189,8 +189,9 @@ module RuboCop
 
         def enable_comment(corrector)
           comment = frozen_string_literal_comment(processed_source)
+          replacement = MagicComment.parse(comment.text).new_frozen_string_literal(true)
 
-          corrector.replace(line_range(comment.line), FROZEN_STRING_LITERAL_ENABLED)
+          corrector.replace(line_range(comment.line), replacement)
         end
 
         def insert_comment(corrector)

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

@@ -8,6 +8,9 @@ module RuboCop
       # reassign (possibly to redirect some stream) constants in Ruby, you'll get
       # an interpreter warning if you do so.
       #
+      # Additionally, `$stdout/$stderr/$stdin` can safely be accessed in a Ractor because they
+      # are ractor-local, while `STDOUT/STDERR/STDIN` will raise `Ractor::IsolationError`.
+      #
       # @safety
       #   Autocorrection is unsafe because `STDOUT` and `$stdout` may point to different
       #   objects, for example.

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

@@ -3,7 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # Looks for uses of global variables.
+      # Looks for uses of global variables. Global variables introduce
+      # shared mutable state that makes code harder to test, debug,
+      # and reason about, since any part of the program can read or modify them.
+      #
       # It does not report offenses for built-in global variables.
       # Built-in global variables are allowed by default. Additionally
       # users can allow additional variables via the AllowedVariables option.
@@ -54,7 +57,7 @@ module RuboCop
         ].map(&:to_sym)
 
         def user_vars
-          cop_config['AllowedVariables'].map(&:to_sym)
+          @user_vars ||= cop_config['AllowedVariables'].map(&:to_sym).freeze
         end
 
         def allowed_var?(global_var)