rubocop 1.31.2 → 1.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 998eb88b2df9c70d2b432d79cd43901b7e72d33714c2a1ac1e1ebf3f64d75b85
-  data.tar.gz: 335fd1c15204af498ebee7200f2958902ccfd96923f9530b589517a857967a72
+  metadata.gz: 270faf06487f8a915ef6293944db136da6fb51ec09b5613be4b848a471c858bb
+  data.tar.gz: 1c61746959019453862c2e90b8d3250ce3f9815b1eae286f1fd5b73fb267a1cb
 SHA512:
-  metadata.gz: ceda90af46b2317f03cc4a86ea8aba7c63a96f12d55d6bea533ae2537d68bdc75a647f2d2a1f5103c1799f2dda6ec0f923351891050915a237919df241d39e1e
-  data.tar.gz: 8a0c5273cf612ca4717d619ce33b37dc2206beb4c6d247c3b501a67ec364861e18c24878b513c37b67e499084162cb70ab618e6e090f7876fda8da37c93d45d1
+  metadata.gz: 86966e7ff42d0f514a447c8313cc9bdc13020ec1d375e584dba8ebae5bb535a1238380a57d55dfd697c735b3f9259f59939563f4b504f08570304e4ec1c2c7af
+  data.tar.gz: ce35c98b8b51b8b59c6c2aeac880a0618067a68f7080a2e44408a7e283471b2b57f84e57c127144632b61eaa8edf6e4369d4702c2baa222cb3b37fad38606bd5

data/README.md

@@ -53,7 +53,7 @@ To prevent an unwanted RuboCop update you might want to use a conservative versi
 in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 1.31', require: false
