rubocop 1.84.2 → 1.86.2

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

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

@@ -224,15 +224,18 @@ module RuboCop
         end
 
         def find_heredoc_argument(node)
-          return unless node&.call_type?
+          return unless node
 
-          last_arg = node.last_argument
+          node = node.children.first while node.begin_type?
+          return node if heredoc?(node)
+          return unless node.call_type?
 
-          if heredoc?(last_arg)
-            last_arg
-          elsif last_arg&.call_type?
-            find_heredoc_argument(last_arg)
+          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)

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
@@ -69,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_lookup_method.rb

@@ -41,8 +41,13 @@ module RuboCop
       #   # 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`.'
@@ -51,6 +56,8 @@ module RuboCop
         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)
@@ -75,18 +82,23 @@ module RuboCop
         end
 
         def correct_fetch_to_brackets(corrector, node)
-          receiver = node.receiver.source
           key = node.first_argument.source
-          replacement = "#{receiver}[#{key}]"
-          replacement = "(#{replacement})" if node.csend_type?
-          corrector.replace(node, replacement)
+
+          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)
-          receiver = node.receiver.source
           key = node.first_argument.source
-          operator = node.csend_type? ? '&.' : '.'
-          corrector.replace(node, "#{receiver}#{operator}fetch(#{key})")
+
+          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

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

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

@@ -9,9 +9,11 @@ module RuboCop
       # call to `transform_values` instead.
       #
       # @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
@@ -19,10 +21,18 @@ module RuboCop
       #   Hash[{a: 1, b: 2}.collect { |k, v| [k, foo(v)] }]
       #   {a: 1, b: 2}.map { |k, v| [k, v * v] }.to_h
       #   {a: 1, b: 2}.to_h { |k, v| [k, v * v] }
+      #   foo.to_h.each_with_object({}) { |(k, v), h| h[k] = foo(v) }
+      #   foo.merge(bar).map { |k, v| [k, v.to_s] }.to_h
       #
       #   # good
       #   {a: 1, b: 2}.transform_values { |v| foo(v) }
       #   {a: 1, b: 2}.transform_values { |v| v * v }
+      #   foo.to_h.transform_values { |v| foo(v) }
+      #   foo.merge(bar).transform_values { |v| v.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] = v.to_s }
+      #   baz.map { |k, v| [k, v.to_s] }.to_h
       class HashTransformValues < Base
         include HashTransformMethod
         extend AutoCorrector
@@ -33,7 +43,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 _key)
@@ -48,7 +58,7 @@ module RuboCop
             (const _ :Hash)
             :[]
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg _key)
                 (arg $_))
@@ -59,7 +69,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 _key)
                 (arg $_))
@@ -70,7 +80,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 _key)
               (arg $_))

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

@@ -64,7 +64,7 @@ module RuboCop
 
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_if(node)
           return if node.ternary? || node.unless?
 
@@ -72,6 +72,7 @@ module RuboCop
 
           return unless else_branch&.if_type? && else_branch.if?
           return if allow_if_modifier_in_else_branch?(else_branch)
+          return if comments_between_else_and_if?(node, else_branch)
 
           add_offense(else_branch.loc.keyword) do |corrector|
             next if part_of_ignored_node?(node)
@@ -80,12 +81,12 @@ module RuboCop
             ignore_node(node)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
         def autocorrect(corrector, node)
-          if then?(node)
+          if node.then?
             # If the nested `if` is a then node, correct it first,
             # then the next pass will use `correct_to_elsif_from_if_inside_else_form`
             IfThenCorrector.new(node, indentation: 0).call(corrector)
@@ -124,10 +125,6 @@ module RuboCop
           corrector.remove(range_by_whole_lines(find_end_range(node), include_final_newline: true))
         end
 
-        def then?(node)
-          node.loc.begin&.source == 'then'
-        end
-
         def find_end_range(node)
           end_range = node.loc.end
           return end_range if end_range
@@ -139,6 +136,18 @@ module RuboCop
           range_between(node.loc.keyword.begin_pos, condition.source_range.end_pos)
         end
 
+        def comments_between_else_and_if?(node, else_branch)
+          return false if else_branch.modifier_form?
+
+          else_end = node.loc.else.end_pos
+          if_begin = else_branch.loc.keyword.begin_pos
+
+          processed_source.comments.any? do |comment|
+            comment_pos = comment.source_range.begin_pos
+            comment_pos > else_end && comment_pos < if_begin
+          end
+        end
+
         def allow_if_modifier_in_else_branch?(else_branch)
           allow_if_modifier? && else_branch&.modifier_form?
         end

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

