rubocop 1.66.0 → 1.72.1

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

@@ -109,7 +109,7 @@ module RuboCop
         end
 
         def max_line_length
-          return unless config.for_cop('Layout/LineLength')['Enabled']
+          return unless config.cop_enabled?('Layout/LineLength')
 
           config.for_cop('Layout/LineLength')['Max']
         end

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

@@ -48,6 +48,7 @@ module RuboCop
       #
       class EndlessMethod < Base
         include ConfigurableEnforcedStyle
+        include EndlessMethodRewriter
         extend TargetRubyVersion
         extend AutoCorrector
 
@@ -81,20 +82,6 @@ module RuboCop
 
           add_offense(node) { |corrector| correct_to_multiline(corrector, node) }
         end
-
-        def correct_to_multiline(corrector, node)
-          replacement = <<~RUBY.strip
-            def #{node.method_name}#{arguments(node)}
-              #{node.body.source}
-            end
-          RUBY
-
-          corrector.replace(node, replacement)
-        end
-
-        def arguments(node, missing = '')
-          node.arguments.any? ? node.arguments.source : missing
-        end
       end
     end
   end

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

@@ -86,7 +86,7 @@ module RuboCop
           return if node.method?(:eval) && !valid_eval_receiver?(node.receiver)
 
           code = node.first_argument
-          return unless code && (code.str_type? || code.dstr_type?)
+          return unless code&.type?(:str, :dstr)
 
           check_location(node, code)
         end
@@ -136,7 +136,7 @@ module RuboCop
                            actual: line_node.source,
                            expected: expected)
 
-          add_offense(line_node.source_range, message: message) do |corrector|
+          add_offense(line_node, message: message) do |corrector|
             corrector.replace(line_node, expected)
           end
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for exact regexp match inside Regexp literals.
+      # Checks for exact regexp match inside `Regexp` literals.
       #
       # @example
       #
@@ -40,8 +40,7 @@ module RuboCop
         def on_send(node)
           return unless (receiver = node.receiver)
           return unless (regexp = exact_regexp_match(node))
-
-          parsed_regexp = Regexp::Parser.parse(regexp)
+          return unless (parsed_regexp = parse_regexp(regexp))
           return unless exact_match_pattern?(parsed_regexp)
 
           prefer = "#{receiver.source} #{new_method(node)} '#{parsed_regexp[1].text}'"

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

@@ -123,7 +123,7 @@ module RuboCop
         end
 
         def call_like?(node)
-          node.call_type? || node.zsuper_type? || node.super_type?
+          node.type?(:call, :zsuper, :super)
         end
 
         def insert_argument(node, corrector, block_name)
@@ -135,7 +135,13 @@ module RuboCop
         end
 
         def correct_call_node(node, corrector, block_name)
-          corrector.insert_after(node, "(&#{block_name})")
+          new_arguments = if node.zsuper_type?
+                            args = build_new_arguments_for_zsuper(node) << "&#{block_name}"
+                            args.join(', ')
+                          else
+                            "&#{block_name}"
+                          end
+          corrector.insert_after(node, "(#{new_arguments})")
           return unless node.parenthesized?
 
           args_begin = Util.args_begin(node)
@@ -144,6 +150,13 @@ module RuboCop
           corrector.remove(range)
         end
 
+        def build_new_arguments_for_zsuper(node)
+          def_node = node.each_ancestor(:def, :defs).first
+          def_node.arguments.map do |arg|
+            arg.optarg_type? ? arg.node_parts[0] : arg.source
+          end
+        end
+
         def block_body_range(block_node, send_node)
           range_between(send_node.source_range.end_pos, block_node.loc.end.end_pos)
         end

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

@@ -8,7 +8,7 @@ module RuboCop
       #
       # * `scientific` which enforces a mantissa between 1 (inclusive) and 10 (exclusive).
       # * `engineering` which enforces the exponent to be a multiple of 3 and the mantissa
-      #   to be between 0.1 (inclusive) and 10 (exclusive).
+      #   to be between 0.1 (inclusive) and 1000 (exclusive).
       # * `integral` which enforces the mantissa to always be a whole number without
       #   trailing zeroes.
       #

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

@@ -6,7 +6,7 @@ module RuboCop
       # Suggests `ENV.fetch` for the replacement of `ENV[]`.
       # `ENV[]` silently fails and returns `nil` when the environment variable is unset,
       # which may cause unexpected behaviors when the developer forgets to set it.
-      # On the other hand, `ENV.fetch` raises KeyError or returns the explicitly
+      # On the other hand, `ENV.fetch` raises `KeyError` or returns the explicitly
       # specified default value.
       #
       # @example
@@ -26,6 +26,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `ENV.fetch(%<key>s)` or `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
+        RESTRICT_ON_SEND = [:[]].freeze
 
         # @!method env_with_bracket?(node)
         def_node_matcher :env_with_bracket?, <<~PATTERN

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_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/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

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)
+            token.text.start_with?(FROZEN_STRING_LITERAL_REGEXP)
           end
         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

@@ -234,11 +234,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}"
@@ -264,7 +264,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)
@@ -283,7 +283,8 @@ module RuboCop
         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?
@@ -292,6 +293,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

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

@@ -111,8 +111,7 @@ module RuboCop
         end
 
         def requires_parens?(node)
-          (node.call_type? && node.arguments.any? && !node.parenthesized?) ||
-            node.or_type? || node.and_type?
+          (node.call_type? && node.arguments.any? && !node.parenthesized?) || node.operator_keyword?
         end
 
         def multi_argument(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of `each_key` and `each_value` Hash methods.
+      # Checks for uses of `each_key` and `each_value` `Hash` methods.
       #
       # NOTE: If you have an array of two-element arrays, you can put
       #   parentheses around the block arguments to indicate that you're not
@@ -44,7 +44,7 @@ module RuboCop
 
         # @!method kv_each(node)
         def_node_matcher :kv_each, <<~PATTERN
-          ({block numblock} $(call (call _ ${:keys :values}) :each) ...)
+          (any_block $(call (call _ ${:keys :values}) :each) ...)
         PATTERN
 
         # @!method each_arguments(node)
@@ -57,6 +57,11 @@ module RuboCop
           (call $(call _ ${:keys :values}) :each (block_pass (sym _)))
         PATTERN
 
+        # @!method hash_mutated?(node, receiver)
+        def_node_matcher :hash_mutated?, <<~PATTERN
+          `(send %1 :[]= ...)
+        PATTERN
+
         def on_block(node)
           return unless handleable?(node)
 
@@ -103,6 +108,7 @@ module RuboCop
         def handleable?(node)
           return false if use_array_converter_method_as_preceding?(node)
           return false unless (root_receiver = root_receiver(node))
+          return false if hash_mutated?(node, root_receiver)
 
           !root_receiver.literal? || root_receiver.hash_type?
         end
@@ -156,10 +162,7 @@ module RuboCop
 
         def use_array_converter_method_as_preceding?(node)
           return false unless (preceding_method = node.children.first.children.first)
-          unless preceding_method.call_type? ||
-                 preceding_method.block_type? || preceding_method.numblock_type?
-            return false
-          end
+          return false unless preceding_method.type?(:call, :any_block)
 
           ARRAY_CONVERTER_METHODS.include?(preceding_method.method_name)
         end