rubocop 1.84.2 → 1.88.1

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

@@ -79,6 +79,11 @@ module RuboCop
             corrector.replace(range, replacement)
 
             comments_in_range(node).reverse_each do |comment|
+              # Only relocate comments that the replacement destroys. A trailing
+              # comment after the chain survives in place, so moving it would
+              # duplicate it (and splitting the line drops the indentation).
+              next if comment.source_range.begin_pos >= range.end_pos
+
               corrector.insert_before(node, "#{comment.source}\n")
             end
           end

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

@@ -35,6 +35,10 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          # A trailing block (e.g. `Dir.each_child(path).none? { ... }`) changes
+          # the meaning and is not equivalent to `Dir.empty?`.
+          return if node.block_literal?
+
           offensive?(node) do |const_node, arg_node|
             replacement = "#{bang(node)}#{const_node.source}.empty?(#{arg_node.source})"
             add_offense(node, message: format(MSG, replacement: replacement)) do |corrector|

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

@@ -6,7 +6,7 @@ module RuboCop
   module Cop
     module Style
       # Detects comments to enable/disable RuboCop.
-      # This is useful if want to make sure that every RuboCop error gets fixed
+      # This is useful if you want to make sure that every RuboCop error gets fixed
       # and not quickly disabled with a comment.
       #
       # Specific cops can be allowed with the `AllowedCops` configuration. Note that

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

@@ -161,7 +161,12 @@ module RuboCop
           source = source.gsub(COMMENT_REGEXP, '')
           return if source.blank?
 
-          /\s*#{Regexp.escape(source.strip)}/
+          # Treat `\#` (an escaped interpolation marker in the heredoc) as matching
+          # either `\#` or `#` in the comment, since the comment may show either
+          # the literal source form or the runtime appearance.
+          segments = source.strip.split('\\#', -1).map { |segment| Regexp.escape(segment) }
+
+          /\s*#{segments.join('\\\\?#')}/
         end
       end
     end

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

@@ -26,7 +26,7 @@ module RuboCop
 
         MSG = 'Use `Integer#times` for a simple loop which iterates a fixed number of times.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return unless offending?(node)
 
           send_node = node.send_node

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

@@ -40,6 +40,8 @@ module RuboCop
           end
         end
 
+        alias on_itblock on_block
+
         def on_numblock(node)
           each_with_object_numblock_candidate?(node) do |method, body|
             _, method_name, method_arg = *method

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

@@ -28,7 +28,7 @@ module RuboCop
 
         MSG = 'Omit pipes for the empty block parameters.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           send_node = node.send_node
           check(node) unless send_node.send_type? && send_node.lambda_literal?
         end

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

@@ -40,7 +40,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Do not use empty `case` condition, instead use an `if` expression.'
-        NOT_SUPPORTED_PARENT_TYPES = %i[return break next send csend].freeze
+        NOT_SUPPORTED_PARENT_TYPES = %i[return break next send csend yield super].freeze
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_case(case_node)
@@ -90,7 +90,17 @@ module RuboCop
             range = range_between(conditions.first.source_range.begin_pos,
                                   conditions.last.source_range.end_pos)
 
-            corrector.replace(range, conditions.map(&:source).join(' || '))
+            corrector.replace(range, conditions.map { |c| parenthesize_condition(c) }.join(' || '))
+          end
+        end
+
+        # A condition that binds looser than `||` (e.g. a ternary, range, or
+        # assignment) must be parenthesized so the joined `||` keeps its meaning.
+        def parenthesize_condition(condition)
+          if condition.assignment? || condition.type?(:if, :and, :or, :range)
+            "(#{condition.source})"
+          else
+            condition.source
           end
         end
 

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

@@ -5,15 +5,26 @@ module RuboCop
     module Style
       # Enforces consistent style for empty class definitions.
       #
-      # This cop can enforce either a two-line class definition or `Class.new`
+      # This cop can enforce either a standard class definition or `Class.new`
       # for classes with no body.
       #
       # The supported styles are:
       #
-      # * class_definition (default) - prefer two-line class definition over `Class.new`
+      # * class_keyword (default) - prefer standard class definition over `Class.new`
       # * class_new - prefer `Class.new` over class definition
       #
