rubocop 1.90.0 → 1.91.0

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

@@ -107,7 +107,7 @@ module RuboCop
               remove_to_f_method(corrector, node.receiver)
               add_to_f_method(corrector, node.first_argument)
             when :fdiv
-              correct_from_slash_to_fdiv(corrector, node, node.receiver, node.first_argument)
+              correct_from_slash_to_fdiv(corrector, node.receiver, node.first_argument)
             end
           end
         end
@@ -145,23 +145,17 @@ module RuboCop
           corrector.remove(send_node.loc.selector)
         end
 
-        def correct_from_slash_to_fdiv(corrector, node, receiver, argument)
-          receiver_source = extract_receiver_source(receiver)
-          argument_source = extract_receiver_source(argument)
+        def correct_from_slash_to_fdiv(corrector, receiver, argument)
+          remove_to_f_method(corrector, receiver) if to_f_method?(receiver)
 
-          if argument.respond_to?(:parenthesized?) && !argument.parenthesized?
-            argument_source = "(#{argument_source})"
-          end
-
-          corrector.replace(node, "#{receiver_source}.fdiv#{argument_source}")
-        end
+          argument_parenthesized = argument.begin_type?
+          corrector.replace(
+            receiver.source_range.end.join(argument.source_range.begin),
+            argument_parenthesized ? '.fdiv' : '.fdiv('
+          )
 
-        def extract_receiver_source(node)
-          if node.send_type? && node.method?(:to_f)
-            node.receiver.source
-          else
-            node.source
-          end
+          remove_to_f_method(corrector, argument) if to_f_method?(argument)
+          corrector.insert_after(argument, ')') unless argument_parenthesized
         end
       end
     end

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

@@ -69,6 +69,7 @@ module RuboCop
 
           if style == :for
             return unless node.receiver
+            return if rescue_or_ensure_body?(node)
 
             add_offense(node, message: PREFER_FOR) do |corrector|
               EachToForCorrector.new(node).call(corrector)
@@ -87,6 +88,10 @@ module RuboCop
         def suspect_enumerable?(node)
           node.multiline? && node.method?(:each) && !node.send_node.arguments?
         end
+
+        def rescue_or_ensure_body?(node)
+          node.body&.type?(:rescue, :ensure)
+        end
       end
     end
   end

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

@@ -228,7 +228,7 @@ module RuboCop
           "Prefer #{message_text(style)} over #{message_text(detected_style)}."
         end
 
