rubocop 1.31.0 → 1.32.0

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

@@ -9,32 +9,15 @@ module RuboCop
       # On the other hand, `ENV.fetch` raises KeyError or returns the explicitly
       # specified default value.
       #
-      # When an `ENV[]` is the LHS of `||`, the autocorrect makes the RHS
-      # the default value of `ENV.fetch`.
-      #
       # @example
       #   # bad
       #   ENV['X']
-      #   ENV['X'] || 'string literal'
-      #   ENV['X'] || some_method
       #   x = ENV['X']
       #
-      #   ENV['X'] || y.map do |a|
-      #     puts a * 2
-      #   end
-      #
       #   # good
       #   ENV.fetch('X')
-      #   ENV.fetch('X', 'string literal')
-      #   ENV.fetch('X') { some_method }
       #   x = ENV.fetch('X')
       #
-      #   ENV.fetch('X') do
-      #     y.map do |a|
-      #       puts a * 2
-      #     end
-      #   end
-      #
       #   # also good
       #   !ENV['X']
       #   ENV['X'].some_method # (e.g. `.nil?`)
@@ -42,48 +25,20 @@ module RuboCop
       class FetchEnvVar < Base
         extend AutoCorrector
 
-        # rubocop:disable Layout/LineLength
-        MSG_DEFAULT_NIL = 'Use `ENV.fetch(%<key>s)` or `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
-        MSG_DEFAULT_RHS_SECOND_ARG_OF_FETCH = 'Use `ENV.fetch(%<key>s, %<default>s)` instead of `ENV[%<key>s] || %<default>s`.'
-        MSG_DEFAULT_RHS_SINGLE_LINE_BLOCK = 'Use `ENV.fetch(%<key>s) { %<default>s }` instead of `ENV[%<key>s] || %<default>s`.'
-        MSG_DEFAULT_RHS_MULTILINE_BLOCK = 'Use `ENV.fetch(%<key>s)` with a block containing `%<default>s ...`'
-        # rubocop:enable Layout/LineLength
+        MSG = 'Use `ENV.fetch(%<key>s)` or `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
 
         # @!method env_with_bracket?(node)
         def_node_matcher :env_with_bracket?, <<~PATTERN
           (send (const nil? :ENV) :[] $_)
         PATTERN
 
-        # @!method operand_of_or?(node)
-        def_node_matcher :operand_of_or?, <<~PATTERN
-          (^or ...)
-        PATTERN
-
-        # @!method block_control?(node)
-        def_node_matcher :block_control?, <<~PATTERN
-          ({next | break | retry | redo})
-        PATTERN
-
-        # @!method offensive_nodes(node)
-        def_node_search :offensive_nodes, <<~PATTERN
-          [#env_with_bracket? #offensive?]
-        PATTERN
-
         def on_send(node)
           env_with_bracket?(node) do |name_node|
             break unless offensive?(node)
 
-            if operand_of_or?(node)
-              target_node = offensive_nodes(or_chain_root(node)).to_a.last
-              target_name_node = env_with_bracket?(target_node)
-
-              if default_to_rhs?(target_node)
-                default_rhs(target_node, target_name_node)
-              else
-                default_nil(target_node, target_name_node)
-              end
-            else
-              default_nil(node, name_node)
+            message = format(MSG, key: name_node.source)
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, new_code(name_node))
             end
           end
         end
@@ -130,17 +85,6 @@ module RuboCop
           !(allowed_var?(node) || allowable_use?(node))
         end
 
-        def or_chain_root(node)
-          while operand_of_or?(ancestor_or ||= node.parent)
-            ancestor_or = ancestor_or.parent
-          end
-          ancestor_or
-        end
-
-        def default_to_rhs?(node)
-          operand_of_or?(node) && !right_end_of_or_chains?(node) && rhs_can_be_default_value?(node)
-        end
-
         # Check if the node is a receiver and receives a message with dot syntax.
         def message_chained_with_dot?(node)
           return false if node.root?
@@ -157,8 +101,9 @@ module RuboCop
         #   it simply checks whether the variable is set.
         # - Receiving a message with dot syntax, e.g. `ENV['X'].nil?`.
         # - `ENV['key']` assigned by logical AND/OR assignment.
