rubocop 1.24.1 → 1.25.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2e7d2cbe48c6ff81a071b353132db29ed017af57a32bcd142038e2e551f3a5b
-  data.tar.gz: 8ae72a3ce8b6ab13b4d451bbdb1dbcdf54f898711a3009dae81450a49fb037e0
+  metadata.gz: 54b88752efa8bb84dc034391460b9071f31179dcb279550a209d31829e7b8c93
+  data.tar.gz: 31115cff5fdbf562dee62cf7e07033205d150b61ac5fd11476708f21e67000cf
 SHA512:
-  metadata.gz: d868781732056622d0f5157a50553c0b521f81f2ca14d2ede65b4c7372ef0e3b89be5146db8664fac5b28a39c82be52fc297a43d8280647b1b7426ce9ee87337
-  data.tar.gz: e3d8f4dc8ab53859197eb3f05c62290cf72ba11c7e742869d619d6c4564e28f5c0fc70e4e15f90fc4f9bfe2d46cafdeedde8aa16d982adfc7d6eb482f7d20093
+  metadata.gz: acdaf069659a775853b20e05734e85cd65c0c8734b09e568d4360dc9a7440a49ec8e47928b0da78866e1326a588638d18f2564e6e94023bb17b2f39493555027
+  data.tar.gz: 2765d9c9c10966c485be6cd70190b69a25aa99800c8d483bd67c1fdfe3dc5d13bb97cb1ca7f9f663776869acda5a426bc797f3b40adda17e0241ff8b62a374f1

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012-21 Bozhidar Batsov
+Copyright (c) 2012-22 Bozhidar Batsov
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

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.24', require: false
+gem 'rubocop', '~> 1.25', require: false
 ```
 
 See [our versioning policy](https://docs.rubocop.org/rubocop/versioning.html) for further details.
@@ -244,5 +244,5 @@ RuboCop's changelog is available [here](CHANGELOG.md).
 
 ## Copyright
 
-Copyright (c) 2012-2021 Bozhidar Batsov. See [LICENSE.txt](LICENSE.txt) for
+Copyright (c) 2012-2022 Bozhidar Batsov. See [LICENSE.txt](LICENSE.txt) for
 further details.

data/config/default.yml

@@ -430,13 +430,13 @@ Layout/ClassStructure:
       - prepend
       - extend
   ExpectedOrder:
-      - module_inclusion
-      - constants
-      - public_class_methods
-      - initializer
-      - public_methods
-      - protected_methods
-      - private_methods
+    - module_inclusion
+    - constants
+    - public_class_methods
+    - initializer
+    - public_methods
+    - protected_methods
+    - private_methods
 
 Layout/ClosingHeredocIndentation:
   Description: 'Checks the indentation of here document closings.'
@@ -1900,7 +1900,7 @@ Lint/NestedPercentLiteral:
   VersionAdded: '0.52'
 
 Lint/NextWithoutAccumulator:
-  Description:  >-
+  Description: >-
                   Do not omit the accumulator when calling `next`
                   in a `reduce`/`inject` block.
   Enabled: true
@@ -2496,6 +2496,7 @@ Naming/BlockForwarding:
   SupportedStyles:
     - anonymous
     - explicit
+  BlockForwardingName: block
 
 Naming/BlockParameterName:
   Description: >-
@@ -3152,7 +3153,7 @@ Style/ClassMethodsDefinitions:
   StyleGuide: '#def-self-class-methods'
   Enabled: false
   VersionAdded: '0.89'
-  EnforcedStyle:  def_self
+  EnforcedStyle: def_self
   SupportedStyles:
     - def_self
     - self_class
@@ -3698,6 +3699,8 @@ Style/HashSyntax:
     - always
     # forces use of explicit hash literal value.
     - never
+    # accepts both shorthand and explicit use of hash literal value.
+    - either
   # Force hashes that have a symbol value to use hash rockets
   UseHashRocketsWithSymbolValues: false
   # Do not suggest { a?: 1 } over { :a? => 1 } in ruby19 style
@@ -3812,8 +3815,8 @@ Style/InverseMethods:
     :>: :<=
     # `ActiveSupport` defines some common inverse methods. They are listed below,
     # and not enabled by default.
-    #:present?: :blank?,
-    #:include?: :exclude?
+    # :present?: :blank?,
+    # :include?: :exclude?
   # `InverseBlocks` are methods that are inverted by inverting the return
   # of the block that is passed to the method
   InverseBlocks:

data/lib/rubocop/cop/gemspec/required_ruby_version.rb

@@ -68,8 +68,11 @@ module RuboCop
 
         # @!method defined_ruby_version(node)
         def_node_matcher :defined_ruby_version, <<~PATTERN
-          {$(str _) $(array (str _) (str _))
-            (send (const (const nil? :Gem) :Requirement) :new $(str _))}
+          {
+            $(str _)
+            $(array (str _) (str _))
+            (send (const (const nil? :Gem) :Requirement) :new $str+)
+          }
         PATTERN
 
         def on_new_investigation
@@ -97,7 +100,11 @@ module RuboCop
         def extract_ruby_version(required_ruby_version)
           return unless required_ruby_version
 
-          if required_ruby_version.array_type?
+          if required_ruby_version.is_a?(Array)
+            required_ruby_version = required_ruby_version.detect do |v|
+              /[>=]/.match?(v.str_content)
+            end
+          elsif required_ruby_version.array_type?
             required_ruby_version = required_ruby_version.children.detect do |v|
               /[>=]/.match?(v.str_content)
             end

data/lib/rubocop/cop/generator.rb

@@ -182,7 +182,8 @@ module RuboCop
       end
 
       def generate(template)
-        format(template, department: badge.department, cop_name: badge.cop_name)
+        format(template, department: badge.department.to_s.gsub('/', '::'),
+                         cop_name: badge.cop_name)
       end
 
       def spec_path
@@ -209,8 +210,8 @@ module RuboCop
         return 'rspec' if camel_case_string == 'RSpec'
 
         camel_case_string
-          .gsub(/([^A-Z])([A-Z]+)/, '\1_\2')
-          .gsub(/([A-Z])([A-Z][^A-Z\d]+)/, '\1_\2')
+          .gsub(%r{([^A-Z/])([A-Z]+)}, '\1_\2')
+          .gsub(%r{([A-Z])([A-Z][^A-Z\d/]+)}, '\1_\2')
           .downcase
       end
     end

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

@@ -53,23 +53,50 @@ module RuboCop
                            'following the first line of a multi-line method call.'
 
         def on_send(node)
-          first_arg = node.first_argument
-          return if !multiple_arguments?(node, first_arg) || (node.send_type? && node.method?(:[]=))
+          return if !multiple_arguments?(node) || (node.send_type? && node.method?(:[]=))
 
-          if first_arg.hash_type? && !first_arg.braces?
-            pairs = first_arg.pairs
-            check_alignment(pairs, base_column(node, pairs.first))
-          else
-            check_alignment(node.arguments, base_column(node, first_arg))
-          end
+          items = flattened_arguments(node)
+
+          check_alignment(items, base_column(node, items.first))
         end
+
         alias on_csend on_send
 
         private
 
-        def multiple_arguments?(node, first_argument)
+        def flattened_arguments(node)
+          if fixed_indentation?
+            arguments_with_last_arg_pairs(node)
+          else
+            arguments_or_first_arg_pairs(node)
+          end
+        end
+
+        def arguments_with_last_arg_pairs(node)
+          items = node.arguments[0..-2]
+          last_arg = node.arguments.last
+
+          if last_arg.hash_type? && !last_arg.braces?
+            items += last_arg.pairs
+          else
+            items << last_arg
+          end
+          items
+        end
+
+        def arguments_or_first_arg_pairs(node)
+          first_arg = node.first_argument
+          if first_arg.hash_type? && !first_arg.braces?
+            first_arg.pairs
+          else
+            node.arguments
+          end
+        end
+
+        def multiple_arguments?(node)
           return true if node.arguments.size >= 2
 
+          first_argument = node.first_argument
           first_argument&.hash_type? && first_argument.pairs.count >= 2
         end
 

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

@@ -81,7 +81,7 @@ module RuboCop
 
           locations.each do |loc|
             line = loc.line
-            next if line == line_of_def_or_kwbegin
+            next if line == line_of_def_or_kwbegin || last_rescue_and_end_on_same_line(body)
 
             keyword = loc.source
             # below the keyword
@@ -91,6 +91,10 @@ module RuboCop
           end
         end
 
+        def last_rescue_and_end_on_same_line(body)
+          body.rescue_type? && body.resbody_branches.last.loc.line == body.parent.loc.end.line
+        end
+
         def message(location, keyword)
           format(MSG, location: location, keyword: keyword)
         end

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

@@ -222,11 +222,16 @@ module RuboCop
                               node.pairs.any? &&
                               node.parent&.call_type?
 
+          left_sibling = argument_before_hash(node)
           parent_loc = node.parent.loc
-          selector = parent_loc.selector || parent_loc.expression
+          selector = left_sibling || parent_loc.selector || parent_loc.expression
           same_line?(selector, node.pairs.first)
         end
 
+        def argument_before_hash(hash_node)
+          hash_node.left_sibling.respond_to?(:loc) ? hash_node.left_sibling : nil
+        end
+
         def reset!
           self.offenses_by = {}
           self.column_deltas = Hash.new { |hash, key| hash[key] = {} }

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

@@ -143,7 +143,7 @@ module RuboCop
             return true
           end
 
-          do_keyword_line == selector.line && rescue_keyword_column == selector.column
+          do_keyword_line == selector&.line && rescue_keyword_column == selector.column
         end
 
         def aligned_with_leading_dot?(do_keyword_line, send_node_loc, rescue_keyword_column)

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

@@ -30,7 +30,11 @@ module RuboCop
 
         def on_new_investigation
           processed_source.diagnostics.each do |diagnostic|
-            next unless diagnostic.reason == :ambiguous_literal
+            if target_ruby_version >= 3.0
+              next unless diagnostic.reason == :ambiguous_regexp
+            else
+              next unless diagnostic.reason == :ambiguous_literal
+            end
 
             offense_node = find_offense_node_by(diagnostic)
 

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

@@ -33,11 +33,12 @@ module RuboCop
         # @!method io_select(node)
         def_node_matcher :io_select, <<~PATTERN
           (send
-            (const {nil? cbase} :IO) :select $_ $_ {(array) nil} $...)
+            (const {nil? cbase} :IO) :select $...)
         PATTERN
 
         def on_send(node)
-          return unless (read, write, timeout = io_select(node))
+          read, write, _excepts, timeout = *io_select(node)
+          return unless read
           return unless scheduler_compatible?(read, write) || scheduler_compatible?(write, read)
 
           preferred = preferred_method(read, write, timeout)
@@ -51,13 +52,13 @@ module RuboCop
         private
 
         def scheduler_compatible?(io1, io2)
-          return false unless io1.array_type? && io1.values.size == 1
+          return false unless io1&.array_type? && io1.values.size == 1
 
-          io2.array_type? ? io2.values.empty? : io2.nil_type?
+          io2&.array_type? ? io2.values.empty? : (io2.nil? || io2.nil_type?)
         end
 
         def preferred_method(read, write, timeout)
-          timeout_argument = timeout.empty? ? '' : "(#{timeout[0].source})"
+          timeout_argument = timeout.nil? ? '' : "(#{timeout.source})"
 
           if read.array_type? && read.values[0]
             "#{read.values[0].source}.wait_readable#{timeout_argument}"

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -8,7 +8,7 @@ module RuboCop
       EXPLICIT_HASH_VALUE_MSG = 'Explicit the hash value.'
 
       def on_pair(node)
-        return if target_ruby_version <= 3.0
+        return if ignore_hash_shorthand_syntax?(node)
 
         hash_key_source = node.key.source
 
@@ -31,12 +31,17 @@ module RuboCop
 
       private
 
+      def ignore_hash_shorthand_syntax?(pair_node)
+        target_ruby_version <= 3.0 || enforced_shorthand_syntax == 'either' ||
+          !pair_node.parent.hash_type?
+      end
+
       def enforced_shorthand_syntax
         cop_config.fetch('EnforcedShorthandSyntax', 'always')
       end
 
       def require_hash_value?(hash_key_source, node)
-        return true if without_parentheses_call_expr_follows?(node)
+        return true if require_hash_value_for_around_hash_literal?(node)
 
         hash_value = node.value
         return true unless hash_value.send_type? || hash_value.lvar_type?
@@ -44,12 +49,33 @@ module RuboCop
         hash_key_source != hash_value.source || hash_key_source.end_with?('!', '?')
       end
 
-      def without_parentheses_call_expr_follows?(node)
+      def require_hash_value_for_around_hash_literal?(node)
         return false unless (ancestor = node.parent.parent)
-        return false unless (right_sibling = ancestor.right_sibling)
+        return false if ancestor.send_type? && ancestor.method?(:[])
+
+        !node.parent.braces? && !use_element_of_hash_literal_as_receiver?(ancestor, node.parent) &&
+          (use_modifier_form_without_parenthesized_method_call?(ancestor) ||
+           without_parentheses_call_expr_follows?(ancestor))
+      end
+
+      def use_element_of_hash_literal_as_receiver?(ancestor, parent)
+        # `{value:}.do_something` is a valid syntax.
+        ancestor.send_type? && ancestor.receiver == parent
+      end
+
+      def use_modifier_form_without_parenthesized_method_call?(ancestor)
+        return false if ancestor.respond_to?(:parenthesized?) && ancestor.parenthesized?
+        return false unless (parent = ancestor.parent)
+
+        parent.respond_to?(:modifier_form?) && parent.modifier_form?
+      end
+
+      def without_parentheses_call_expr_follows?(ancestor)
+        right_sibling = ancestor.right_sibling
+        right_sibling ||= ancestor.each_ancestor.find(&:assignment?)&.right_sibling
+        return false unless right_sibling
 
-        ancestor.respond_to?(:parenthesized?) && !ancestor.parenthesized? &&
-          right_sibling.respond_to?(:parenthesized?) && !right_sibling.parenthesized?
+        ancestor.respond_to?(:parenthesized?) && !ancestor.parenthesized? && !!right_sibling
       end
     end
   end

data/lib/rubocop/cop/naming/block_forwarding.rb

@@ -9,6 +9,9 @@ module RuboCop
       # by `do_something(&)`.
       #
       # It also supports the opposite style by alternative `explicit` option.
+      # You can specify the block variable name for auto-correction with `BlockForwardingName`.
+      # The default variable name is `block`. If the name is already in use, it will not be
+      # auto-corrected.
       #
       # @example EnforcedStyle: anonymous (default)
       #
@@ -50,12 +53,13 @@ module RuboCop
           last_argument = node.arguments.last
           return if expected_block_forwarding_style?(node, last_argument)
 
-          register_offense(last_argument)
+          register_offense(last_argument, node)
 
           node.each_descendant(:block_pass) do |block_pass_node|
-            next if block_pass_node.children.first&.sym_type?
+            next if block_pass_node.children.first&.sym_type? ||
+                    last_argument.source != block_pass_node.source
 
-            register_offense(block_pass_node)
+            register_offense(block_pass_node, node)
           end
         end
         alias on_defs on_def
@@ -66,7 +70,7 @@ module RuboCop
           if style == :anonymous
             !explicit_block_argument?(last_argument) ||
               use_kwarg_in_method_definition?(node) ||
-              use_block_argument_as_local_variable?(node, last_argument)
+              use_block_argument_as_local_variable?(node, last_argument.source[1..-1])
           else
             !anonymous_block_argument?(last_argument)
           end
@@ -84,22 +88,32 @@ module RuboCop
           node.blockarg_type? && !node.name.nil?
         end
 
+        def register_offense(block_argument, node)
+          add_offense(block_argument, message: format(MSG, style: style)) do |corrector|
+            if style == :anonymous
+              corrector.replace(block_argument, '&')
+
+              arguments = block_argument.parent
+
+              add_parentheses(arguments, corrector) unless arguments.parenthesized_call?
+            else
+              unless use_block_argument_as_local_variable?(node, block_forwarding_name)
+                corrector.replace(block_argument, "&#{block_forwarding_name}")
+              end
+            end
+          end
+        end
+
         def use_block_argument_as_local_variable?(node, last_argument)
           return if node.body.nil?
 
           node.body.each_descendant(:lvar).any? do |lvar|
-            !lvar.parent.block_pass_type? && lvar.source == last_argument.source[1..-1]
+            !lvar.parent.block_pass_type? && lvar.source == last_argument
           end
         end
 
-        def register_offense(block_argument)
-          add_offense(block_argument, message: format(MSG, style: style)) do |corrector|
-            corrector.replace(block_argument, '&')
-
-            arguments = block_argument.parent
-
-            add_parentheses(arguments, corrector) unless arguments.parenthesized_call?
-          end
+        def block_forwarding_name
+          cop_config.fetch('BlockForwardingName', 'block')
         end
       end
     end

data/lib/rubocop/cop/naming/method_parameter_name.rb

@@ -26,7 +26,7 @@ module RuboCop
       #     num1 * num2
       #   end
       #
-      #   # With `MinArgNameLength` set to number greater than 1
+      #   # With `MinNameLength` set to number greater than 1
       #   def baz(a, b, c)
       #     do_stuff(a, b, c)
       #   end

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

@@ -41,7 +41,7 @@ module RuboCop
 
         # @!method reject_method_with_block_pass?(node)
         def_node_matcher :reject_method_with_block_pass?, <<~PATTERN
-          (send _ {:reject :reject!}
+          (send !nil? {:reject :reject!}
             (block_pass
               (sym :nil?)))
         PATTERN
@@ -50,7 +50,7 @@ module RuboCop
         def_node_matcher :reject_method?, <<~PATTERN
           (block
             (send
-              _ {:reject :reject!})
+              !nil? {:reject :reject!})
             $(args ...)
             (send
               $(lvar _) :nil?))
@@ -60,7 +60,7 @@ module RuboCop
         def_node_matcher :select_method?, <<~PATTERN
           (block
             (send
-              _ {:select :select!})
+              !nil? {:select :select!})
             $(args ...)
             (send
               (send

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

@@ -23,6 +23,12 @@ module RuboCop
       # It can enforce either the use of the explicit hash value syntax or
       # the use of Ruby 3.1's hash value shorthand syntax.
       #
+      # The supported styles are:
+      #
+      # * always - forces use of the 3.1 syntax (e.g. {foo:})
+      # * never - forces use of explicit hash literal value
+      # * either - accepts both shorthand and explicit use of hash literal value
+      #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad
       #   {:a => 2}
@@ -75,6 +81,14 @@ module RuboCop
       #   # good
       #   {foo: foo, bar: bar}
       #
+      # @example EnforcedShorthandSyntax: either
+      #
+      #   # good
+      #   {foo: foo, bar: bar}
+      #
+      #   # good
+      #   {foo:, bar:}
+      #
       class HashSyntax < Base
         include ConfigurableEnforcedStyle
         include HashShorthandSyntax

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

@@ -36,7 +36,7 @@ module RuboCop
       #   # good (but potentially an unsafe correction)
       #   foo.do_something?
       #
-      # @example AllowedMethods: ['nonzero?']
+      # @example AllowedMethods: ['nonzero?'] (default)
       #   # good
       #   num.nonzero? ? true : false
       #

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -48,14 +48,21 @@ module RuboCop
             node.each_ancestor(:def, :defs).any?(&:endless?) && node.arguments.any?
           end
 
-          # Require hash value omission be enclosed in parentheses to prevent the following issue:
-          # https://bugs.ruby-lang.org/issues/18396.
           def require_parentheses_for_hash_value_omission?(node)
-            return unless (last_argument = node.last_argument)
+            return false unless (last_argument = node.last_argument)
+            return false if !last_argument.hash_type? || !last_argument.pairs.last&.value_omission?
 
-            return false unless (right_sibling = node.right_sibling)
+            modifier_form?(node) || exist_next_line_expression?(node)
+          end
 
-            last_argument.hash_type? && last_argument.pairs.last&.value_omission? && right_sibling
+          def modifier_form?(node)
+            node.parent.respond_to?(:modifier_form?) && node.parent.modifier_form?
+          end
+
+          # Require hash value omission be enclosed in parentheses to prevent the following issue:
+          # https://bugs.ruby-lang.org/issues/18396.
+          def exist_next_line_expression?(node)
+            node.parent&.assignment? ? node.parent.right_sibling : node.right_sibling
           end
 
           def syntax_like_method_call?(node)

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

@@ -47,7 +47,7 @@ module RuboCop
       # allowed when forwarding arguments with the triple-dot syntax introduced
       # in Ruby 2.7 as omitting them starts an endless range.
       # And Ruby 3.1's hash omission syntax has a case that requires parentheses
-      # because the issue https://bugs.ruby-lang.org/issues/18396.
+      # because of the following issue: https://bugs.ruby-lang.org/issues/18396.
       #
       # @example EnforcedStyle: require_parentheses (default)
       #

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

@@ -97,7 +97,7 @@ module RuboCop
           offense_range = node.loc.begin
 
           add_offense(offense_range) do |corrector|
-            if any_ancestor_assignment_node?(node)
+            if node.parent&.assignment?
               replace_begin_with_statement(corrector, offense_range, node)
             else
               corrector.remove(offense_range)
@@ -170,11 +170,7 @@ module RuboCop
         end
 
         def valid_begin_assignment?(node)
-          any_ancestor_assignment_node?(node) && !node.children.one?
-        end
-
-        def any_ancestor_assignment_node?(node)
-          node.each_ancestor.any?(&:assignment?)
+          node.parent&.assignment? && !node.children.one?
         end
       end
     end

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

@@ -91,11 +91,12 @@ module RuboCop
           second.int_type? ? second.to_a.first : :unknown
         end
 
-        def range_size(range_node) # rubocop:todo Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def range_size(range_node)
           vals = range_node.to_a
-          return :unknown unless vals.all?(&:int_type?)
+          return :unknown unless vals.all? { |val| val.nil? || val.int_type? }
 
-          low, high = vals.map { |val| val.children[0] }
+          low, high = vals.map { |val| val.nil? ? 0 : val.children[0] }
           return :unknown unless low.zero? && high >= 0
 
           case range_node.type
@@ -105,6 +106,7 @@ module RuboCop
             (low..high).size
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def source_range(shuffle_node, node)
           Parser::Source::Range.new(shuffle_node.source_range.source_buffer,

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

@@ -58,6 +58,8 @@ module RuboCop
         end
 
         def simple_assignment?(node)
+          return false unless node.respond_to?(:type)
+
           SIMPLE_ASSIGNMENT_TYPES.include?(node.type)
         end
 

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

@@ -67,7 +67,10 @@ module RuboCop
         MSG_COMPLEX = '%<command>s parentheses for ternary expressions with complex conditions.'
 
         def on_if(node)
-          return if only_closing_parenthesis_is_last_line?(node.condition)
+          condition = node.condition
+
+          return if only_closing_parenthesis_is_last_line?(condition)
+          return if condition_as_parenthesized_one_line_pattern_matching?(condition)
           return unless node.ternary? && !infinite_loop? && offense?(node)
 
           message = message(node)
@@ -77,11 +80,22 @@ module RuboCop
           end
         end
 
+        private
+
         def only_closing_parenthesis_is_last_line?(condition)
           condition.source.split("\n").last == ')'
         end
 
-        private
+        def condition_as_parenthesized_one_line_pattern_matching?(condition)
+          return false unless condition.parenthesized_call?
+          return false unless (first_child = condition.children.first)
+
+          if target_ruby_version >= 3.0
+            first_child.match_pattern_p_type?
+          else
+            first_child.match_pattern_type? # For Ruby 2.7's one line pattern matching AST.
+          end
+        end
 
         def autocorrect(corrector, node)
           condition = node.condition

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -121,9 +121,14 @@ module RuboCop
         output_buffer.puts "# Offense count: #{offense_count}" if show_offense_counts?
 
         cop_class = Cop::Registry.global.find_by_cop_name(cop_name)
-        output_buffer.puts '# Cop supports --auto-correct.' if cop_class&.support_autocorrect?
-
         default_cfg = default_config(cop_name)
+
+        if supports_safe_auto_correct?(cop_class, default_cfg)
+          output_buffer.puts '# Cop supports --auto-correct.'
+        elsif supports_unsafe_autocorrect?(cop_class, default_cfg)
+          output_buffer.puts '# Cop supports --auto-correct-all.'
+        end
+
         return unless default_cfg
 
         params = cop_config_params(default_cfg, cfg)
@@ -132,6 +137,15 @@ module RuboCop
         output_cop_param_comments(output_buffer, params, default_cfg)
       end
 
+      def supports_safe_auto_correct?(cop_class, default_cfg)
+        cop_class&.support_autocorrect? &&
+          (default_cfg.nil? || default_cfg['Safe'] || default_cfg['Safe'].nil?)
+      end
+
+      def supports_unsafe_autocorrect?(cop_class, default_cfg)
+        cop_class&.support_autocorrect? && !default_cfg.nil? && default_cfg['Safe'] == false
+      end
+
       def cop_config_params(default_cfg, cfg)
         default_cfg.keys -
           %w[Description StyleGuide Reference Enabled Exclude Safe

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.24.1'
+    STRING = '1.25.1'
 
     MSG = '%<version>s (using Parser %<parser_version>s, '\
           'rubocop-ast %<rubocop_ast_version>s, ' \

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 1.24.1
+  version: 1.25.1
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-12-31 00:00:00.000000000 Z
+date: 2022-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -32,14 +32,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0.0
+        version: 3.1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0.0
+        version: 3.1.0.0
 - !ruby/object:Gem::Dependency
   name: rainbow
   requirement: !ruby/object:Gem::Requirement
@@ -911,7 +911,7 @@ metadata:
   homepage_uri: https://rubocop.org/
   changelog_uri: https://github.com/rubocop/rubocop/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop/rubocop/
-  documentation_uri: https://docs.rubocop.org/rubocop/1.24/
+  documentation_uri: https://docs.rubocop.org/rubocop/1.25/
   bug_tracker_uri: https://github.com/rubocop/rubocop/issues
   rubygems_mfa_required: 'true'
 post_install_message: