rubocop 1.79.2 → 1.88.0

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)
 
@@ -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)

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

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]

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

@@ -18,6 +18,11 @@ module RuboCop
       # 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.
@@ -90,9 +95,25 @@ 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
-      #   # In `conservative` mode, offenses are only registered for strings
-      #   # given to a known formatting method.
       #
       #   # good
       #   "%{greeting}"
@@ -104,6 +125,12 @@ module RuboCop
       #   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
@@ -118,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
 
@@ -143,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

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)

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

@@ -45,17 +45,6 @@ module RuboCop
       #   ok
       #
       #   # bad
-      #   if something
-      #     foo || raise('exception')
-      #   else
-      #     ok
-      #   end
-      #
-      #   # good
-      #   foo || raise('exception') if something
-      #   ok
-      #
-      #   # bad
       #   define_method(:test) do
       #     if something
       #       work
@@ -207,7 +196,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize
         def autocorrect(corrector, node, condition, replacement, guard)
           corrector.replace(node.loc.keyword.join(condition.source_range), replacement)
 
@@ -216,10 +205,10 @@ module RuboCop
 
           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)
-          elsif else_branch&.send_type? && heredoc?(else_branch.last_argument)
-            autocorrect_heredoc_argument(corrector, node, else_branch, if_branch, guard)
+          if (if_heredoc = find_heredoc_argument(if_branch))
+            autocorrect_heredoc_argument(corrector, node, if_heredoc, else_branch, guard)
+          elsif (else_heredoc = find_heredoc_argument(else_branch))
+            autocorrect_heredoc_argument(corrector, node, else_heredoc, if_branch, guard)
           else
             corrector.remove(node.loc.end)
             return unless node.else?
@@ -228,22 +217,38 @@ module RuboCop
             corrector.remove(range_of_branch_to_remove(node, guard))
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize
 
         def heredoc?(argument)
           argument.respond_to?(:heredoc?) && argument.heredoc?
         end
 
-        def autocorrect_heredoc_argument(corrector, node, heredoc_branch, leave_branch, guard)
+        def find_heredoc_argument(node)
+          return unless node
+
+          node = node.children.first while node.begin_type?
+          return node if heredoc?(node)
+          return unless node.call_type?
+
+          node.arguments.reverse_each do |argument|
+            heredoc_argument = find_heredoc_argument(argument)
+            return heredoc_argument if heredoc_argument
+          end
+
+          find_heredoc_argument(node.receiver)
+        end
+
+        def autocorrect_heredoc_argument(corrector, node, heredoc_node, leave_branch, guard)
           remove_whole_lines(corrector, node.loc.end)
           return unless node.else?
 
-          remove_whole_lines(corrector, leave_branch.source_range)
+          if leave_branch
+            remove_whole_lines(corrector, leave_branch.source_range)
+            corrector.insert_after(heredoc_node.loc.heredoc_end, "\n#{leave_branch.source}")
+          end
+
           remove_whole_lines(corrector, node.loc.else)
           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}"
-          )
         end
 
         def range_of_branch_to_remove(node, guard)

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

@@ -6,8 +6,13 @@ module RuboCop
       # Checks for presence or absence of braces around hash literal as a last
       # array item depending on configuration.
       #
-      # NOTE: This cop will ignore arrays where all items are hashes, regardless of
-      # EnforcedStyle.
+      # NOTE: This cop will ignore arrays where multiple items are all hashes,
+      # regardless of `EnforcedStyle`.
+      #
+      # [source,ruby]
+      # ----
+      # [{ one: 1 }, { two: 2 }]
+      # ----
       #
       # @example EnforcedStyle: braces (default)
       #   # bad
@@ -16,8 +21,11 @@ module RuboCop
       #   # good
       #   [1, 2, { one: 1, two: 2 }]
       #
+      #   # bad
+      #   [one: 1, two: 2]
+      #
       #   # good
-      #   [{ one: 1 }, { two: 2 }]
+      #   [{ one: 1, two: 2 }]
       #
       # @example EnforcedStyle: no_braces
       #   # bad
@@ -26,8 +34,11 @@ module RuboCop
       #   # good
       #   [1, 2, one: 1, two: 2]
       #
+      #   # bad
+      #   [{ one: 1, two: 2 }]
+      #
       #   # good
-      #   [{ one: 1 }, { two: 2 }]
+      #   [one: 1, two: 2]
       class HashAsLastArrayItem < Base
         include RangeHelp
         include ConfigurableEnforcedStyle