+gem 'rubocop', '~> 1.32', require: false
 ```
 
 See [our versioning policy](https://docs.rubocop.org/rubocop/versioning.html) for further details.

data/config/default.yml

@@ -977,6 +977,11 @@ Layout/LineContinuationLeadingSpace:
   AutoCorrect: false
   SafeAutoCorrect: false
   VersionAdded: '1.31'
+  VersionChanged: '1.32'
+  EnforcedStyle: trailing
+  SupportedStyles:
+    - leading
+    - trailing
 
 Layout/LineContinuationSpacing:
   Description: 'Checks the spacing in front of backslash in line continuations.'
@@ -1153,6 +1158,13 @@ Layout/MultilineMethodDefinitionBraceLayout:
     - new_line
     - same_line
 
+Layout/MultilineMethodParameterLineBreaks:
+  Description: >-
+                 Checks that each parameter in a multi-line method definition
+                 starts on a separate line.
+  Enabled: false
+  VersionAdded: '1.32'
+
 Layout/MultilineOperationIndentation:
   Description: >-
                  Checks indentation of binary operations that span more than
@@ -2128,6 +2140,11 @@ Lint/RequireParentheses:
   Enabled: true
   VersionAdded: '0.18'
 
+Lint/RequireRangeParentheses:
+  Description: 'Checks that a range literal is enclosed in parentheses when the end of the range is at a line break.'
+  Enabled: pending
+  VersionAdded: '1.32'
+
 Lint/RequireRelativeSelfPath:
   Description: 'Checks for uses a file requiring itself with `require_relative`.'
   Enabled: pending
@@ -3495,6 +3512,12 @@ Style/EmptyElse:
     - empty
     - nil
     - both
+  AllowComments: false
+
+Style/EmptyHeredoc:
+  Description: 'Checks for using empty heredoc to reduce redundancy.'
+  Enabled: pending
+  VersionAdded: '1.32'
 
 Style/EmptyLambdaParameter:
   Description: 'Omit parens for empty lambda parameters.'

data/lib/rubocop/cli.rb

@@ -12,6 +12,7 @@ module RuboCop
       color debug display_style_guide display_time display_only_fail_level_offenses
       display_only_failed except extra_details fail_level fix_layout format
       ignore_disable_comments lint only only_guide_cops require safe
+      autocorrect safe_autocorrect autocorrect_all
     ].freeze
 
     class Finished < StandardError; end

data/lib/rubocop/config.rb

@@ -25,7 +25,7 @@ module RuboCop
       @loaded_path = loaded_path
       @for_cop = Hash.new do |h, cop|
         qualified_cop_name = Cop::Registry.qualified_cop_name(cop, loaded_path)
-        cop_options = self[qualified_cop_name] || {}
+        cop_options = self[qualified_cop_name].dup || {}
         cop_options['Enabled'] = enable_cop?(qualified_cop_name, cop_options)
         h[cop] = cop_options
       end

data/lib/rubocop/cop/internal_affairs/useless_restrict_on_send.rb

@@ -33,7 +33,13 @@ module RuboCop
         MSG = 'Useless `RESTRICT_ON_SEND` is defined.'
 
         # @!method defined_send_callback?(node)
-        def_node_search :defined_send_callback?, '(def {:on_send :after_send} ...)'
+        def_node_search :defined_send_callback?, <<~PATTERN
+          {
+            (def {:on_send :after_send} ...)
+            (alias (sym {:on_send :after_send}) _source ...)
+            (send nil? :alias_method {(sym {:on_send :after_send}) (str {"on_send" "after_send"})} _source ...)
+          }
+        PATTERN
 
         def on_casgn(node)
           return if !restrict_on_send?(node) || defined_send_callback?(node.parent)

data/lib/rubocop/cop/layout/line_continuation_leading_space.rb

@@ -4,9 +4,10 @@ module RuboCop
   module Cop
     module Layout
       # Checks that strings broken over multiple lines (by a backslash) contain
-      # trailing spaces instead of leading spaces.
+      # trailing spaces instead of leading spaces (default) or leading spaces
+      # instead of trailing spaces.
       #
-      # @example
+      # @example EnforcedStyle: trailing (default)
       #   # bad
       #   'this text contains a lot of' \
       #   '               spaces'
@@ -23,18 +24,38 @@ module RuboCop
       #   'this text is too ' \
       #   'long'
       #
+      # @example EnforcedStyle: leading
+      #   # bad
+      #   'this text contains a lot of               ' \
+      #   'spaces'
+      #
+      #   # good
+      #   'this text contains a lot of' \
+      #   '               spaces'
+      #
+      #   # bad
+      #   'this text is too ' \
+      #   'long'
+      #
+      #   # good
+      #   'this text is too' \
+      #   ' long'
       class LineContinuationLeadingSpace < Base
         include RangeHelp
 
-        MSG = 'Move leading spaces to the end of previous line.'
-
         def on_dstr(node)
-          range_start = node.loc.expression.begin_pos - node.loc.expression.column
+          end_of_first_line = node.loc.expression.begin_pos - node.loc.expression.column
 
           raw_lines(node).each_cons(2) do |raw_line_one, raw_line_two|
-            range_start += raw_line_one.length
+            end_of_first_line += raw_line_one.length
 
-            investigate(raw_line_one, raw_line_two, range_start)
+            next unless continuation?(raw_line_one)
+
+            if enforced_style_leading?
+              investigate_leading_style(raw_line_one, end_of_first_line)
+            else
+              investigate_trailing_style(raw_line_two, end_of_first_line)
+            end
           end
         end
 
@@ -44,24 +65,47 @@ module RuboCop
           processed_source.raw_source.lines[node.first_line - 1, line_range(node).size]
         end
 
-        def investigate(first_line, second_line, range_start)
-          return unless continuation?(first_line)
+        def investigate_leading_style(first_line, end_of_first_line)
+          matches = first_line.match(/(?<trailing_spaces>\s+)(?<ending>['"]\s*\\\n)/)
+          return if matches.nil?
 
-          matches = second_line.match(/\A(?<indent>\s*['"])(?<leading_spaces>\s+)/)
+          add_offense(leading_offense_range(end_of_first_line, matches))
+        end
+
+        def investigate_trailing_style(second_line, end_of_first_line)
+          matches = second_line.match(/\A(?<beginning>\s*['"])(?<leading_spaces>\s+)/)
           return if matches.nil?
 
-          add_offense(offense_range(range_start, matches))
+          add_offense(trailing_offense_range(end_of_first_line, matches))
         end
 
         def continuation?(line)
           line.end_with?("\\\n")
         end
 
-        def offense_range(range_start, matches)
-          begin_pos = range_start + matches[:indent].length
+        def leading_offense_range(end_of_first_line, matches)
+          end_pos = end_of_first_line - matches[:ending].length
+          begin_pos = end_pos - matches[:trailing_spaces].length
+          range_between(begin_pos, end_pos)
+        end
+
+        def trailing_offense_range(end_of_first_line, matches)
+          begin_pos = end_of_first_line + matches[:beginning].length
           end_pos = begin_pos + matches[:leading_spaces].length
           range_between(begin_pos, end_pos)
         end
+
+        def message(_range)
+          if enforced_style_leading?
+            'Move trailing spaces to the start of next line.'
+          else
+            'Move leading spaces to the end of previous line.'
+          end
+        end
+
+        def enforced_style_leading?
+          cop_config['EnforcedStyle'] == 'leading'
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/line_length.rb

@@ -37,6 +37,7 @@ module RuboCop
       # * MultilineHashBraceLayout
       # * MultilineHashKeyLineBreaks
       # * MultilineMethodArgumentLineBreaks
+      # * MultilineMethodParameterLineBreaks
       # * ParameterAlignment
       #
       # Together, these cops will pretty print hashes, arrays,
@@ -79,6 +80,7 @@ module RuboCop
         alias on_array on_potential_breakable_node
         alias on_hash on_potential_breakable_node
         alias on_send on_potential_breakable_node
+        alias on_def on_potential_breakable_node
 
         def on_new_investigation
           check_for_breakable_semicolons(processed_source)

data/lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb

@@ -6,7 +6,7 @@ module RuboCop
       # Ensures that each argument in a multi-line method call
       # starts on a separate line.
       #
-      # NOTE: this cop does not move the first argument, if you want that to
+      # NOTE: This cop does not move the first argument, if you want that to
       # be on a separate line, see `Layout/FirstMethodArgumentLineBreak`.
       #
       # @example
@@ -22,6 +22,9 @@ module RuboCop
       #     b,
       #     c
       #   )
+      #
+      #   # good
+      #   foo(a, b, c)
       class MultilineMethodArgumentLineBreaks < Base
         include MultilineElementLineBreaks
         extend AutoCorrector

data/lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Ensures that each parameter in a multi-line method definition
+      # starts on a separate line.
+      #
+      # NOTE: This cop does not move the first argument, if you want that to
+      # be on a separate line, see `Layout/FirstMethodParameterLineBreak`.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo(a, b,
+      #     c
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b,
+      #     c
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(a, b, c)
+      #   end
+      class MultilineMethodParameterLineBreaks < Base
+        include MultilineElementLineBreaks
+        extend AutoCorrector
+
+        MSG = 'Each parameter in a multi-line method definition must start on a separate line.'
+
+        def on_def(node)
+          return if node.arguments.empty?
+
+          check_line_breaks(node, node.arguments)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/ambiguous_block_association.rb

@@ -7,6 +7,7 @@ module RuboCop
       # when param passed without parentheses.
       #
       # This cop can customize ignored methods with `IgnoredMethods`.
+      # By default, there are no methods to ignored.
       #
       # @example
       #
@@ -29,10 +30,16 @@ module RuboCop
       #   # Lambda arguments require no disambiguation
       #   foo = ->(bar) { bar.baz }
       #
+      # @example IgnoredMethods: [] (default)
+      #
+      #   # bad
+      #   expect { do_something }.to change { object.attribute }
+      #
       # @example IgnoredMethods: [change]
       #
       #   # good
       #   expect { do_something }.to change { object.attribute }
+      #
       class AmbiguousBlockAssociation < Base
         include IgnoredMethods
 

data/lib/rubocop/cop/lint/deprecated_class_methods.rb

@@ -8,22 +8,22 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   File.exists?(some_path)
       #   Dir.exists?(some_path)
       #   iterator?
       #   ENV.freeze # Calling `Env.freeze` raises `TypeError` since Ruby 2.7.
+      #   ENV.clone
+      #   ENV.dup # Calling `Env.dup` raises `TypeError` since Ruby 3.1.
       #   Socket.gethostbyname(host)
       #   Socket.gethostbyaddr(host)
       #
-      # @example
-      #
       #   # good
-      #
       #   File.exist?(some_path)
       #   Dir.exist?(some_path)
       #   block_given?
       #   ENV # `ENV.freeze` cannot prohibit changes to environment variables.
+      #   ENV.to_h
+      #   ENV.to_h # `ENV.dup` cannot dup `ENV`, use `ENV.to_h` to get a copy of `ENV` as a hash.
       #   Addrinfo.getaddrinfo(nodename, service)
       #   Addrinfo.tcp(host, port).getnameinfo
       class DeprecatedClassMethods < Base
@@ -111,6 +111,12 @@ module RuboCop
           DeprecatedClassMethod.new(:freeze, class_constant: :ENV) =>
             Replacement.new(nil, class_constant: :ENV),
 
+          DeprecatedClassMethod.new(:clone, class_constant: :ENV) =>
+            Replacement.new(:to_h, class_constant: :ENV),
+
+          DeprecatedClassMethod.new(:dup, class_constant: :ENV) =>
+            Replacement.new(:to_h, class_constant: :ENV),
+
           DeprecatedClassMethod.new(:gethostbyaddr, class_constant: :Socket, correctable: false) =>
             Replacement.new(:getnameinfo, class_constant: :Addrinfo, instance_method: true),
 

data/lib/rubocop/cop/lint/non_atomic_file_operation.rb

@@ -25,30 +25,37 @@ module RuboCop
       #   to be strictly equivalent to that before the replacement.
       #
       # @example
-      #   # bad
-      #   unless FileTest.exist?(path)
-      #     FileUtils.makedirs(path)
+      #   # bad - race condition with another process may result in an error in `mkdir`
+      #   unless Dir.exist?(path)
+      #     FileUtils.mkdir(path)
       #   end
       #
-      #   if FileTest.exist?(path)
+      #   # good - atomic and idempotent creation
+      #   FileUtils.mkdir_p(path)
+      #
+      #   # bad - race condition with another process may result in an error in `remove`
+      #   if File.exist?(path)
       #     FileUtils.remove(path)
       #   end
       #
-      #   # good
-      #   FileUtils.mkdir_p(path)
-      #
-      #   FileUtils.rm_rf(path)
+      #   # good - atomic and idempotent removal
+      #   FileUtils.rm_f(path)
       #
       class NonAtomicFileOperation < Base
         extend AutoCorrector
         include Alignment
         include RangeHelp
 
-        MSG = 'Remove unnecessary existence checks `%<receiver>s.%<method_name>s`.'
-        MAKE_METHODS = %i[makedirs mkdir mkdir_p mkpath].freeze
-        REMOVE_METHODS = %i[remove remove_dir remove_entry remove_entry_secure delete unlink
-                            remove_file rm rm_f rm_r rm_rf rmdir rmtree safe_unlink].freeze
-        RESTRICT_ON_SEND = (MAKE_METHODS + REMOVE_METHODS).freeze
+        MSG_REMOVE_FILE_EXIST_CHECK = 'Remove unnecessary existence check ' \
+                                      '`%<receiver>s.%<method_name>s`.'
+        MSG_CHANGE_FORCE_METHOD = 'Use atomic file operation method `FileUtils.%<method_name>s`.'
+        MAKE_FORCE_METHODS = %i[makedirs mkdir_p mkpath].freeze
+        MAKE_METHODS = %i[mkdir].freeze
+        REMOVE_FORCE_METHODS = %i[rm_f rm_rf].freeze
+        REMOVE_METHODS = %i[remove remove_dir remove_entry remove_entry_secure
+                            delete unlink remove_file rm rmdir safe_unlink].freeze
+        RESTRICT_ON_SEND = (MAKE_METHODS + MAKE_FORCE_METHODS + REMOVE_METHODS +
+          REMOVE_FORCE_METHODS).freeze
 
         # @!method send_exist_node(node)
         def_node_search :send_exist_node, <<-PATTERN
@@ -71,10 +78,9 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless (parent = node.parent) && parent.if_type?
-          return if allowable_use_with_if?(parent)
+          return unless if_node_child?(node)
           return if explicit_not_force?(node)
-          return unless (exist_node = send_exist_node(parent).first)
+          return unless (exist_node = send_exist_node(node.parent).first)
           return unless exist_node.first_argument == node.first_argument
 
           register_offense(node, exist_node)
@@ -82,44 +88,69 @@ module RuboCop
 
         private
 
+        def if_node_child?(node)
+          return false unless (parent = node.parent)
+
+          parent.if_type? && !allowable_use_with_if?(parent)
+        end
+
         def allowable_use_with_if?(if_node)
           if_node.condition.and_type? || if_node.condition.or_type? || if_node.else_branch
         end
 
         def register_offense(node, exist_node)
+          unless force_method?(node)
+            add_offense(node,
+                        message: format(MSG_CHANGE_FORCE_METHOD,
+                                        method_name: replacement_method(node)))
+          end
+
           range = range_between(node.parent.loc.keyword.begin_pos,
                                 exist_node.loc.expression.end_pos)
-
-          add_offense(range, message: message(exist_node)) do |corrector|
+          add_offense(range, message: message_remove_file_exist_check(exist_node)) do |corrector|
             autocorrect(corrector, node, range)
           end
         end
 
-        def message(node)
+        def message_remove_file_exist_check(node)
           receiver, method_name = receiver_and_method_name(node)
-          format(MSG, receiver: receiver, method_name: method_name)
+          format(MSG_REMOVE_FILE_EXIST_CHECK, receiver: receiver, method_name: method_name)
         end
 
         def autocorrect(corrector, node, range)
           corrector.remove(range)
+          autocorrect_replace_method(corrector, node)
+          corrector.remove(node.parent.loc.end) if node.parent.multiline?
+        end
+
+        def autocorrect_replace_method(corrector, node)
+          return if force_method?(node)
+
           corrector.replace(node.child_nodes.first.loc.name, 'FileUtils')
           corrector.replace(node.loc.selector, replacement_method(node))
-          corrector.remove(node.parent.loc.end) if node.parent.multiline?
         end
 
         def replacement_method(node)
-          return node.method_name if force_option?(node)
-
           if MAKE_METHODS.include?(node.method_name)
             'mkdir_p'
           elsif REMOVE_METHODS.include?(node.method_name)
-            'rm_rf'
+            'rm_f'
+          else
+            node.method_name
           end
         end
 
+        def force_method?(node)
+          force_method_name?(node) || force_option?(node)
+        end
+
         def force_option?(node)
           node.arguments.any? { |arg| force?(arg) }
         end
+
+        def force_method_name?(node)
+          (MAKE_FORCE_METHODS + REMOVE_FORCE_METHODS).include?(node.method_name)
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/number_conversion.rb

@@ -16,7 +16,8 @@ module RuboCop
       # NOTE: Some values cannot be converted properly using one of the `Kernel`
       # method (for instance, `Time` and `DateTime` values are allowed by this
       # cop by default). Similarly, Rails' duration methods do not work well
-      # with `Integer()` and can be ignored with `IgnoredMethods`.
+      # with `Integer()` and can be ignored with `IgnoredMethods`. By default,
+      # there are no methods to ignored.
       #
       # @safety
       #   Autocorrection is unsafe because it is not guaranteed that the
@@ -45,6 +46,11 @@ module RuboCop
       #   foo.try { |i| Float(i) }
       #   bar.send { |i| Complex(i) }
       #
+      # @example IgnoredMethods: [] (default)
+      #
+      #   # bad
+      #   10.minutes.to_i
+      #
       # @example IgnoredMethods: [minutes]
       #
       #   # good

data/lib/rubocop/cop/lint/redundant_safe_navigation.rb

@@ -35,6 +35,13 @@ module RuboCop
       #   # good - without `&.` this will always return `true`
       #   foo&.respond_to?(:to_a)
       #
+      # @example AllowedMethods: [foo?]
+      #   # bad
+      #   do_something if attrs&.foo?(:[])
+      #
+      #   # good
+      #   do_something if attrs&.bar?(:[])
+      #
       class RedundantSafeNavigation < Base
         include AllowedMethods
         include RangeHelp

data/lib/rubocop/cop/lint/require_range_parentheses.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks that a range literal is enclosed in parentheses when the end of the range is
+      # at a line break.
+      #
+      # NOTE: The following is maybe intended for `(42..)`. But, compatible is `42..do_something`.
+      # So, this cop does not provide autocorrection because it is left to user.
+      #
+      # [source,ruby]
+      # ----
+      # case condition
+      # when 42..
+      #   do_something
+      # end
+      # ----
+      #
+      # @example
+      #
+      #   # bad - Represents `(1..42)`, not endless range.
+      #   1..
+      #   42
+      #
+      #   # good - It's incompatible, but your intentions when using endless range may be:
+      #   (1..)
+      #   42
+      #
+      #   # good
+      #   1..42
+      #
+      #   # good
+      #   (1..42)
+      #
+      #   # good
+      #   (1..
+      #   42)
+      #
+      class RequireRangeParentheses < Base
+        MSG = 'Wrap the endless range literal `%<range>s` to avoid precedence ambiguity.'
+
+        def on_irange(node)
+          return if node.parent&.begin_type?
+          return unless node.begin && node.end
+          return if same_line?(node.begin, node.end)
+
+          message = format(MSG, range: "#{node.begin.source}#{node.loc.operator.source}")
+
+          add_offense(node, message: message)
+        end
+
+        alias on_erange on_irange
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/safe_navigation_chain.rb

@@ -25,6 +25,7 @@ module RuboCop
       #   x&.foo || bar
       class SafeNavigationChain < Base
         include NilMethods
+        extend AutoCorrector
         extend TargetRubyVersion
 
         minimum_target_ruby_version 2.3
@@ -48,12 +49,45 @@ module RuboCop
               Parser::Source::Range.new(node.source_range.source_buffer,
                                         safe_nav.source_range.end_pos,
                                         method_chain.source_range.end_pos)
-            add_offense(location)
+            add_offense(location) do |corrector|
+              autocorrect(corrector, offense_range: location, send_node: method_chain)
+            end
           end
         end
 
         private
 
+        # @param [Parser::Source::Range] offense_range
+        # @param [RuboCop::AST::SendNode] send_node
+        # @return [String]
+        def add_safe_navigation_operator(offense_range:, send_node:)
+          source = \
+            if send_node.method?(:[]) || send_node.method?(:[]=)
+              format(
+                '%<method_name>s(%<arguments>s)',
+                arguments: send_node.arguments.map(&:source).join(', '),
+                method_name: send_node.method_name
+              )
+            else
+              offense_range.source.dup
+            end
+          source.prepend('.') unless send_node.dot?
+          source.prepend('&')
+        end
+
+        # @param [RuboCop::Cop::Corrector] corrector
+        # @param [Parser::Source::Range] offense_range
+        # @param [RuboCop::AST::SendNode] send_node
+        def autocorrect(corrector, offense_range:, send_node:)
+          corrector.replace(
+            offense_range,
+            add_safe_navigation_operator(
+              offense_range: offense_range,
+              send_node: send_node
+            )
+          )
+        end
+
         def method_chain(node)
           chain = node
           chain = chain.parent if chain.send_type? && chain.parent&.call_type?

data/lib/rubocop/cop/metrics/block_length.rb

@@ -15,6 +15,7 @@ module RuboCop
       #
       # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
       # for backwards compatibility. Please use `IgnoredMethods` instead.
+      # By default, there are no methods to ignored.
       #
       # @example CountAsOne: ['array', 'heredoc']
       #

data/lib/rubocop/cop/metrics/method_length.rb

@@ -13,6 +13,7 @@ module RuboCop
       #
       # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
       # for backwards compatibility. Please use `IgnoredMethods` instead.
+      # By default, there are no methods to ignored.
       #
       # @example CountAsOne: ['array', 'heredoc']
       #