rubocop 1.81.7 → 1.92.1

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

@@ -76,6 +76,9 @@ module RuboCop
 
         def on_super(super_node)
           return unless (def_node = find_def_node(super_node))
+          # Zsuper passes a destructured argument as the original value, while
+          # `argument_list` flattens it into its parts.
+          return if def_node.arguments.any?(&:mlhs_type?)
 
           def_node_args = def_node.arguments.argument_list
           super_args = preprocess_super_args(super_node.arguments)
@@ -103,13 +106,13 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def arguments_identical?(def_node, super_node, def_args, super_args)
           return false if argument_list_size_differs?(def_args, super_args, super_node)
 
           def_args.zip(super_args).each do |def_arg, super_arg|
             next if positional_arg_same?(def_arg, super_arg)
-            next if positional_rest_arg_same(def_arg, super_arg)
+            next if positional_rest_arg_same?(def_arg, super_arg)
             next if keyword_arg_same?(def_arg, super_arg)
             next if keyword_rest_arg_same?(def_arg, super_arg)
             next if block_arg_same?(def_node, super_node, def_arg, super_arg)
@@ -120,7 +123,6 @@ module RuboCop
 
           true
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def argument_list_size_differs?(def_args, super_args, super_node)
           # If the def node has a block argument and the super node has an explicit block,
@@ -147,7 +149,7 @@ module RuboCop
           def_arg.name == super_arg.children.first
         end
 
-        def positional_rest_arg_same(def_arg, super_arg)
+        def positional_rest_arg_same?(def_arg, super_arg)
           return false unless def_arg.restarg_type?
           # anonymous forwarding
           return true if def_arg.name.nil? && super_arg.forwarded_restarg_type?

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

@@ -142,9 +142,11 @@ module RuboCop
         include RangeHelp
         include AllowedMethods
         include AllowedPattern
+        include PatternMatchingHelp
         extend AutoCorrector
 
         MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` instead of a block.'
+        MSG_LAMBDA_LITERAL = 'Use `lambda(&:%<method>s)` instead of %<original>s.'
         SUPER_TYPES = %i[super zsuper].freeze
         LAMBDA_OR_PROC = %i[lambda proc].freeze
 
@@ -164,27 +166,28 @@ module RuboCop
         PATTERN
 
         def self.autocorrect_incompatible_with
-          [Layout::SpaceBeforeBlockBraces]
+          [Layout::SpaceBeforeBlockBraces, Style::TrailingCommaInArguments]
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_block(node)
           symbol_proc?(node) do |dispatch_node, arguments_node, method_name|
             if active_support_extensions_enabled?
               return if proc_node?(dispatch_node)
               return if LAMBDA_OR_PROC.include?(dispatch_node.method_name)
             end
+            # A pattern accepts a lambda literal, but not `lambda(&:foo)`.
+            return if in_pattern?(node)
             return if unsafe_hash_usage?(dispatch_node)
             return if unsafe_array_usage?(dispatch_node)
             return if allowed_method_name?(dispatch_node.method_name)
             return if allow_if_method_has_argument?(node.send_node)
             return if node.block_type? && destructuring_block_argument?(arguments_node)
-            return if allow_comments? && contains_comments?(node)
+            return if allow_comments?(node)
 
             register_offense(node, method_name, dispatch_node.method_name)
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         alias on_numblock on_block
         alias on_itblock on_block
 
@@ -208,12 +211,26 @@ module RuboCop
         end
 
         def register_offense(node, method_name, block_method_name)
-          block_start = node.loc.begin.begin_pos
-          block_end = node.loc.end.end_pos
-          range = range_between(block_start, block_end)
-          message = format(MSG, method: method_name, block_method: block_method_name)
+          range = if node.send_node.lambda_literal?
+                    node.source_range
+                  else
+                    node.loc.begin.begin.join(node.loc.end.end)
+                  end
+          message = message(node, method_name, block_method_name)
 
-          add_offense(range, message: message) { |corrector| autocorrect(corrector, node) }
+          add_offense(range, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def message(node, method_name, block_method_name)
+          if node.send_node.lambda_literal?
+            original = node.single_line? ? "`#{node.source}`" : 'a lambda literal with a block'
+
+            format(MSG_LAMBDA_LITERAL, method: method_name, original: original)
+          else
+            format(MSG, method: method_name, block_method: block_method_name)
+          end
         end
 
         def autocorrect(corrector, node)
@@ -260,10 +277,10 @@ module RuboCop
         end
 
         def begin_pos_for_replacement(node)
-          expr = node.send_node.source_range
+          send_node = node.send_node
 