-      # @example EnforcedStyle: class_definition (default)
+      # One difference between the two styles is that the `Class.new` form does not make
+      # the subclass name available to the base class's `inherited` callback.
+      # For this reason, `EnforcedStyle: class_keyword` is set as the default style.
+      # Class definitions without a superclass, which are not involved in inheritance,
+      # are not detected. This ensures safe detection regardless of the applied style.
+      # This avoids overlapping responsibilities with the `Lint/EmptyClass` cop.
+      #
+      # Use `AllowedParentClasses` to permit both styles for specific parent classes.
+      # For example, adding `StandardError` allows both `Error = Class.new(StandardError)`
+      # and `class Error < StandardError; end` regardless of the enforced style.
+      #
+      # @example EnforcedStyle: class_keyword (default)
       #   # bad
       #   FooError = Class.new(StandardError)
       #
@@ -35,33 +46,43 @@ module RuboCop
       #   # good
       #   FooError = Class.new(StandardError)
       #
+      # @example AllowedParentClasses: ['StandardError']
+      #   # good - allowed regardless of EnforcedStyle
+      #   FooError = Class.new(StandardError)
+      #
+      #   # good - allowed regardless of EnforcedStyle
+      #   class FooError < StandardError
+      #   end
+      #
       class EmptyClassDefinition < Base
         include ConfigurableEnforcedStyle
-        include RangeHelp
         extend AutoCorrector
 
-        MSG_CLASS_DEFINITION =
-          'Prefer a two-line class definition over `Class.new` for classes with no body.'
-        MSG_CLASS_NEW = 'Prefer `Class.new` over class definition for classes with no body.'
+        MSG_CLASS_KEYWORD =
+          'Use the `class` keyword instead of `Class.new` to define an empty class.'
+        MSG_CLASS_NEW = 'Use `Class.new` instead of the `class` keyword to define an empty class.'
 
         # @!method class_new_assignment(node)
         def_node_matcher :class_new_assignment, <<~PATTERN
-          (casgn _ _ $(send (const _ :Class) :new ...))
+          (casgn _ _ $(send (const _ :Class) :new _))
         PATTERN
 
         def on_casgn(node)
-          return unless style == :class_definition
+          return unless %i[class_keyword class_definition].include?(style)
           return unless (class_new_node = class_new_assignment(node))
           return if (arg = class_new_node.first_argument) && !arg.const_type?
+          return if allowed_parent_class?(class_new_node.first_argument.source)
 
-          add_offense(node, message: MSG_CLASS_DEFINITION) do |corrector|
+          add_offense(node, message: MSG_CLASS_KEYWORD) do |corrector|
             autocorrect_class_new(corrector, node, class_new_node)
           end
         end
 
         def on_class(node)
           return unless style == :class_new
+          return unless node.parent_class
           return if (body = node.body) && !body.children.empty?
+          return if allowed_parent_class?(node.parent_class.source)
 
           add_offense(node, message: MSG_CLASS_NEW) do |corrector|
             autocorrect_class_definition(corrector, node)
@@ -70,25 +91,34 @@ module RuboCop
 
         private
 
+        def allowed_parent_class?(parent_class_name)
+          allowed_parent_classes.include?(parent_class_name)
+        end
+
+        def allowed_parent_classes
+          cop_config.fetch('AllowedParentClasses', [])
+        end
+
         def autocorrect_class_new(corrector, node, class_new_node)
           indent = ' ' * node.loc.column
-          class_name = node.name
-          if (parent_class = class_new_node.first_argument)
-            parent_class_name = " < #{parent_class.source}"
-          end
+          class_name = constant_name(node)
+          parent_class_name = class_new_node.first_argument.source
 
-          corrector.replace(node, "class #{class_name}#{parent_class_name}\n#{indent}end")
+          corrector.replace(node, "class #{class_name} < #{parent_class_name}\n#{indent}end")
+        end
+
+        # Preserve any namespace on the assigned constant (e.g. `Foo::Bar`),
+        # which `node.name` drops.
+        def constant_name(node)
+          namespace = node.namespace
+          namespace ? "#{namespace.source}::#{node.name}" : node.name
         end
 
         def autocorrect_class_definition(corrector, node)
-          indent = ' ' * node.loc.column
           class_name = node.identifier.source
-          if (parent_class = node.parent_class)
-            parent_class_name = "(#{parent_class.source})"
-          end
-          range = range_by_whole_lines(node.source_range, include_final_newline: true)
+          parent_class_name = node.parent_class.source
 