+        # - `ENV['key']` is the LHS of a `||`.
         def allowable_use?(node)
-          used_as_flag?(node) || message_chained_with_dot?(node) || assigned?(node)
+          used_as_flag?(node) || message_chained_with_dot?(node) || assigned?(node) || or_lhs?(node)
         end
 
         # The following are allowed cases:
@@ -172,127 +117,15 @@ module RuboCop
           node == lhs
         end
 
-        def left_end_of_or_chains?(node)
-          return false unless operand_of_or?(node)
-
-          node.parent.lhs == node
-        end
-
-        def right_end_of_or_chains?(node)
-          !(left_end_of_or_chains?(node) || node.parent&.parent&.or_type?)
-        end
-
-        def conterpart_rhs_of(node)
-          left_end_of_or_chains?(node) ? node.parent.rhs : node.parent.parent.rhs
-        end
-
-        def rhs_can_be_default_value?(node)
-          !rhs_is_block_control?(node)
-        end
+        def or_lhs?(node)
+          return false unless (parent = node.parent)&.or_type?
 
-        def rhs_is_block_control?(node)
-          block_control?(conterpart_rhs_of(node))
+          parent.lhs == node || parent.parent&.or_type?
         end
 
-        def new_code_default_nil(name_node)
+        def new_code(name_node)
           "ENV.fetch(#{name_node.source}, nil)"
         end