-          if (paren_pos = (expr.source =~ /\(\s*\)$/))
-            expr.begin_pos + paren_pos
+          if send_node.parenthesized? && send_node.arguments.empty?
+            send_node.loc.begin.begin_pos
           else
             node.loc.begin.begin_pos
           end
@@ -273,8 +290,9 @@ module RuboCop
           !!cop_config.fetch('AllowMethodsWithArguments', false) && send_node.arguments.any?
         end
 
-        def allow_comments?
-          cop_config.fetch('AllowComments', false)
+        def allow_comments?(node)
+          cop_config.fetch('AllowComments', false) && contains_comments?(node) &&
+            !comments_contain_disables?(node, name)
         end
       end
     end

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for manual counting patterns that can be replaced by `Enumerable#tally`.
+      #
+      # The cop detects the following patterns:
+      #
+      # - `each_with_object(Hash.new(0)) { |item, counts| counts[item] += 1 }`
+      # - `group_by(&:itself).transform_values(&:count)`
+      # - `group_by { |x| x }.transform_values(&:size)`
+      # - `group_by { |x| x }.transform_values { |v| v.length }`
+      #
+      # @safety
+      #   This cop is unsafe because it cannot guarantee that the receiver
+      #   is an `Enumerable` by static analysis, so the correction may
+      #   not be actually equivalent.
+      #
+      # @example
+      #   # bad
+      #   array.each_with_object(Hash.new(0)) { |item, counts| counts[item] += 1 }
+      #
+      #   # bad
+      #   array.group_by(&:itself).transform_values(&:count)
+      #
+      #   # bad
+      #   array.group_by { |item| item }.transform_values(&:size)
+      #
+      #   # bad
+      #   array.group_by { |item| item }.transform_values { |v| v.length }
+      #
+      #   # good
+      #   array.tally
+      #
+      class TallyMethod < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+        include RangeHelp
+
+        minimum_target_ruby_version 2.7
+
+        MSG_EACH_WITH_OBJECT = 'Use `tally` instead of `each_with_object`.'
+        MSG_GROUP_BY = 'Use `tally` instead of `group_by` and `transform_values`.'
+        RESTRICT_ON_SEND = %i[each_with_object transform_values].freeze
+        COUNTING_METHODS = %i[count size length].to_set.freeze
+
+        # Pattern 1: collection.each_with_object(Hash.new(0)) { |elem, hash| hash[elem] += 1 }
+        # @!method tally_each_with_object?(node)
+        def_node_matcher :tally_each_with_object?, <<~PATTERN
+          {
+            (block
+              (call _ :each_with_object
+                (send (const {nil? cbase} :Hash) :new (int 0)))
+              (args (arg _elem) (arg _hash))
+              (op_asgn
+                (send (lvar _hash) :[] (lvar _elem)) :+ (int 1)))
+            (numblock
+              (call _ :each_with_object
+                (send (const {nil? cbase} :Hash) :new (int 0)))
+              2
+              (op_asgn
+                (send (lvar :_2) :[] (lvar :_1)) :+ (int 1)))
+          }
+        PATTERN
+
+        # Pattern 2: collection.group_by(&:itself).transform_values(&:count/size/length)
+        # @!method tally_group_by_symbol?(node)
+        def_node_matcher :tally_group_by_symbol?, <<~PATTERN
+          (call
+            (call _ :group_by (block_pass (sym :itself)))
+            :transform_values
+            (block_pass (sym %COUNTING_METHODS)))
+        PATTERN
+
+        # Pattern 3: collection.group_by { |x| x }.transform_values(&:count/size/length)
+        # @!method tally_group_by_identity_block?(node)
+        def_node_matcher :tally_group_by_identity_block?, <<~PATTERN
+          (call
+            {
+              (block (call _ :group_by) (args (arg _x)) (lvar _x))
+              (numblock (call _ :group_by) 1 (lvar :_1))
+              (itblock (call _ :group_by) :it (lvar :it))
+            }
+            :transform_values
+            (block_pass (sym %COUNTING_METHODS)))
+        PATTERN
+
+        # Pattern 4: collection.group_by(&:itself).transform_values { |v| v.count/size/length }
+        #            collection.group_by { |x| x }.transform_values { |v| v.count/size/length }
+        # @!method tally_group_by_transform_block?(node)
+        def_node_matcher :tally_group_by_transform_block?, <<~PATTERN
+          {
+            (block
+              (call
+                {
+                  (call _ :group_by (block_pass (sym :itself)))
+                  (block (call _ :group_by) (args (arg _x)) (lvar _x))
+                  (numblock (call _ :group_by) 1 (lvar :_1))
+                  (itblock (call _ :group_by) :it (lvar :it))
+                }
+                :transform_values)
+              (args (arg _v))
+              (send (lvar _v) %COUNTING_METHODS))
+            (numblock
+              (call
+                {
+                  (call _ :group_by (block_pass (sym :itself)))
+                  (block (call _ :group_by) (args (arg _x)) (lvar _x))
+                  (numblock (call _ :group_by) 1 (lvar :_1))
+                  (itblock (call _ :group_by) :it (lvar :it))
+                }
+                :transform_values)
+              1
+              (send (lvar :_1) %COUNTING_METHODS))
+            (itblock
+              (call
+                {
+                  (call _ :group_by (block_pass (sym :itself)))
+                  (block (call _ :group_by) (args (arg _x)) (lvar _x))
+                  (numblock (call _ :group_by) 1 (lvar :_1))
+                  (itblock (call _ :group_by) :it (lvar :it))
+                }
+                :transform_values)
+              :it
+              (send (lvar :it) %COUNTING_METHODS))
+          }
+        PATTERN
+        def on_send(node)
+          if node.method?(:each_with_object)
+            check_each_with_object(node)
+          elsif node.method?(:transform_values)
+            check_transform_values(node)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_each_with_object(node)
+          block_node = node.block_node
+          return unless block_node
+          return unless tally_each_with_object?(block_node)
+
+          add_offense(node.loc.selector, message: MSG_EACH_WITH_OBJECT) do |corrector|
+            corrector.replace(replacement_range(node, block_node), 'tally')
+          end
+        end
+
+        def check_transform_values(node)
+          if tally_group_by_symbol?(node) || tally_group_by_identity_block?(node)
+            register_group_by_offense(node, node)
+          elsif (block_node = node.block_node) && tally_group_by_transform_block?(block_node)
+            register_group_by_offense(node, block_node)
+          end
+        end
+
+        def register_group_by_offense(transform_node, end_node)
+          group_by_node = group_by_send_node(transform_node)
+
+          add_offense(group_by_node.loc.selector, message: MSG_GROUP_BY) do |corrector|
+            corrector.replace(replacement_range(group_by_node, end_node), 'tally')
+          end
+        end
+
+        def group_by_send_node(transform_node)
+          receiver = transform_node.receiver
+          if receiver.type?(:any_block)
+            receiver.send_node
+          else
+            receiver
+          end
+        end
+
+        def replacement_range(start_node, end_node)
+          range_between(start_node.loc.selector.begin_pos, end_node.source_range.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -58,6 +58,7 @@ module RuboCop
         include SafeAssignment
         include ConfigurableEnforcedStyle
         include SurroundingSpace
+        include ReparsedEquivalence
         extend AutoCorrector
 
         VARIABLE_TYPES = AST::Node::VARIABLES
@@ -101,7 +102,8 @@ module RuboCop
           condition = node.condition
 
           return nil if parenthesized?(condition) &&
-                        (safe_assignment?(condition) || unsafe_autocorrect?(condition))
+                        (safe_assignment?(condition) || unsafe_autocorrect?(condition) ||
+                         verified_by_reparse([condition]).empty?)
 
           if parenthesized?(condition)
             correct_parenthesized(corrector, condition)
@@ -113,6 +115,10 @@ module RuboCop
         def offense?(node)
           condition = node.condition
 
+          # A modifier `if`/`unless` requires the parentheses, e.g. `(a if b) ? x : y`,
+          # so removing them would change the meaning. Don't flag it.
+          return false if parenthesized_modifier_condition?(condition)
+
           if safe_assignment?(condition)
             !safe_assignment_allowed?
           else
@@ -174,6 +180,13 @@ module RuboCop
           condition.children.any? { |child| below_ternary_precedence?(child) }
         end
 
+        def parenthesized_modifier_condition?(condition)
+          return false unless condition.begin_type?
+
+          inner = condition.children.first
+          inner&.if_type? && inner.modifier_form?
+        end
+
         def unparenthesized_method_call?(child)
           /^[a-z]/i.match?(method_name(child)) && !child.parenthesized?
         end
@@ -207,6 +220,26 @@ module RuboCop
           end
         end
 
+        # Whatever binds looser than the ternary operator (`n += 1`, `a rescue b`,
+        # a nested ternary, `yield a`, several statements, ...) changes
+        # meaning without the parentheses, so their removal is verified by
+        # reparsing.
+        def apply_reparse_correction(corrector, condition)
+          correct_parenthesized(corrector, condition)
+        end
+
+        # The removed parentheses are the only expected difference.
+        def normalize_reparsed_ast(node)
+          return node unless node.is_a?(::Parser::AST::Node)
+
+          children = node.children.map { |child| normalize_reparsed_ast(child) }
+          if node.begin_type? && children.one? && children.first.is_a?(::Parser::AST::Node)
+            children.first
+          else
+            node.updated(nil, children)
+          end
+        end
+
         def correct_unparenthesized(corrector, condition)
           corrector.wrap(condition, '(', ')')
         end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `Time.new` without arguments, which is an implicit way
+      # to retrieve the current system time. Prefer the more explicit `Time.now`.
+      #
+      # @example
+      #   # bad
+      #   Time.new
+      #
+      #   # good
+      #   Time.now
+      #
+      #   # good - `Time.new` with arguments constructs a specific time
+      #   Time.new(2026, 8, 19)
+      #
+      class TimeNow < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `Time.now` over `Time.new` to retrieve the current time.'
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        # @!method time_new?(node)
+        def_node_matcher :time_new?, <<~PATTERN
+          (call (const {nil? cbase} :Time) :new)
+        PATTERN
+
+        def on_send(node)
+          return unless time_new?(node)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node.loc.selector.join(node.source_range.end), 'now')
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -3,11 +3,11 @@
 module RuboCop
   module Cop
     module Style
