rubocop 1.52.1 → 1.79.2

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use `File::NULL` instead of hardcoding the null device (`/dev/null` on Unix-like
+      # OSes, `NUL` or `NUL:` on Windows), so that code is platform independent.
+      # Only looks for full string matches, substrings within a longer string are not
+      # considered.
+      #
+      # However, only files that use the string `'/dev/null'` are targeted for detection.
+      # This is because the string `'NUL'` is not limited to the null device.
+      # This behavior results in false negatives when the `'/dev/null'` string is not used,
+      # but it is a trade-off to avoid false positives. `NULL:`
+      # Unlike `'NUL'`, `'NUL:'` is regarded as something like `C:` and is always detected.
+      #
+      # NOTE: Uses inside arrays and hashes are ignored.
+      #
+      # @safety
+      #   It is possible for a string value to be changed if code is being run
+      #   on multiple platforms and was previously hardcoded to a specific null device.
+      #
+      #   For example, the following string will change on Windows when changed to
+      #   `File::NULL`:
+      #
+      #   [source,ruby]
+      #   ----
+      #   path = "/dev/null"
+      #   ----
+      #
+      # @example
+      #   # bad
+      #   '/dev/null'
+      #   'NUL'
+      #   'NUL:'
+      #
+      #   # good
+      #   File::NULL
+      #
+      #   # ok - inside an array
+      #   null_devices = %w[/dev/null nul]
+      #
+      #   # ok - inside a hash
+      #   { unix: "/dev/null", windows: "nul" }
+      class FileNull < Base
+        extend AutoCorrector
+
+        REGEXP = %r{\A(/dev/null|NUL:?)\z}i.freeze
+        MSG = 'Use `File::NULL` instead of `%<source>s`.'
+
+        def on_new_investigation
+          return unless (ast = processed_source.ast)
+
+          @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
+          end
+        end
+
+        def on_str(node)
+          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 unless REGEXP.match?(value)
+
+          add_offense(node, message: format(MSG, source: value)) do |corrector|
+            corrector.replace(node, 'File::NULL')
+          end
+        end
+
+        private
+
+        def valid_string?(value)
+          !value.empty? && value.valid_encoding?
+        end
+
+        def acceptable?(node)
+          # Using a hardcoded null device is acceptable when inside an array or
+          # inside a hash to ensure behavior doesn't change.
+          return false unless node.parent
+
+          node.parent.type?(:array, :pair)
+        end
+      end
+    end
+  end
+end

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

@@ -6,8 +6,7 @@ module RuboCop
       # Favor `File.(bin)read` convenience methods.
       #
       # @example
-      #   ## text mode
-      #   # bad
+      #   # bad - text mode
       #   File.open(filename).read
       #   File.open(filename, &:read)
       #   File.open(filename) { |f| f.read }
@@ -23,9 +22,7 @@ module RuboCop
       #   # good
       #   File.read(filename)
       #
-      # @example
-      #   ## binary mode
-      #   # bad
+      #   # bad - binary mode
       #   File.open(filename, 'rb').read
       #   File.open(filename, 'rb', &:read)
       #   File.open(filename, 'rb') do |f|

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usage of `File.open` in append mode with empty block.
+      #
+      # Such a usage only creates a new file, but it doesn't update
+      # timestamps for an existing file, which might have been the intention.
+      #
+      # For example, for an existing file `foo.txt`:
+      #
+      #   ruby -e "puts File.mtime('foo.txt')"
+      #   # 2024-11-26 12:17:23 +0100
+      #
+      #   ruby -e "File.open('foo.txt', 'a') {}"
+      #
+      #   ruby -e "puts File.mtime('foo.txt')"
+      #   # 2024-11-26 12:17:23 +0100 -> unchanged
+      #
+      # If the intention was to update timestamps, `FileUtils.touch('foo.txt')`
+      # should be used instead.
+      #
+      # @safety
+      #   Autocorrection is unsafe for this cop because unlike `File.open`,
+      #   `FileUtils.touch` updates an existing file's timestamps.
+      #
+      # @example
+      #   # bad
+      #   File.open(filename, 'a') {}
+      #   File.open(filename, 'a+') {}
+      #
+      #   # good
+      #   FileUtils.touch(filename)
+      #
+      class FileTouch < Base
+        extend AutoCorrector
+
+        MSG = 'Use `FileUtils.touch(%<argument>s)` instead of `File.open` in ' \
+              'append mode with empty block.'
+
+        RESTRICT_ON_SEND = %i[open].freeze
+
+        APPEND_FILE_MODES = %w[a a+ ab a+b at a+t].to_set.freeze
+
+        # @!method file_open?(node)
+        def_node_matcher :file_open?, <<~PATTERN
+          (send
+            (const {nil? cbase} :File) :open
+            $(...)
+            (str %APPEND_FILE_MODES))
+        PATTERN
+
+        def on_send(node)
+          filename = file_open?(node)
+          parent = node.parent
+
+          return unless filename
+          return unless parent && empty_block?(parent)
+
+          message = format(MSG, argument: filename.source)
+          add_offense(parent, message: message) do |corrector|
+            corrector.replace(parent, "FileUtils.touch(#{filename.source})")
+          end
+        end
+
+        private
+
+        def empty_block?(node)
+          node.block_type? && !node.body
+        end
+      end
+    end
+  end
+end

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

@@ -17,8 +17,7 @@ module RuboCop
       # ----
       #
       # @example
-      #   ## text mode
-      #   # bad
+      #   # bad - text mode
       #   File.open(filename, 'w').write(content)
       #   File.open(filename, 'w') do |f|
       #     f.write(content)
@@ -27,9 +26,7 @@ module RuboCop
       #   # good
       #   File.write(filename, content)
       #
-      # @example
-      #   ## binary mode
-      #   # bad
+      #   # bad - binary mode
       #   File.open(filename, 'wb').write(content)
       #   File.open(filename, 'wb') do |f|
       #     f.write(content)

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

@@ -65,19 +65,23 @@ module RuboCop
 
         # @!method right_coerce?(node)
         def_node_matcher :right_coerce?, <<~PATTERN
-          (send _ :/ (send _ :to_f))
+          (send _ :/ #to_f_method?)
         PATTERN
         # @!method left_coerce?(node)
         def_node_matcher :left_coerce?, <<~PATTERN
-          (send (send _ :to_f) :/ _)
+          (send #to_f_method? :/ _)
         PATTERN
         # @!method both_coerce?(node)
         def_node_matcher :both_coerce?, <<~PATTERN
-          (send (send _ :to_f) :/ (send _ :to_f))
+          (send #to_f_method? :/ #to_f_method?)
         PATTERN
         # @!method any_coerce?(node)
         def_node_matcher :any_coerce?, <<~PATTERN
-          {(send _ :/ (send _ :to_f)) (send (send _ :to_f) :/ _)}
+          {(send _ :/ #to_f_method?) (send #to_f_method? :/ _)}
+        PATTERN
+        # @!method to_f_method?(node)
+        def_node_matcher :to_f_method?, <<~PATTERN
+          (send !nil? :to_f)
         PATTERN
 
         def on_send(node)

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

@@ -44,7 +44,6 @@ module RuboCop
       #
       class For < Base
         include ConfigurableEnforcedStyle
-        include RangeHelp
         extend AutoCorrector
 
         EACH_LENGTH = 'each'.length
@@ -66,6 +65,8 @@ module RuboCop
           return unless suspect_enumerable?(node)
 
           if style == :for
+            return unless node.receiver
+
             add_offense(node, message: PREFER_FOR) do |corrector|
               EachToForCorrector.new(node).call(corrector)
               opposite_style_detected
@@ -76,11 +77,12 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
         def suspect_enumerable?(node)
-          node.multiline? && node.send_node.method?(:each) && !node.send_node.arguments?
+          node.multiline? && node.method?(:each) && !node.send_node.arguments?
         end
       end
     end

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

@@ -4,36 +4,48 @@ module RuboCop
   module Cop
     module Style
       # Enforces the use of a single string formatting utility.
-      # Valid options include Kernel#format, Kernel#sprintf and String#%.
+      # Valid options include `Kernel#format`, `Kernel#sprintf`, and `String#%`.
       #
-      # The detection of String#% cannot be implemented in a reliable
+      # The detection of `String#%` cannot be implemented in a reliable
       # manner for all cases, so only two scenarios are considered -
       # 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`,
+      # `'%s' % [1, 2, 3].to_s` can be autocorrected without any incompatibility:
+      #
+      # [source,ruby]
+      # ----
+      # '%s' % [1, 2, 3]        #=> '1'
+      # format('%s', [1, 2, 3]) #=> '[1, 2, 3]'
+      # '%s' % [1, 2, 3].to_s   #=> '[1, 2, 3]'
+      # ----
+      #
       # @example EnforcedStyle: format (default)
       #   # bad
-      #   puts sprintf('%10s', 'hoge')
-      #   puts '%10s' % 'hoge'
+      #   puts sprintf('%10s', 'foo')
+      #   puts '%10s' % 'foo'
       #
       #   # good
-      #   puts format('%10s', 'hoge')
+      #   puts format('%10s', 'foo')
       #
       # @example EnforcedStyle: sprintf
       #   # bad
-      #   puts format('%10s', 'hoge')
-      #   puts '%10s' % 'hoge'
+      #   puts format('%10s', 'foo')
+      #   puts '%10s' % 'foo'
       #
       #   # good
-      #   puts sprintf('%10s', 'hoge')
+      #   puts sprintf('%10s', 'foo')
       #
       # @example EnforcedStyle: percent
       #   # bad
-      #   puts format('%10s', 'hoge')
-      #   puts sprintf('%10s', 'hoge')
+      #   puts format('%10s', 'foo')
+      #   puts sprintf('%10s', 'foo')
       #
       #   # good
-      #   puts '%10s' % 'hoge'
+      #   puts '%10s' % 'foo'
       #
       class FormatString < Base
         include ConfigurableEnforcedStyle
@@ -42,6 +54,9 @@ module RuboCop
         MSG = 'Favor `%<prefer>s` over `%<current>s`.'
         RESTRICT_ON_SEND = %i[format sprintf %].freeze
 
+        # Known conversion methods whose return value is not an array.
+        AUTOCORRECTABLE_METHODS = %i[to_d to_f to_h to_i to_r to_s to_sym].freeze
+
         # @!method formatter(node)
         def_node_matcher :formatter, <<~PATTERN
           {
@@ -53,7 +68,7 @@ module RuboCop
 
         # @!method variable_argument?(node)
         def_node_matcher :variable_argument?, <<~PATTERN
-          (send {str dstr} :% {send_type? lvar_type?})
+          (send {str dstr} :% #autocorrectable?)
         PATTERN
 
         def on_send(node)
@@ -70,6 +85,12 @@ module RuboCop
 
         private
 
+        def autocorrectable?(node)
+          return true if node.lvar_type?
+
+          node.send_type? && !AUTOCORRECTABLE_METHODS.include?(node.method_name)
+        end
+
         def message(detected_style)
           format(MSG, prefer: method_name(style), current: method_name(detected_style))
         end

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

@@ -3,16 +3,24 @@
 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 can be customized allowed methods with `AllowedMethods`.
-      # By default, there are no methods to allowed.
+      # `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: 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 +90,20 @@ module RuboCop
       #   # good
       #   redirect('foo/%{bar_id}')
       #
+      # @example Mode: conservative, EnforcedStyle: annotated
+      #   # In `conservative` mode, offenses are only registered for strings
+      #   # given to a known formatting method.
+      #
+      #   # good
+      #   "%{greeting}"
+      #   foo("%{greeting}")
+      #
+      #   # bad
+      #   format("%{greeting}", greeting: 'Hello')
+      #   printf("%{greeting}", greeting: 'Hello')
+      #   sprintf("%{greeting}", greeting: 'Hello')
+      #   "%{greeting}" % { greeting: 'Hello' }
+      #
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
         include AllowedMethods
@@ -153,8 +175,9 @@ 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)
@@ -203,7 +226,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 +245,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

@@ -142,14 +142,16 @@ module RuboCop
           end
 
           next_token = processed_source.tokens[token_number]
-          token = next_token if Encoding::ENCODING_PATTERN.match?(next_token&.text)
+          if next_token&.text&.valid_encoding? && Encoding::ENCODING_PATTERN.match?(next_token.text)
+            token = next_token
+          end
 
           token
         end
 
         def frozen_string_literal_comment(processed_source)
           processed_source.tokens.find do |token|
-            token.text.start_with?(FROZEN_STRING_LITERAL)
+            MagicComment.parse(token.text).frozen_string_literal_specified?
           end
         end
 
@@ -187,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.
@@ -44,7 +47,9 @@ module RuboCop
         PATTERN
 
         def on_const(node)
-          const_name = node.children[1]
+          return if namespaced?(node)
+
+          const_name = node.short_name
           return unless STD_STREAMS.include?(const_name)
 
           gvar_name = gvar_name(const_name).to_sym
@@ -61,6 +66,10 @@ module RuboCop
           format(MSG, gvar_name: gvar_name(const_name), const_name: const_name)
         end
 
+        def namespaced?(node)
+          !node.namespace.nil? && (node.relative? || !node.namespace.cbase_type?)
+        end
+
         def gvar_name(const_name)
           "$#{const_name.to_s.downcase}"
         end

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

@@ -70,9 +70,7 @@ module RuboCop
         end
 
         def check(node)
-          global_var, = *node
-
-          add_offense(node.loc.name) unless allowed_var?(global_var)
+          add_offense(node.loc.name) unless allowed_var?(node.name)
         end
       end
     end

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

@@ -55,6 +55,25 @@ module RuboCop
       #   foo || raise('exception') if something
       #   ok
       #
+      #   # bad
+      #   define_method(:test) do
+      #     if something
+      #       work
+      #     end
+      #   end
+      #
+      #   # good
+      #   define_method(:test) do
+      #     return unless something
+      #
+      #     work
+      #   end
+      #
+      #   # also good
+      #   define_method(:test) do
+      #     work if something
+      #   end
+      #
       # @example AllowConsecutiveConditionals: false (default)
       #   # bad
       #   def test
@@ -110,6 +129,14 @@ module RuboCop
         end
         alias on_defs on_def
 
+        def on_block(node)
+          return unless node.method?(:define_method) || node.method?(:define_singleton_method)
+
+          on_def(node)
+        end
+        alias on_numblock on_block
+        alias on_itblock on_block
+
         def on_if(node)
           return if accepted_form?(node)
 
@@ -187,7 +214,7 @@ module RuboCop
           if_branch = node.if_branch
           else_branch = node.else_branch
 
-          corrector.replace(node.loc.begin, "\n") if node.loc.begin&.is?('then')
+          corrector.replace(node.loc.begin, "\n") if node.then?
 
           if if_branch&.send_type? && heredoc?(if_branch.last_argument)
             autocorrect_heredoc_argument(corrector, node, if_branch, else_branch, guard)
@@ -208,11 +235,11 @@ module RuboCop
         end
 
         def autocorrect_heredoc_argument(corrector, node, heredoc_branch, leave_branch, guard)
+          remove_whole_lines(corrector, node.loc.end)
           return unless node.else?
 
           remove_whole_lines(corrector, leave_branch.source_range)
           remove_whole_lines(corrector, node.loc.else)
-          remove_whole_lines(corrector, node.loc.end)
           remove_whole_lines(corrector, range_of_branch_to_remove(node, guard))
           corrector.insert_after(
             heredoc_branch.last_argument.loc.heredoc_end, "\n#{leave_branch.source}"
@@ -238,7 +265,7 @@ module RuboCop
 
         def and_or_guard_clause?(guard_clause)
           parent = guard_clause.parent
-          parent.and_type? || parent.or_type?
+          parent.operator_keyword?
         end
 
         def too_long_for_single_line?(node, example)
@@ -251,11 +278,14 @@ module RuboCop
         end
 
         def trivial?(node)
+          return false unless node.if_branch
+
           node.branches.one? && !node.if_branch.if_type? && !node.if_branch.begin_type?
         end
 
         def accepted_if?(node, ending)
-          return true if node.modifier_form? || node.ternary? || node.elsif_conditional?
+          return true if node.modifier_form? || node.ternary? || node.elsif_conditional? ||
+                         assigned_lvar_used_in_if_branch?(node)
 
           if ending
             node.else?
@@ -264,6 +294,18 @@ module RuboCop
           end
         end
 
+        def assigned_lvar_used_in_if_branch?(node)
+          return false unless (if_branch = node.if_branch)
+
+          assigned_lvars_in_condition = node.condition.each_descendant(:lvasgn).map do |lvasgn|
+            lvar_name, = *lvasgn
+            lvar_name.to_s
+          end
+          used_lvars_in_branch = if_branch.each_descendant(:lvar).map(&:source) || []
+
+          (assigned_lvars_in_condition & used_lvars_in_branch).any?
+        end
+
         def remove_whole_lines(corrector, range)
           corrector.remove(range_by_whole_lines(range, include_final_newline: true))
         end