@@ -36,7 +47,7 @@ module RuboCop
         def on_hash(node)
           return if node.children.first&.kwsplat_type?
           return unless (array = containing_array(node))
-          return unless last_array_item?(array, node) && explicit_array?(array)
+          return unless expected_braced_last_array_item?(array, node) && explicit_array?(array)
 
           if braces_style?
             check_braces(node)
@@ -52,10 +63,12 @@ module RuboCop
           parent if parent&.array_type?
         end
 
-        def last_array_item?(array, node)
-          return false if array.child_nodes.all?(&:hash_type?)
+        def expected_braced_last_array_item?(array, node)
+          return false if array.each_value.all? do |node|
+            node.hash_type? && (braces_style? ? node.braces? : !node.braces?)
+          end
 
-          array.children.last.equal?(node)
+          !array.values[-2]&.hash_type? && array.values.last.equal?(node)
         end
 
         def explicit_array?(array)
@@ -67,7 +80,12 @@ module RuboCop
           return if node.braces?
 
           add_offense(node, message: 'Wrap hash in `{` and `}`.') do |corrector|
-            corrector.wrap(node, '{', '}')
+            if node.single_line? || same_line?(node, node.parent)
+              corrector.wrap(node, '{', '}')
+            else
+              indent = indent(node)
+              corrector.wrap(node, "{\n#{indent}", "\n#{indent}}")
+            end
           end
         end
 

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

@@ -73,7 +73,7 @@ module RuboCop
           first_argument = node.first_argument
           if first_argument.hash_type?
             register_offense_for_hash(node, first_argument)
-          elsif first_argument.splat_type?
+          elsif first_argument.type?(:splat, :forwarded_restarg)
             add_offense(node, message: MSG_SPLAT) unless allowed_splat_argument?
           elsif use_zip_method_without_argument?(first_argument)
             register_offense_for_zip_method(node, first_argument)

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of either `Hash#[]` or `Hash#fetch` for hash lookup.
+      #
+      # This cop can be configured to prefer either bracket-style (`[]`)
+      # or fetch-style lookup. It is disabled by default.
+      #
+      # When enforcing `fetch` style, only single-argument bracket access is flagged.
+      # When enforcing `brackets` style, only `fetch` calls with a single key
+      # argument are flagged (not those with default values or blocks).
+      #
+      # @safety
+      #   This cop is unsafe because `Hash#[]` and `Hash#fetch` have different
+      #   semantics. `Hash#[]` returns `nil` for missing keys, while `Hash#fetch`
+      #   raises a `KeyError`. Replacing one with the other can change program
+      #   behavior in cases where the key is missing.
+      #
+      #   Additionally, it cannot be guaranteed that the receiver is a `Hash`
+      #   or responds to the replacement method.
+      #
+      # @example EnforcedStyle: brackets (default)
+      #   # bad
+      #   hash.fetch(key)
+      #
+      #   # good
+      #   hash[key]
+      #
+      #   # good - fetch with default value is allowed
+      #   hash.fetch(key, default)
+      #
+      #   # good - fetch with block is allowed
+      #   hash.fetch(key) { default }
+      #
+      # @example EnforcedStyle: fetch
+      #   # bad
+      #   hash[key]
+      #
+      #   # good
+      #   hash.fetch(key)
+      #
+      # @example AllowedReceivers: ['Rails.cache']
+      #   # good
+      #   Rails.cache.fetch(name, options) { block }
+      #
+      class HashLookupMethod < Base
+        include ConfigurableEnforcedStyle
+        include AllowedReceivers
+        extend AutoCorrector
+
+        BRACKET_MSG = 'Use `Hash#[]` instead of `Hash#fetch`.'
+        FETCH_MSG = 'Use `Hash#fetch` instead of `Hash#[]`.'
+
+        RESTRICT_ON_SEND = %i[[] fetch].freeze
+
+        def on_send(node)
+          return if (receiver = node.receiver) && allowed_receiver?(receiver)
+
+          if offense_for_brackets?(node)
+            add_offense(node.loc.selector, message: BRACKET_MSG) do |corrector|
+              correct_fetch_to_brackets(corrector, node)
+            end
+          elsif offense_for_fetch?(node)
+            add_offense(node, message: FETCH_MSG) do |corrector|
+              correct_brackets_to_fetch(corrector, node)
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def offense_for_brackets?(node)
+          style == :brackets && node.receiver && node.method?(:fetch) && node.arguments.one? &&
+            !node.block_literal?
+        end
+
+        def offense_for_fetch?(node)
+          style == :fetch && node.method?(:[]) && node.arguments.one?
+        end
+
+        def correct_fetch_to_brackets(corrector, node)
+          key = node.first_argument.source
+
+          if node.csend_type?
+            corrector.replace(node, "(#{node.receiver.source}[#{key}])")
+          else
+            corrector.replace(node.loc.dot.join(node.source_range.end), "[#{key}]")
+          end
+        end
+
+        def correct_brackets_to_fetch(corrector, node)
+          key = node.first_argument.source
+
+          if node.csend_type?
+            corrector.replace(node.loc.dot.join(node.source_range.end), "&.fetch(#{key})")
+          else
+            corrector.replace(node.loc.selector.join(node.source_range.end), ".fetch(#{key})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -19,6 +19,22 @@ module RuboCop
       #   This cop is unsafe because it cannot be guaranteed that the receiver
       #   is a `Hash` or responds to the replacement method.
       #
+      #   Additionally, the replacement may change the order of the resulting
+      #   hash: `Hash#slice` returns entries in the order the keys are given,
+      #   whereas `select`, `filter`, and `reject` preserve the entry order of
+      #   the receiver.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   hash = {foo: 1, bar: 2, baz: 3}
+      #   keys = %i[baz foo]
+      #
+      #   hash.select { |k, _v| keys.include?(k) } # => {foo: 1, baz: 3}
+      #   hash.slice(*keys)                        # => {baz: 3, foo: 1}
+      #   ----
+      #
       # @example
       #
       #   # bad

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

@@ -212,7 +212,7 @@ module RuboCop
         end
 
         def word_symbol_pair?(pair)
-          return false unless pair.key.type?(:sym, :dsym)
+          return false unless pair.key.any_sym_type?
 
           acceptable_19_syntax_symbol?(pair.key.source)
         end

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

@@ -11,9 +11,11 @@ module RuboCop
       # (`transform_keys` was added in Ruby 2.5.)
       #
       # @safety
-      #   This cop is unsafe, as it can produce false positives if we are
-      #   transforming an enumerable of key-value-like pairs that isn't actually
-      #   a hash, e.g.: `[[k1, v1], [k2, v2], ...]`
+      #   This cop identifies the receiver as a hash by checking for literal hash
+      #   syntax and common methods that are known to return hashes (e.g. `to_h`,
+      #   `merge`, `invert`, `group_by`, etc.). However, it is unsafe because it
+      #   is possible for a custom class to define one of these methods and return
+      #   something other than a hash.
       #
       # @example
       #   # bad
@@ -21,10 +23,18 @@ module RuboCop
       #   Hash[{a: 1, b: 2}.collect { |k, v| [foo(k), v] }]
       #   {a: 1, b: 2}.map { |k, v| [k.to_s, v] }.to_h
       #   {a: 1, b: 2}.to_h { |k, v| [k.to_s, v] }
+      #   foo.to_h.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+      #   foo.merge(bar).map { |k, v| [k.to_s, v] }.to_h
       #
       #   # good
       #   {a: 1, b: 2}.transform_keys { |k| foo(k) }
       #   {a: 1, b: 2}.transform_keys { |k| k.to_s }
+      #   foo.to_h.transform_keys { |k| k.to_sym }
+      #   foo.merge(bar).transform_keys { |k| k.to_s }
+      #
+      #   # Won't register an offense - receiver is not known to be a hash
+      #   foo.bar.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
+      #   baz.map { |k, v| [k.to_s, v] }.to_h
       class HashTransformKeys < Base
         include HashTransformMethod
         extend AutoCorrector
@@ -35,7 +45,7 @@ module RuboCop
         # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            (call !#array_receiver? :each_with_object (hash))
+            (call #hash_receiver? :each_with_object (hash))
             (args
               (mlhs
                 (arg $_)
@@ -50,7 +60,7 @@ module RuboCop
             (const _ :Hash)
             :[]
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg $_)
                 (arg _val))
@@ -61,7 +71,7 @@ module RuboCop
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           (call
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg $_)
                 (arg _val))
@@ -72,7 +82,7 @@ module RuboCop
         # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            (call !#array_receiver? :to_h)
+            (call #hash_receiver? :to_h)
             (args
               (arg $_)
               (arg _val))