-      # Newcomers to ruby applications may write top-level methods,
+      # Newcomers to Ruby applications may write top-level methods,
       # when ideally they should be organized in appropriate classes or modules.
       # This cop looks for definitions of top-level methods and warns about them.
       #
-      # However for ruby scripts it is perfectly fine to use top-level methods.
+      # However, for Ruby scripts it is perfectly fine to use top-level methods.
       # Hence this cop is disabled by default.
       #
       # @example

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

@@ -64,7 +64,7 @@ module RuboCop
 
         MSG = 'Useless trailing comma present in block arguments.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- a trailing comma needs an explicit parameter list
           # lambda literal (`->`) never has block arguments.
           return if node.send_node.lambda_literal?
           return unless useless_trailing_comma?(node)

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

@@ -45,6 +45,7 @@ module RuboCop
             corrector.insert_before(node.loc.end, "\n#{' ' * node.loc.keyword.column}")
           end
         end
+        alias on_defs on_def
 
         private
 

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

@@ -7,26 +7,26 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   a, b, _ = foo()
-      #   a, b, _, = foo()
-      #   a, _, _ = foo()
-      #   a, _, _, = foo()
+      #   a, b, _ = foo
+      #   a, b, _, = foo
+      #   a, _, _ = foo
+      #   a, _, _, = foo
       #
       #   # good