-          corrector.replace(range, "#{indent}#{class_name} = Class.new#{parent_class_name}\n")
+          corrector.replace(node, "#{class_name} = Class.new(#{parent_class_name})")
         end
       end
     end

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

@@ -42,6 +42,10 @@ module RuboCop
         MSG = 'Use an empty string literal instead of heredoc.'
 
         def on_heredoc(node)
+          # A backtick heredoc (`<<~`CMD``) executes a command, so it cannot be
+          # replaced with an empty string literal.
+          return if node.xstr_type?
+
           heredoc_body = node.loc.heredoc_body
 
           return unless heredoc_body.source.empty?

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

@@ -23,7 +23,7 @@ module RuboCop
 
         MSG = 'Omit parentheses for the empty lambda parameters.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           send_node = node.send_node
           return unless send_node.send_type?
 

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

@@ -44,13 +44,18 @@ module RuboCop
         def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
 
         # @!method array_with_block(node)
-        def_node_matcher :array_with_block, '(block (send (const {nil? cbase} :Array) :new) args _)'
+        def_node_matcher :array_with_block, <<~PATTERN
+          {
+            (block (send (const {nil? cbase} :Array) :new) args _)
+            ({numblock itblock} (send (const {nil? cbase} :Array) :new) ...)
+          }
+        PATTERN
 
         # @!method hash_with_block(node)
         def_node_matcher :hash_with_block, <<~PATTERN
           {
             (block (send (const {nil? cbase} :Hash) :new) args _)
-            (numblock (send (const {nil? cbase} :Hash) :new) ...)
+            ({numblock itblock} (send (const {nil? cbase} :Hash) :new) ...)
           }
         PATTERN
 

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

@@ -45,36 +45,46 @@ module RuboCop
         MSG_TRAILING_CONDITIONAL = 'Do not use trailing conditionals in string interpolation.'
         MSG_TERNARY = 'Do not return empty strings in string interpolation.'
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
         def on_interpolation(node)
           node.each_child_node(:if) do |child_node|
             if style == :trailing_conditional
-              if empty_if_outcome?(child_node)
-                ternary_style_autocorrect(child_node, child_node.else_branch.source, 'unless')
-              end
-
-              if empty_else_outcome?(child_node)
-                ternary_style_autocorrect(child_node, child_node.if_branch.source, 'if')
-              end
+              trailing_conditional_correction(child_node)
             elsif style == :ternary
-              next unless child_node.modifier_form?
-
-              ternary_component = if child_node.unless?
-                                    "'' : #{child_node.if_branch.source}"
-                                  else
-                                    "#{child_node.if_branch.source} : ''"
-                                  end
-
-              add_offense(node, message: MSG_TRAILING_CONDITIONAL) do |corrector|
-                corrector.replace(node, "\#{#{child_node.condition.source} ? #{ternary_component}}")
-              end
+              ternary_correction(node, child_node)
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         private
 
+        def trailing_conditional_correction(child_node)
+          # A modifier `if`/`unless` is already a trailing conditional and has
+          # no `else` branch, so the ternary-to-trailing rewrite does not apply.
+          return if child_node.modifier_form?
+
+          if empty_if_outcome?(child_node)
+            ternary_style_autocorrect(child_node, child_node.else_branch.source, 'unless')
+          end
+
+          return unless empty_else_outcome?(child_node)
+
+          ternary_style_autocorrect(child_node, child_node.if_branch.source, 'if')
+        end
+
+        def ternary_correction(node, child_node)
+          return unless child_node.modifier_form?
+
+          ternary_component = if child_node.unless?
+                                "'' : #{child_node.if_branch.source}"
+                              else
+                                "#{child_node.if_branch.source} : ''"
+                              end
+
+          add_offense(node, message: MSG_TRAILING_CONDITIONAL) do |corrector|
+            corrector.replace(node, "\#{#{child_node.condition.source} ? #{ternary_component}}")
+          end
+        end
+
         def empty_if_outcome?(node)
           empty_branch_outcome?(node.if_branch)
         end

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

@@ -3,12 +3,18 @@
 module RuboCop
   module Cop
     module Style
-      # Checks ensures source files have no utf-8 encoding comments.
+      # Checks that source files have no utf-8 encoding comments.
+      # Since Ruby 2.0, UTF-8 is the default source encoding, so
+      # these comments are no longer necessary and just add noise.
+      #
       # @example
       #   # bad
       #   # encoding: UTF-8
       #   # coding: UTF-8
       #   # -*- coding: UTF-8 -*-