-        # rubocop:disable-next Style/FormatStringToken
+        # rubocop:disable-next Style/FormatStringToken -- the cop needs the token style it is matching
         def message_text(style)
           {
             annotated: 'annotated tokens (like `%<foo>s`)',

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

@@ -109,6 +109,10 @@ module RuboCop
         MSG = 'Use a guard clause (`%<example>s`) instead of wrapping the ' \
               'code inside a conditional expression.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MissingElse]
+        end
+
         def on_def(node)
           body = node.body
 

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

@@ -57,12 +57,15 @@ module RuboCop
 
         def on_send(node)
           return if (receiver = node.receiver) && allowed_receiver?(receiver)
+          return if part_of_ignored_node?(node)
 
           if offense_for_brackets?(node)
+            ignore_node(node.first_argument)
             add_offense(node.loc.selector, message: BRACKET_MSG) do |corrector|
               correct_fetch_to_brackets(corrector, node)
             end
           elsif offense_for_fetch?(node)
+            ignore_node(node.first_argument)
             add_offense(node, message: FETCH_MSG) do |corrector|
               correct_brackets_to_fetch(corrector, node)
             end

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

@@ -187,7 +187,7 @@ module RuboCop
             issues[:directives] << directive if directive_offends?(directive)
           end
 
-          comment.values.each do |value| # rubocop:disable Style/HashEachMethods
+          comment.values.each do |value| # rubocop:disable Style/HashEachMethods -- the receiver is a magic comment, not a Hash
             issues[:values] << value if wrong_capitalization?(value.source, value_capitalization)
           end
 

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

@@ -242,7 +242,7 @@ module RuboCop
         extend AutoCorrector
 
         def self.autocorrect_incompatible_with
-          [Style::NestedParenthesizedCalls, Style::RescueModifier]
+          [Style::NestedParenthesizedCalls, Style::RescueModifier, Style::TrailingCommaInArguments]
         end
 
         def on_send(node)

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

@@ -70,6 +70,7 @@ module RuboCop
 
         def right_hand_operand(node, left_hand_keyword)
           condition = node.condition
+          negated = left_hand_keyword != node.keyword
 
           expr = if condition.send_type? && !condition.arguments.empty? &&
                     !condition.operator_method?
@@ -77,8 +78,8 @@ module RuboCop
                  else
                    condition.source
                  end
-          expr = "(#{expr})" if requires_parens?(condition)
-          expr = "!#{expr}" unless left_hand_keyword == node.keyword
+          expr = "(#{expr})" if requires_parens?(condition, negated)
+          expr = "!#{expr}" if negated
           expr
         end
 
@@ -91,8 +92,12 @@ module RuboCop
           expr
         end
 
-        def requires_parens?(node)
-          node.or_type? || !(RuboCop::AST::Node::COMPARISON_OPERATORS & node.children).empty?
+        def requires_parens?(node, negated)
+          # A negated `&&`/`||` operand must be wrapped so the `!` applies to the
+          # whole expression (e.g. `!(a && b)`, not `!a && b`).
+          (negated && node.operator_keyword?) ||
+            node.or_type? ||
+            !(RuboCop::AST::Node::COMPARISON_OPERATORS & node.children).empty?
         end
       end
     end

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

@@ -42,28 +42,56 @@ module RuboCop
         # @!method nil_check?(node)
         def_node_matcher :nil_check?, '(send _ :nil?)'
 
-        # rubocop:disable-next Metrics/AbcSize
         def on_send(node)
           return unless node.receiver
 
           style_check?(node) do
             add_offense(node.loc.selector) do |corrector|
               if prefer_comparison?
-                range = node.loc.dot.join(node.loc.selector.end)
-                corrector.replace(range, ' == nil')
+                autocorrect_to_comparison(corrector, node)
               else
-                range = node.receiver.source_range.end.join(node.source_range.end)
-                corrector.replace(range, '.nil?')
+                autocorrect_to_predicate(corrector, node)
               end
-
-              parent = node.parent
-              corrector.wrap(node, '(', ')') if parent.respond_to?(:method?) && parent.method?(:!)
             end
           end
         end
 
         private
 
+        def autocorrect_to_comparison(corrector, node)
+          range = node.loc.dot.join(node.loc.selector.end)
+          corrector.replace(range, ' == nil')
+          # The new `== nil` binds looser than an enclosing operator (e.g. `<<`,
+          # `!`), so wrap it to keep the original precedence.
+          corrector.wrap(node, '(', ')') if operator_expression?(node.parent)
+        end
+
+        def autocorrect_to_predicate(corrector, node)
+          receiver = node.receiver
+          if operator_expression?(receiver)
+            # A looser-binding receiver (e.g. `!x`, `a + b`) must be parenthesized
+            # so the appended `.nil?` applies to the whole expression.
+            corrector.replace(node, "(#{receiver.source}).nil?")
+          else
+            range = receiver.source_range.end.join(node.source_range.end)
+            corrector.replace(range, '.nil?')
+          end
+        end
+
+        def operator_expression?(node)
+          return false unless node
+
+          operator_send?(node) ||
+            node.operator_keyword? ||
+            (node.if_type? && node.ternary?) ||
+            node.type?(:range, :iflipflop, :eflipflop) ||
+            node.assignment?
+        end
+
+        def operator_send?(node)
+          node.send_type? && node.operator_method? && !node.method?(:[]) && !node.method?(:[]=)
+        end
+
         def message(_node)
           prefer_comparison? ? EXPLICIT_MSG : PREDICATE_MSG
         end

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

@@ -48,7 +48,7 @@ module RuboCop
           { ({return next break} nil) (nil) }
         PATTERN
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- a lambda whose body is `nil` uses no parameters
           return unless node.lambda_or_proc?
           return unless nil_return?(node.body)
           # `return` inside a non-lambda proc returns from the enclosing method,

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

@@ -109,7 +109,7 @@ module RuboCop
 
         def message(node)
           if node.method?(:!=) && !include_semantic_changes?
-            prefer = "!#{node.receiver.source}.nil?"
+            prefer = non_nil_check_replacement(node)
             format(MSG_FOR_REPLACEMENT, prefer: prefer, current: node.source)
           else
             MSG_FOR_REDUNDANCY
@@ -120,11 +120,27 @@ module RuboCop
           cop_config['IncludeSemanticChanges']
         end
 
+        # An operator-expression receiver (e.g. `a + b`) binds looser than the
+        # appended `.nil?`, so it must be parenthesized: `!(a + b).nil?`.
+        def non_nil_check_replacement(node)
+          receiver = node.receiver
+          source = operator_expression?(receiver) ? "(#{receiver.source})" : receiver.source
+          "!#{source}.nil?"
+        end
+
+        def operator_expression?(node)
+          node.operator_keyword? ||
+            (node.send_type? && node.binary_operation?) ||
+            (node.if_type? && node.ternary?) ||
+            node.type?(:range, :iflipflop, :eflipflop) ||
+            node.assignment?
+        end
+
         def autocorrect_comparison(corrector, node)
           if include_semantic_changes?
             corrector.replace(node, node.receiver.source)
           else
-            corrector.replace(node, "!#{node.receiver.source}.nil?")
+            corrector.replace(node, non_nil_check_replacement(node))
           end
         end
 

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

@@ -56,7 +56,9 @@ module RuboCop
         def requires_parens?(child)
           child.operator_keyword? ||
             (child.send_type? && child.binary_operation?) ||
-            (child.if_type? && child.ternary?)
+            (child.if_type? && child.ternary?) ||
+            child.type?(:range, :iflipflop, :eflipflop) ||
+            child.assignment?
         end
 
         def correct_opposite_method(corrector, range, child)

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

@@ -55,7 +55,11 @@ module RuboCop
           return unless type
 
           add_offense(node) do |corrector|
-            corrector.replace(node, send(:"format_#{type}", node.source))
+            # The prefix patterns below are anchored, so correct only the digits
+            # and leave any sign the literal's source carries in place.
+            range = unsigned_range(node)
+
+            corrector.replace(range, send(:"format_#{type}", range.source))
           end
         end
 
@@ -71,6 +75,12 @@ module RuboCop
           octal_literal_type(literal) || hex_bin_dec_literal_type(literal)
         end
 
+        def unsigned_range(node)
+          range = node.source_range
+
+          node.source.start_with?('+', '-') ? range.adjust(begin_pos: 1) : range
+        end
+
         def octal_literal_type(literal)
           if OCTAL_ZERO_ONLY_REGEX.match?(literal) && octal_zero_only?
             :octal_zero_only

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

@@ -117,7 +117,7 @@ module RuboCop
         end
 
         def ternary_replacement(node)
-          condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
 
           "#{expr_replacement(condition)} ? " \
             "#{expr_replacement(if_branch)} : " \

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

@@ -184,7 +184,7 @@ module RuboCop
           def accesses?(rhs, lhs)
             if lhs.method?(:[]=)
               # FIXME: Workaround `rubocop:disable` comment for JRuby.
-              # rubocop:disable-next Performance/RedundantEqualityComparisonBlock
+              # rubocop:disable-next Performance/RedundantEqualityComparisonBlock -- a JRuby workaround, as the comment above says
               matching_calls(rhs, lhs.receiver, :[]).any? { |args| args == lhs.arguments }
             else
               access_method = lhs.method_name.to_s.chop.to_sym

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

@@ -123,10 +123,15 @@ module RuboCop
 
         def parens_allowed?(node)
           parens_required?(node) ||
-            (safe_assignment?(node) && safe_assignment_allowed?) ||
+            (safe_assignment?(node) && safe_assignment_kept?) ||
             (node.multiline? && allow_multiline_conditions?)
         end
 
+        def safe_assignment_kept?
+          safe_assignment_allowed? ||
+            config.for_enabled_cop('Lint/AssignmentInCondition')['AllowSafeAssignment']
+        end
+
         def allow_multiline_conditions?
           cop_config['AllowInMultilineConditions']
         end

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

@@ -119,7 +119,7 @@ module RuboCop
         end
 
         def offense?(node)
-          _condition, _if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          _condition, _if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
           return false if use_if_branch?(else_branch) || use_hash_key_assignment?(else_branch)
 
           synonymous_condition_and_branch?(node) && !node.elsif? &&
@@ -143,7 +143,7 @@ module RuboCop
         end
 
         def synonymous_condition_and_branch?(node)
-          condition, if_branch, _else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          condition, if_branch, _else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
           # e.g.
           #   if var
           #     var
@@ -192,7 +192,7 @@ module RuboCop
         end
 
         def branches_have_assignment?(node)
-          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
 
           return false unless if_branch && else_branch
 
@@ -294,7 +294,7 @@ module RuboCop
         end
 
         def make_ternary_form(node)
-          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
           arithmetic_operation = use_arithmetic_operation?(if_branch)
 
           ternary_form = [

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

@@ -108,7 +108,7 @@ module RuboCop
 
           node.arguments.map do |arg|
             if arg.hash_type?
-              arg.source
+              hash_argument_source(arg)
             else
               "**#{arg.source}"
             end
@@ -122,6 +122,15 @@ module RuboCop
 
           mergeable?(parent)
         end
+
+        # A braced hash literal passed to `merge` must have its braces stripped so
+        # its pairs join the surrounding keyword arguments. Keeping the braces would
+        # produce a positional hash after keyword arguments, which is invalid Ruby.
+        def hash_argument_source(hash)
+          return hash.source unless hash.braces?
+
+          hash.pairs.map(&:source).join(', ')
+        end
       end
     end
   end

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

@@ -52,7 +52,7 @@ module RuboCop
             ${nil? basic_literal? const_type?})
         PATTERN
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- the matched body is a literal or a constant
           redundant_fetch_block_candidate?(node) do |send, body|
             return if should_not_check?(send, body)
 

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

@@ -170,7 +170,10 @@ module RuboCop
             return 'a one-line pattern matching'
           end
           return 'an interpolated expression' if interpolation?(begin_node)
-          return 'a method argument' if argument_of_parenthesized_method_call?(begin_node, node)
+          if argument_of_parenthesized_method_call?(begin_node, node) &&
+             !keyword_logical_operator?(node)
+            return 'a method argument'
+          end
           return 'a one-line rescue' if oneline_rescue_parentheses_required?(begin_node, node)
 
           return if begin_node.chained?
@@ -315,6 +318,13 @@ module RuboCop
             (node.end.nil? && begin_node == parent.children.last)
         end
 
+        # `and`/`or` keyword operators bind looser than the method-argument
+        # boundary, so `foo((x and y))` cannot drop its parentheses without
+        # becoming a syntax error (unlike `&&`/`||`).
+        def keyword_logical_operator?(node)
+          node.operator_keyword? && node.semantic_operator?
+        end
+
         def disallowed_one_line_pattern_matching?(begin_node, node)
           if (parent = begin_node.parent)
             return false if parent.any_def_type? && parent.endless?

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

@@ -74,7 +74,7 @@ module RuboCop
 
           non_redundant =
             whitespace_in_free_space_mode?(node, class_elem) ||
-            backslash_b?(class_elem) || octal_requiring_char_class?(class_elem) ||
+            backslash_b?(class_elem) || backreference_requiring_char_class?(class_elem) ||
             requires_escape_outside_char_class?(class_elem)
 
           !non_redundant
@@ -104,10 +104,11 @@ module RuboCop
           elem == '\b'
         end
 
-        def octal_requiring_char_class?(elem)
-          # The octal escapes \1 to \7 only work inside a character class
-          # because they would be a backreference outside it.
-          elem.match?(/\A\\[1-7]\z/)
+        def backreference_requiring_char_class?(elem)
+          # `\1` to `\9` only match a literal digit inside a character class;
+          # outside it they are backreferences (and a syntax error when the
+          # referenced group does not exist), so the class is not redundant.
+          elem.match?(/\A\\[1-9]\z/)
         end
 
         def requires_escape_outside_char_class?(elem)

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

@@ -27,17 +27,17 @@ module RuboCop
         def_node_matcher :redundant_regexp_constructor, <<~PATTERN
           (send
             (const {nil? cbase} :Regexp) {:new :compile}
-            (regexp $... (regopt $...)))
+            $(regexp _* (regopt _*)))
         PATTERN
 
         def on_send(node)