-      #   a, b, = foo()
-      #   a, = foo()
-      #   *a, b, _ = foo()
+      #   a, b, = foo
+      #   a, = foo
+      #   *a, b, _ = foo
       #   # => We need to know to not include 2 variables in a
-      #   a, *b, _ = foo()
-      #   # => The correction `a, *b, = foo()` is a syntax error
+      #   a, *b, _ = foo
+      #   # => The correction `a, *b, = foo` is a syntax error
       #
       # @example AllowNamedUnderscoreVariables: true (default)
       #   # good
-      #   a, b, _something = foo()
+      #   a, b, _something = foo
       #
       # @example AllowNamedUnderscoreVariables: false
       #   # bad
-      #   a, b, _something = foo()
+      #   a, b, _something = foo
       #
       class TrailingUnderscoreVariable < Base
         include SurroundingSpace
@@ -35,19 +35,20 @@ module RuboCop
 
         MSG = 'Do not use trailing `_`s in parallel assignment. Prefer `%<code>s`.'
         UNDERSCORE = '_'
+        ARRAY_OPENING = '['
         DISALLOW = %i[lvasgn splat].freeze
         private_constant :DISALLOW
 
         def on_masgn(node)
-          ranges = unneeded_ranges(node)
-
-          ranges.each do |range|
+          unneeded_ranges(node).each do |range, replacement|
+            closing = replacement == ARRAY_OPENING ? ']' : ''
             good_code = node.source
             offset = range.begin_pos - node.source_range.begin_pos
-            good_code[offset, range.size] = ''
+            good_code[offset, range.size] = replacement
 
-            add_offense(range, message: format(MSG, code: good_code)) do |corrector|
-              corrector.remove(range)
+            add_offense(range, message: format(MSG, code: "#{good_code}#{closing}")) do |corrector|
+              corrector.replace(range, replacement)
+              corrector.insert_after(node, closing) unless closing.empty?
             end
           end
         end
@@ -113,13 +114,14 @@ module RuboCop
 
           return unless first_offense
 