-
-        def new_code_default_rhs_single_line(node, name_node)
-          parent = node.parent
-          if parent.rhs.basic_literal?
-            "ENV.fetch(#{name_node.source}, #{parent.rhs.source})"
-          else
-            "ENV.fetch(#{name_node.source}) { #{parent.rhs.source} }"
-          end
-        end
-
-        def new_code_default_rhs_multiline(node, name_node)
-          env_indent = indent(node.parent)
-          default = node.parent.rhs.source.split("\n").map do |line|
-            "#{env_indent}#{line}"
-          end.join("\n")
-          <<~NEW_CODE.chomp
-            ENV.fetch(#{name_node.source}) do
-            #{configured_indentation}#{default}
-            #{env_indent}end
-          NEW_CODE
-        end
-
-        def new_code_default_rhs(node, name_node)
-          if node.parent.rhs.single_line?
-            new_code_default_rhs_single_line(node, name_node)
-          else
-            new_code_default_rhs_multiline(node, name_node)
-          end
-        end
-
-        def default_rhs(node, name_node)
-          if left_end_of_or_chains?(node)
-            default_rhs_in_same_or(node, name_node)
-          else
-            default_rhs_in_outer_or(node, name_node)
-          end
-        end
-
-        # Adds an offense and sets `nil` to the default value of `ENV.fetch`.
-        # `ENV['X']` --> `ENV.fetch('X', nil)`
-        def default_nil(node, name_node)
-          message = format(MSG_DEFAULT_NIL, key: name_node.source)
-
-          add_offense(node, message: message) do |corrector|
-            corrector.replace(node, new_code_default_nil(name_node))
-          end
-        end
-
-        # Adds an offense and makes the RHS the default value of `ENV.fetch`.
-        # `ENV['X'] || y` --> `ENV.fetch('X') { y }`
-        def default_rhs_in_same_or(node, name_node)
-          template = message_template_for(node.parent.rhs)
-          message = format(template,
-                           key: name_node.source,
-                           default: first_line_of(node.parent.rhs.source))
-
-          add_offense(node, message: message) do |corrector|
-            corrector.replace(node.parent, new_code_default_rhs(node, name_node))
-          end
-        end
-
-        # Adds an offense and makes the RHS the default value of `ENV.fetch`.
-        # `z || ENV['X'] || y` --> `z || ENV.fetch('X') { y }`
-        def default_rhs_in_outer_or(node, name_node)
-          parent = node.parent
-          grand_parent = parent.parent
-
-          template = message_template_for(grand_parent.rhs)
-          message = format(template,
-                           key: name_node.source,
-                           default: first_line_of(grand_parent.rhs.source))
-
-          add_offense(node, message: message) do |corrector|
-            lhs_code = parent.lhs.source
-            rhs_code = new_code_default_rhs(parent, name_node)
-            corrector.replace(grand_parent, "#{lhs_code} || #{rhs_code}")
-          end
-        end
-
-        def message_template_for(rhs)
-          if rhs.multiline?
-            MSG_DEFAULT_RHS_MULTILINE_BLOCK
-          elsif rhs.basic_literal?
-            MSG_DEFAULT_RHS_SECOND_ARG_OF_FETCH
-          else
-            MSG_DEFAULT_RHS_SINGLE_LINE_BLOCK
-          end
-        end
-
-        def configured_indentation
-          ' ' * (config.for_cop('Layout/IndentationWidth')['Width'] || 2)
-        end
-
-        def first_line_of(source)
-          source.split("\n").first
-        end
       end
     end
   end

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

@@ -12,6 +12,7 @@ module RuboCop
       # to encoded URLs or Date/Time formatting strings.
       #
       # This cop can be customized ignored methods with `IgnoredMethods`.
+      # By default, there are no methods to ignored.
       #
       # @example EnforcedStyle: annotated (default)
       #
@@ -61,6 +62,11 @@ module RuboCop
       #   # good
       #   format('%06d', 10)
       #
+      # @example IgnoredMethods: [] (default)
+      #
+      #   # bad
+      #   redirect('foo/%{bar_id}')
+      #
       # @example IgnoredMethods: [redirect]
       #
       #   # good

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

@@ -144,7 +144,7 @@ module RuboCop
             return key.join(', ')
           end
 
-          key.source
+          key.literal? ? key.source : "*#{key.source}"
         end
 
         def decorate_source(value)

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

@@ -6,6 +6,8 @@ module RuboCop
       # Checks for redundant `if` with boolean literal branches.
       # It checks only conditions to return boolean value (`true` or `false`) for safe detection.
       # The conditions to be checked are comparison methods, predicate methods, and double negative.
+      # `nonzero?` method is allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @safety
       #   Autocorrection is unsafe because there is no guarantee that all predicate methods

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

@@ -5,12 +5,24 @@ module RuboCop
     module Style
       # Checks for unwanted parentheses in parameterless method calls.
       #
+      # This cop can be customized ignored methods with `IgnoredMethods`.
+      # By default, there are no methods to ignored.
+      #
       # @example
       #   # bad
       #   object.some_method()
       #
       #   # good
       #   object.some_method
+      #
+      # @example IgnoredMethods: [] (default)
+      #   # bad
+      #   object.foo()
+      #
+      # @example IgnoredMethods: [foo]
+      #   # good
+      #   object.foo()
+      #
       class MethodCallWithoutArgsParentheses < Base
         include IgnoredMethods
         extend AutoCorrector

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

@@ -117,10 +117,10 @@ module RuboCop
         end
 
         def check_module_function(nodes)
-          private_directive = nodes.any? { |node| private_directive?(node) }
+          return if nodes.any? { |node| private_directive?(node) }
 
           nodes.each do |node|
-            yield node if extend_self_node?(node) && !private_directive
+            yield node if extend_self_node?(node)
           end
         end
 

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

@@ -5,6 +5,10 @@ module RuboCop
     module Style
       # Checks for unparenthesized method calls in the argument list
       # of a parenthesized method call.
+      # `be`, `be_a`, `be_an`, `be_between`, `be_falsey`, `be_kind_of`, `be_instance_of`,
+      # `be_truthy`, `be_within`, `eq`, `eql`, `end_with`, `include`, `match`, `raise_error`,
+      # `respond_to`, and `start_with` methods are allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @example
       #   # good
@@ -12,6 +16,11 @@ module RuboCop
       #
       #   # bad
       #   method1(method2 arg)
+      #
+      # @example AllowedMethods: [foo]
+      #   # good
+      #   method1(foo arg)
+      #
       class NestedParenthesizedCalls < Base
         include RangeHelp
         include AllowedMethods

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

@@ -6,13 +6,16 @@ module RuboCop
       # Checks for usage of comparison operators (`==`,
       # `>`, `<`) to test numbers as zero, positive, or negative.
       # These can be replaced by their respective predicate methods.
-      # The cop can also be configured to do the reverse.
+      # This cop can also be configured to do the reverse.
       #
-      # The cop disregards `#nonzero?` as its value is truthy or falsey,
+      # This cop can be customized ignored methods with `IgnoredMethods`.
+      # By default, there are no methods to ignored.
+      #
+      # This cop disregards `#nonzero?` as its value is truthy or falsey,
       # but not `true` and `false`, and thus not always interchangeable with
       # `!= 0`.
       #
-      # The cop ignores comparisons to global variables, since they are often
+      # This cop ignores comparisons to global variables, since they are often
       # populated with objects which can be compared with integers, but are
       # not themselves `Integer` polymorphic.
       #
@@ -23,29 +26,40 @@ module RuboCop
       #
       # @example EnforcedStyle: predicate (default)
       #   # bad
-      #
       #   foo == 0
       #   0 > foo
       #   bar.baz > 0
       #
       #   # good
-      #
       #   foo.zero?
       #   foo.negative?
       #   bar.baz.positive?
       #
       # @example EnforcedStyle: comparison
       #   # bad
-      #
       #   foo.zero?
       #   foo.negative?
       #   bar.baz.positive?
       #
       #   # good
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
+      #
+      # @example IgnoredMethods: [] (default) with EnforcedStyle: predicate
+      #   # bad
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
       #
+      # @example IgnoredMethods: [==] with EnforcedStyle: predicate
+      #   # good
       #   foo == 0
+      #
+      #   # bad
       #   0 > foo
       #   bar.baz > 0
+      #
       class NumericPredicate < Base
         include ConfigurableEnforcedStyle
         include IgnoredMethods

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

@@ -81,7 +81,8 @@ module RuboCop
         end
 
         def like_method_argument_parentheses?(node)
-          node.send_type? && node.arguments.size == 1 && !node.arithmetic_operation?
+          node.send_type? && node.arguments.one? &&
+            !node.arithmetic_operation? && node.first_argument.begin_type?
         end
 
         def empty_parentheses?(node)

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

@@ -64,12 +64,14 @@ module RuboCop
           # Make the obvious check first
           return unless processed_source.raw_source.include?(';')
 
-          each_semicolon { |line, column| register_semicolon(line, column, false) }
+          each_semicolon do |line, column, token_before_semicolon|
+            register_semicolon(line, column, false, token_before_semicolon)
+          end
         end
 
         def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            yield line, tokens.last.column if tokens.last.semicolon?
+            yield line, tokens.last.column, tokens[-2] if tokens.last.semicolon?
             yield line, tokens.first.column if tokens.first.semicolon?
           end
         end
@@ -78,13 +80,21 @@ module RuboCop
           processed_source.tokens.group_by(&:line)
         end
 
-        def register_semicolon(line, column, after_expression)
+        def register_semicolon(line, column, after_expression, token_before_semicolon = nil)
           range = source_range(processed_source.buffer, line, column)
 
           add_offense(range) do |corrector|
             if after_expression
               corrector.replace(range, "\n")
             else
+              # Prevents becoming one range instance with subsequent line when endless range
+              # without parentheses.
+              # See: https://github.com/rubocop/rubocop/issues/10791
+              if token_before_semicolon&.regexp_dots?
+                range_node = find_range_node(token_before_semicolon)
+                corrector.wrap(range_node, '(', ')') if range_node
+              end
+
               corrector.remove(range)
             end
           end
@@ -103,6 +113,20 @@ module RuboCop
             yield Regexp.last_match.begin(0)
           end
         end
+
+        def find_range_node(token_before_semicolon)
+          range_nodes.detect do |range_node|
+            range_node.source_range.contains?(token_before_semicolon.pos)
+          end
+        end
+
+        def range_nodes
+          return @range_nodes if instance_variable_defined?(:@range_nodes)
+
+          ast = processed_source.ast
+          @range_nodes = ast.range_type? ? [ast] : []
+          @range_nodes.concat(ast.each_descendant(:irange, :erange).to_a)
+        end
       end
     end
   end

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

@@ -39,7 +39,7 @@ module RuboCop
         minimum_target_ruby_version 2.0
 
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'
-        ARRAY_MSG = 'Use `%<prefer>s` for an array of symbols.'
+        ARRAY_MSG = 'Use %<prefer>s for an array of symbols.'
 
         class << self
           attr_accessor :largest_brackets
@@ -74,8 +74,7 @@ module RuboCop
               to_symbol_literal(c.value.to_s)
             end
           end
-
-          "[#{syms.join(', ')}]"
+          build_bracketed_array_with_appropriate_whitespace(elements: syms, node: node)
         end
 
         def to_symbol_literal(string)

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

@@ -7,6 +7,8 @@ module RuboCop
       #
       # If you prefer a style that allows block for method with arguments,
       # please set `true` to `AllowMethodsWithArguments`.
+      # respond_to , and `define_method?` methods are ignored by default.
+      # These are customizable with `IgnoredMethods` option.
       #
       # @safety
       #   This cop is unsafe because `proc`s and blocks work differently
@@ -68,6 +70,12 @@ module RuboCop
       #     s.upcase # some comment
       #     # some comment
       #   end
+      #
+      # @example IgnoredMethods: [respond_to, define_method] (default)
+      #   # good
+      #   respond_to { |foo| foo.bar }
+      #   define_method(:foo) { |foo| foo.bar }
+      #
       class SymbolProc < Base
         include CommentsHelp
         include RangeHelp
@@ -81,7 +89,7 @@ module RuboCop
         def_node_matcher :proc_node?, '(send (const {nil? cbase} :Proc) :new)'
 
         # @!method symbol_proc_receiver?(node)
-        def_node_matcher :symbol_proc_receiver?, '{(send ...) (super ...) zsuper}'
+        def_node_matcher :symbol_proc_receiver?, '{(call ...) (super ...) zsuper}'
 
         # @!method symbol_proc?(node)
         def_node_matcher :symbol_proc?, <<~PATTERN

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

@@ -5,6 +5,9 @@ module RuboCop
     module Style
       # Looks for trivial reader/writer methods, that could
       # have been created with the attr_* family of functions automatically.
+      # `to_ary`, `to_a`, `to_c`, `to_enum`, `to_h`, `to_hash`, `to_i`, `to_int`, `to_io`,
+      # `to_open`, `to_path`, `to_proc`, `to_r`, `to_regexp`, `to_str`, `to_s`, and `to_sym` methods
+      # are allowed by default. These are customizable with `AllowedMethods` option.
       #
       # @example
       #   # bad

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

@@ -44,7 +44,7 @@ module RuboCop
         extend AutoCorrector
 
         PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'
-        ARRAY_MSG = 'Use `%<prefer>s` for an array of words.'
+        ARRAY_MSG = 'Use %<prefer>s for an array of words.'
 
         class << self
           attr_accessor :largest_brackets
@@ -92,8 +92,7 @@ module RuboCop
               to_string_literal(word.children[0])
             end
           end
-
-          "[#{words.join(', ')}]"
+          build_bracketed_array_with_appropriate_whitespace(elements: words, node: node)
         end
       end
     end

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'colorizable'
+
 module RuboCop
   module Formatter
     # A basic formatter that displays only files with offenses.

data/lib/rubocop/formatter.rb

@@ -2,30 +2,30 @@
 
 module RuboCop
   module Formatter
-    autoload :BaseFormatter, 'rubocop/formatter/base_formatter'
-    autoload :SimpleTextFormatter, 'rubocop/formatter/simple_text_formatter'
+    require_relative 'formatter/text_util'
+
+    require_relative 'formatter/base_formatter'
+    require_relative 'formatter/simple_text_formatter'
     # relies on simple text
-    autoload :ClangStyleFormatter, 'rubocop/formatter/clang_style_formatter'
-    autoload :DisabledConfigFormatter, 'rubocop/formatter/disabled_config_formatter'
-    autoload :EmacsStyleFormatter, 'rubocop/formatter/emacs_style_formatter'
-    autoload :FileListFormatter, 'rubocop/formatter/file_list_formatter'
-    autoload :FuubarStyleFormatter, 'rubocop/formatter/fuubar_style_formatter'
-    autoload :GitHubActionsFormatter, 'rubocop/formatter/git_hub_actions_formatter'
-    autoload :HTMLFormatter, 'rubocop/formatter/html_formatter'
-    autoload :JSONFormatter, 'rubocop/formatter/json_formatter'
-    autoload :JUnitFormatter, 'rubocop/formatter/junit_formatter'
-    autoload :MarkdownFormatter, 'rubocop/formatter/markdown_formatter'
-    autoload :OffenseCountFormatter, 'rubocop/formatter/offense_count_formatter'
-    autoload :ProgressFormatter, 'rubocop/formatter/progress_formatter'
-    autoload :QuietFormatter, 'rubocop/formatter/quiet_formatter'
-    autoload :TapFormatter, 'rubocop/formatter/tap_formatter'
-    autoload :WorstOffendersFormatter, 'rubocop/formatter/worst_offenders_formatter'
-    autoload :PacmanFormatter, 'rubocop/formatter/pacman_formatter'
+    require_relative 'formatter/clang_style_formatter'
+    require_relative 'formatter/disabled_config_formatter'
+    require_relative 'formatter/emacs_style_formatter'
+    require_relative 'formatter/file_list_formatter'
+    require_relative 'formatter/fuubar_style_formatter'
+    require_relative 'formatter/git_hub_actions_formatter'
+    require_relative 'formatter/html_formatter'
+    require_relative 'formatter/json_formatter'
+    require_relative 'formatter/junit_formatter'
+    require_relative 'formatter/markdown_formatter'
+    require_relative 'formatter/offense_count_formatter'
+    require_relative 'formatter/progress_formatter'
+    require_relative 'formatter/quiet_formatter'
+    require_relative 'formatter/tap_formatter'
+    require_relative 'formatter/worst_offenders_formatter'
+    require_relative 'formatter/pacman_formatter'
     # relies on progress formatter
-    autoload :AutoGenConfigFormatter, 'rubocop/formatter/auto_gen_config_formatter'
-    autoload :Colorizable, 'rubocop/formatter/colorizable'
+    require_relative 'formatter/auto_gen_config_formatter'
 
     require_relative 'formatter/formatter_set'
-    require_relative 'formatter/text_util'
   end
 end

data/lib/rubocop/options.rb

@@ -421,12 +421,9 @@ module RuboCop
     end
 
     def invalid_arguments_for_parallel
-      [('--auto-gen-config'    if @options.key?(:auto_gen_config)),
-       ('-F/--fail-fast'       if @options.key?(:fail_fast)),
-       ('-x/--fix-layout'      if @options.key?(:fix_layout)),
-       ('-a/--autocorrect'     if @options.key?(:safe_autocorrect)),
-       ('-A/--autocorrect-all' if @options.key?(:autocorrect_all)),
-       ('--cache false'        if @options > { cache: 'false' })].compact
+      [('--auto-gen-config' if @options.key?(:auto_gen_config)),
+       ('-F/--fail-fast'    if @options.key?(:fail_fast)),
+       ('--cache false'     if @options > { cache: 'false' })].compact
     end
 
     def only_includes_redundant_disable?

data/lib/rubocop/rake_task.rb

@@ -73,11 +73,15 @@ module RuboCop
       namespace(name) do
         # rubocop:todo Naming/InclusiveLanguage
         task(:auto_correct, *args) do
+          require 'rainbow'
           warn Rainbow(
             'rubocop:auto_correct task is deprecated; ' \
             'use rubocop:autocorrect task or rubocop:autocorrect_all task instead.'
           ).yellow
-          ::Rake::Task['rubocop:autocorrect'].invoke
+          RakeFileUtils.verbose(verbose) do
+            yield(*[self, task_args].slice(0, task_block.arity)) if task_block
+            perform('--autocorrect')
+          end
         end
         # rubocop:enable Naming/InclusiveLanguage