@@ -89,9 +89,9 @@ module RuboCop
           [Style::SoleNestedConditional]
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_if(node)
-          return if endless_method?(node.body)
+          return if endless_method?(node.body) || node.ancestors.any?(&:dstr_type?)
 
           condition = node.condition
           return if defined_nodes(condition).any? { |n| defined_argument_is_undefined?(node, n) } ||
@@ -101,12 +101,13 @@ module RuboCop
 
           add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
             next if part_of_ignored_node?(node)
+            next if another_modifier_if_on_same_line?(node)
 
             autocorrect(corrector, node)
             ignore_node(node)
           end
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
@@ -280,6 +281,16 @@ module RuboCop
           node.parent if node&.type?(:pair)
         end
 
+        def another_modifier_if_on_same_line?(node)
+          collection = find_containing_collection(node)
+          return false unless collection
+
+          line = node.source_range.line
+          collection.each_descendant(:if).any? do |sibling|
+            sibling != node && sibling.modifier_form? && sibling.source_range.line == line
+          end
+        end
+
         def non_simple_if_unless?(node)
           node.ternary? || node.elsif? || node.else?
         end

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

@@ -17,9 +17,9 @@ module RuboCop
         include OnNormalIfUnless
         extend AutoCorrector
 
-        MSG_IF_ELSE = 'Do not use `if %<expr>s;` - use `if/else` instead.'
-        MSG_NEWLINE = 'Do not use `if %<expr>s;` - use a newline instead.'
-        MSG_TERNARY = 'Do not use `if %<expr>s;` - use a ternary operator instead.'
+        MSG_IF_ELSE = 'Do not use `%<keyword>s %<expr>s;` - use `if/else` instead.'
+        MSG_NEWLINE = 'Do not use `%<keyword>s %<expr>s;` - use a newline instead.'
+        MSG_TERNARY = 'Do not use `%<keyword>s %<expr>s;` - use a ternary operator instead.'
 
         def on_normal_if_unless(node)
           return if node.parent&.if_type?
@@ -49,7 +49,7 @@ module RuboCop
                        MSG_TERNARY
                      end
 
-          format(template, expr: node.condition.source)
+          format(template, keyword: node.keyword, expr: node.condition.source)
         end
 
         def autocorrect(corrector, node)
@@ -71,7 +71,7 @@ module RuboCop
         end
 
         def use_return_with_argument?(node)
-          node.if_branch&.return_type? && node.if_branch&.arguments&.any?
+          node.branches.compact.any? { |branch| branch.return_type? && branch.arguments.any? }
         end
 
         def replacement(node)
@@ -80,6 +80,8 @@ module RuboCop
           then_code = node.if_branch ? build_expression(node.if_branch) : 'nil'
           else_code = node.else_branch ? build_expression(node.else_branch) : 'nil'
 
+          then_code, else_code = else_code, then_code if node.unless?
+
           "#{node.condition.source} ? #{then_code} : #{else_code}"
         end
 

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

@@ -3,7 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for trailing inline comments.
+      # Checks for trailing inline comments. Inline comments can
+      # make lines harder to read, especially when they are long.
+      # Placing comments on their own line above the code they
+      # describe is often clearer.
       #
       # @example
       #

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

@@ -48,8 +48,7 @@ module RuboCop
         private
 
         def allowed_addresses
-          allowed_addresses = cop_config['AllowedAddresses']
-          Array(allowed_addresses).map(&:downcase)
+          @allowed_addresses ||= Array(cop_config['AllowedAddresses']).map(&:downcase).freeze
         end
 
         def potential_ip?(str)

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

@@ -176,7 +176,7 @@ module RuboCop
           if first_non_comment_token
             0...first_non_comment_token.line
           else
-            (0..)
+            0..
           end
         end
 
@@ -299,7 +299,7 @@ module RuboCop
         end
 
         def supported_capitalizations
-          cop_config['SupportedCapitalizations'].map(&:to_sym)
+          @supported_capitalizations ||= cop_config['SupportedCapitalizations'].map(&:to_sym).freeze
         end
       end
     end