-          if unused_variables_only?(first_offense, variables)
-            return unused_range(node.type, mlhs_node, node.rhs)
-          end
-
-          return range_for_parentheses(first_offense, mlhs_node) if Util.parentheses?(mlhs_node)
+          return unused_range(node, mlhs_node) if unused_variables_only?(first_offense, variables)
 
-          range_between(first_offense.source_range.begin_pos, node.loc.operator.begin_pos)
+          range = if Util.parentheses?(mlhs_node)
+                    range_for_parentheses(first_offense, mlhs_node)
+                  else
+                    range_between(first_offense.source_range.begin_pos, node.loc.operator.begin_pos)
+                  end
+          [range, '']
         end
 
         def children_offenses(variables)
@@ -130,17 +132,18 @@ module RuboCop
           offense.source_range == variables.first.source_range
         end
 
-        def unused_range(node_type, mlhs_node, right)
-          start_range = mlhs_node.source_range.begin_pos
+        def unused_range(node, mlhs_node)
+          # `node` can be an `mlhs` when recursing into a nested destructuring
+          # group. Removing the group could leave a dangling comma or put
+          # something after a splat, so it is collapsed into a single `_`,
+          # which the parent group handles in turn.
+          return [mlhs_node.source_range, UNDERSCORE] unless node.masgn_type?
 
-          end_range = case node_type
-                      when :masgn
-                        right.source_range.begin_pos
-                      when :mlhs
-                        mlhs_node.source_range.end_pos
-                      end
+          rhs = node.rhs
+          range = range_between(mlhs_node.source_range.begin_pos, rhs.source_range.begin_pos)
 
-          range_between(start_range, end_range)
+          # `_, _ = 1, 2` cannot become `1, 2`, so the values become an array literal.
+          [range, rhs.array_type? && !rhs.bracketed? ? ARRAY_OPENING : '']
         end
 
         def range_for_parentheses(offense, left)

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

@@ -234,7 +234,7 @@ module RuboCop
         def autocorrect_class(corrector, node)
           kind = trivial_accessor_kind(node)
 
-          return unless names_match?(node) && kind
+          return unless names_match?(node) && !node.predicate_method? && kind
 
           indent = ' ' * node.loc.column
           corrector.replace(

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

@@ -14,11 +14,11 @@ module RuboCop
       #
       # `forbid_mixed_logical_operators` style forbids the use of more than one type
       # of logical operators. This makes the `unless` condition easier to read
-      # because either all conditions need to be met or any condition need to be met
+      # because either all conditions need to be met or any condition needs to be met
       # in order for the expression to be truthy or falsey.
       #
-      # `forbid_logical_operators` style forbids any use of logical operator.
-      # This makes it even more easy to read the `unless` condition as
+      # `forbid_logical_operators` style forbids any use of logical operators.
+      # This makes it even easier to read the `unless` condition as
       # there is only one condition in the expression.
       #
       # @example EnforcedStyle: forbid_mixed_logical_operators (default)

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

@@ -33,6 +33,7 @@ module RuboCop
 
         def on_while(node)
           return unless node.multiline? && node.do?
+          return if same_line_body?(node)
 
           add_offense(node.loc.begin, message: format(MSG, keyword: node.keyword)) do |corrector|
             do_range = node.condition.source_range.end.join(node.loc.begin)
@@ -41,6 +42,12 @@ module RuboCop
           end
         end
         alias on_until on_while
+
+        private
+
+        def same_line_body?(node)
+          node.body && same_line?(node.loc.begin, node.body)
+        end
       end
     end
   end

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

@@ -16,6 +16,11 @@ module RuboCop
       #   # good
       #   x += 1 while x < 10
       #
+      #   # good
+      #   while x < 10
+      #     y += 1 if x.odd?
+      #   end
+      #
       #   # bad
       #   until x > 10
       #     x += 1
@@ -24,6 +29,11 @@ module RuboCop
       #   # good
       #   x += 1 until x > 10
       #
+      #   # good
+      #   until x > 10
+      #     y += 1 unless x.even?
+      #   end
+      #
       #   # bad
       #   x += 100 while x < 500 # a long comment that makes code too long if it were a single line
       #
@@ -45,6 +55,12 @@ module RuboCop
           end
         end
         alias on_until on_while
+
+        private
+
+        def non_eligible_body?(body)
+          body&.conditional? || body&.kwbegin_type? || super
+        end
       end
     end
   end

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

@@ -93,6 +93,7 @@ module RuboCop
 
         def on_array(node)
           if bracketed_array_of?(:str, node)
+            return if node.values.any?(&:heredoc?)
             return if complex_content?(node.values)
             return if within_matrix_of_complex_content?(node)