-          return unless (regexp, regopt = redundant_regexp_constructor(node))
+          return unless (regexp = redundant_regexp_constructor(node))
 
           add_offense(node, message: format(MSG, method: node.method_name)) do |corrector|
-            pattern = regexp.map(&:source).join
-            regopt = regopt.join
-
-            corrector.replace(node, "/#{pattern}/#{regopt}")
+            # Reuse the inner literal's own source so its delimiters are preserved.
+            # Forcing `/.../` would break patterns like `%r{foo/bar}` that contain
+            # an unescaped slash.
+            corrector.replace(node, regexp.source)
           end
         end
       end

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

@@ -33,7 +33,7 @@ module RuboCop
 
         MSG = 'Name `%<method>s` block params `|%<params>s|`.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- checks block parameter names
           return unless node.single_line?
 
           return unless eligible_method?(node)

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

@@ -101,7 +101,7 @@ module RuboCop
                       'module (don\'t forget to require it) over `%<global>s`.'
         MSG_REGULAR = 'Prefer `%<prefer>s` over `%<global>s`.'
 
-        ENGLISH_VARS = { # rubocop:disable Style/MutableConstant
+        ENGLISH_VARS = { # rubocop:disable Style/MutableConstant -- merged into below, then frozen
           :$: => [:$LOAD_PATH],
           :$" => [:$LOADED_FEATURES],
           :$0 => [:$PROGRAM_NAME],

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

@@ -10,6 +10,10 @@ module RuboCop
       #   Autocorrection is unsafe because it will change the inheritance
       #   tree (e.g. return value of `Module#ancestors`) of the constant.
       #
+      #   It is also unsafe because constants that the class body resolves through its
+      #   ancestors (e.g. one provided by an included module) fall out of scope inside
+      #   the block.
+      #
       # @example
       #   # bad
       #   class Person < Struct.new(:first_name, :last_name)
@@ -39,6 +43,7 @@ module RuboCop
 
         def on_class(node)
           return unless struct_constructor?(node.parent_class)
+          return if defines_constants?(node.body)
 
           add_offense(node.parent_class) do |corrector|
             corrector.remove(
@@ -58,6 +63,15 @@ module RuboCop
 
         private
 
+        # Constants, including nested classes and modules, are scoped to the class when they
+        # are defined in a class body, but leak into the enclosing namespace once moved into a
+        # `Struct.new` block, so such a class cannot be rewritten as an assignment.
+        def defines_constants?(class_body)
+          return false unless class_body
+
+          class_body.each_node(:casgn, :class, :module).any?
+        end
+
         def correct_parent(parent, corrector)
           if parent.block_type?
             corrector.remove(range_with_surrounding_space(parent.loc.end, newlines: false))

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, InternalAffairs/ItblockHandler
+        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.rb

@@ -63,7 +63,6 @@ module RuboCop
       register_cop :DocumentationMethod, "#{__dir__}/style/documentation_method"
       register_cop :Documentation, "#{__dir__}/style/documentation"
       register_cop :DocumentDynamicEvalDefinition, "#{__dir__}/style/document_dynamic_eval_definition"
-      register_cop :DoubleCopDisableDirective, "#{__dir__}/style/double_cop_disable_directive"
       register_cop :DoubleNegation, "#{__dir__}/style/double_negation"
       register_cop :EachForSimpleLoop, "#{__dir__}/style/each_for_simple_loop"
       register_cop :EachWithObject, "#{__dir__}/style/each_with_object"

data/lib/rubocop/cop/util.rb

@@ -63,7 +63,7 @@ module RuboCop
           end
         else
           # Use a block version to avoid allocating enumerators.
-          node.each_descendant do # rubocop:disable Lint/UnreachableLoop
+          node.each_descendant do # rubocop:disable Lint/UnreachableLoop -- the block form avoids allocating an enumerator
             return true
           end
         end

data/lib/rubocop/cops_documentation_generator.rb

@@ -20,6 +20,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     safety:                ->(data) { safety_object(data.safety_objects, data.cop) },
     examples:              ->(data) { examples(data.example_objects, data.cop) },
     configuration:         ->(data) { configurations(data.cop.department, data.cop, data.config) },
+    preview:               ->(data) { preview_defaults(data.cop) },
     references:            ->(data) { references(data.cop, data.see_objects) }
   }.freeze
 
@@ -194,7 +195,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   def configurations(department, cop, cop_config)
     header = ['Name', 'Default value', 'Configurable values']
     configs = cop_config.each_key.reject do |key|
-      key == 'AllowMultipleStyles' ||
+      key == 'AllowMultipleStyles' || key == 'Preview' ||
         (key != 'SupportedTypes' && key.start_with?('Supported'))
     end
     return '' if configs.empty?
@@ -209,6 +210,22 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     cop_subsection('Configurable attributes', cop) + to_table(header, content)
   end
 
+  def preview_defaults(cop)
+    cop_config = config.for_cop(cop)
+    preview = cop_config['Preview']
+    return '' unless preview.is_a?(Hash)
+
+    header = ['Name', 'Current default', 'Preview default']
+    content = preview.map do |name, value|
+      [name, format_table_value(cop_config[name]), format_table_value(value)]
+    end
+
+    cop_subsection('Preview defaults', cop) +
+      'These defaults apply under xref:versioning.adoc#preview[Preview] and are ' \
+      "expected to become the regular defaults in the next major release.\n\n" +
+      to_table(header, content)
+  end
+
   def configuration_name(department, name)
     return name unless name == 'AllowMultilineFinalElement'
 
@@ -389,7 +406,11 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   def cop_status(status)
     return 'Disabled' unless status
 
-    status == 'pending' ? 'Pending' : 'Enabled'
+    case status
+    when 'pending' then 'Pending'
+    when 'preview' then 'Preview'
+    else 'Enabled'
+    end
   end
 
   # HTML anchor are somewhat limited in what characters they can contain, just