+      #
+      #   # good
+      #   # No encoding comment needed
       class Encoding < Base
         include RangeHelp
         extend AutoCorrector

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for END blocks.
+      # Checks for `END` blocks. `END` blocks are Perl-style constructs
+      # and `Kernel#at_exit` is the idiomatic Ruby alternative, as it's
+      # explicit and can be used anywhere.
       #
       # @example
       #   # bad

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

@@ -157,6 +157,7 @@ module RuboCop
             handle_require_always_style(node)
           end
         end
+        alias on_defs on_def
 
         private
 
@@ -170,7 +171,7 @@ module RuboCop
         end
 
         def handle_require_single_line_style(node)
-          if node.endless? && !node.single_line?
+          if node.endless? && node.multiline?
             add_offense(node, message: MSG_MULTI_LINE) do |corrector|
               correct_to_multiline(corrector, node)
             end
@@ -207,7 +208,7 @@ module RuboCop
 
         def correct_to_multiline(corrector, node)
           replacement = <<~RUBY.strip
-            def #{node.method_name}#{arguments(node)}
+            def #{receiver(node)}#{node.method_name}#{arguments(node)}
               #{node.body.source}
             end
           RUBY
@@ -217,10 +218,14 @@ module RuboCop
 
         def endless_replacement(node)
           <<~RUBY.strip
-            def #{node.method_name}#{arguments(node)} = #{node.body.source}
+            def #{receiver(node)}#{node.method_name}#{arguments(node)} = #{node.body.source}
           RUBY
         end
 
+        def receiver(node)
+          node.receiver ? "#{node.receiver.source}#{node.loc.operator.source}" : ''
+        end
+
         def arguments(node, missing = '')
           node.arguments.any? ? node.arguments.source : missing
         end

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

@@ -45,6 +45,10 @@ module RuboCop
         def on_send(node)
           return unless env_home?(node)
           return if node.arguments.count == 2 && !node.arguments[1].nil_type?
+          # `ENV.fetch('HOME') { default }` supplies a fallback, just like
+          # `ENV.fetch('HOME', default)`. `Dir.home` ignores the block, so
+          # converting would silently drop it.
+          return if node.block_node
 
           add_offense(node) do |corrector|
             corrector.replace(node, 'Dir.home')

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

@@ -34,7 +34,7 @@ module RuboCop
           even_odd_candidate?(node) do |base_number, method, arg|
             replacement_method = replacement_method(arg, method)
             add_offense(node, message: format(MSG, method: replacement_method)) do |corrector|
-              correction = "#{base_number.source}.#{replacement_method}?"
+              correction = "#{receiver_source(base_number)}.#{replacement_method}?"
               corrector.replace(node, correction)
             end
           end
@@ -42,6 +42,16 @@ module RuboCop
 
         private
 
+        def receiver_source(node)
+          # A binary or unary operator receiver (e.g. `a * b`, `-a`) binds looser
+          # than the appended method call, so it must be wrapped in parentheses.
+          if node.send_type? && node.operator_method? && !node.method?(:[])
+            "(#{node.source})"
+          else
+            node.source
+          end
+        end
+
         def replacement_method(arg, method)
           case arg
           when 0

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

@@ -43,7 +43,8 @@ module RuboCop
           return unless (parsed_regexp = parse_regexp(regexp))
           return unless exact_match_pattern?(parsed_regexp)
 
-          prefer = "#{receiver.source} #{new_method(node)} '#{parsed_regexp[1].text}'"
+          string = escape_single_quotes(parsed_regexp[1].text)
+          prefer = "#{receiver.source} #{new_method(node)} '#{string}'"
 
           add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
             corrector.replace(node, prefer)
@@ -53,6 +54,12 @@ module RuboCop
 
         private
 
+        # Escape characters that are special inside a single-quoted string so the
+        # generated literal (e.g. for `/\Afoo'bar\z/`) stays valid Ruby.
+        def escape_single_quotes(text)
+          text.gsub(/['\\]/) { |char| "\\#{char}" }
+        end
+
         def exact_match_pattern?(parsed_regexp)
           tokens = parsed_regexp.map(&:token)
           return false unless tokens[0] == :bos && tokens[1] == :literal && tokens[2] == :eos

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

@@ -70,7 +70,7 @@ module RuboCop
 
         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)

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

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