rubocop 1.70.0 → 1.71.1

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Use `node.type?(:foo, :bar)` instead of `node.foo_type? || node.bar_type?`,
+      # and `!node.type?(:foo, :bar)` instead of `!node.foo_type? && !node.bar_type?`.
+      #
+      # @example
+      #
+      #   # bad
+      #   node.str_type? || node.sym_type?
+      #
+      #   # good
+      #   node.type?(:str, :sym)
+      #
+      #   # bad
+      #   node.type?(:str, :sym) || node.boolean_type?
+      #
+      #   # good
+      #   node.type?(:str, :sym, :boolean)
+      #
+      #   # bad
+      #   !node.str_type? && !node.sym_type?
+      #
+      #   # good
+      #   !node.type?(:str, :sym)
+      #
+      #   # bad
+      #   !node.type?(:str, :sym) && !node.boolean_type?
+      #
+      #   # good
+      #   !node.type?(:str, :sym, :boolean)
+      #
+      class NodeTypeMultiplePredicates < Base
+        extend AutoCorrector
+
+        MSG_OR = 'Use `%<replacement>s` instead of checking for multiple node types.'
+        MSG_AND = 'Use `%<replacement>s` instead of checking against multiple node types.'
+
+        # @!method one_of_node_types?(node)
+        def_node_matcher :one_of_node_types?, <<~PATTERN
+          (or $(call _receiver #type_predicate?) (call _receiver #type_predicate?))
+        PATTERN
+
+        # @!method or_another_type?(node)
+        def_node_matcher :or_another_type?, <<~PATTERN
+          (or {
+            $(call _receiver :type? sym+) (call _receiver #type_predicate?) |
+            (call _receiver #type_predicate?) $(call _receiver :type? sym+)
+          })
+        PATTERN
+
+        # @!method none_of_node_types?(node)
+        def_node_matcher :none_of_node_types?, <<~PATTERN
+          (and
+            (send $(call _receiver #type_predicate?) :!)
+            (send (call _receiver #type_predicate?) :!)
+          )
+        PATTERN
+
+        # @!method and_not_another_type?(node)
+        def_node_matcher :and_not_another_type?, <<~PATTERN
+          (and {
+            (send $(call _receiver :type? sym+) :!) (send (call _receiver #type_predicate?) :!) |
+            (send (call _receiver #type_predicate?) :!) (send $(call _receiver :type? sym+) :!)
+          })
+        PATTERN
+
+        def on_or(node)
+          return unless (send_node = one_of_node_types?(node) || or_another_type?(node))
+          return unless send_node.receiver
+
+          replacement = replacement(node, send_node)
+          add_offense(node, message: format(MSG_OR, replacement: replacement)) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        def on_and(node)
+          return unless (send_node = none_of_node_types?(node) || and_not_another_type?(node))
+          return unless send_node.receiver
+
+          replacement = "!#{replacement(node, send_node)}"
+
+          add_offense(node, message: format(MSG_AND, replacement: replacement)) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def type_predicate?(method_name)
+          method_name.end_with?('_type?')
+        end
+
+        def replacement(node, send_node)
+          send_node = send_node.children.first if send_node.method?(:!)
+
+          types = types(node)
+          receiver = send_node.receiver.source
+          dot = send_node.loc.dot.source
+
+          "#{receiver}#{dot}type?(:#{types.join(', :')})"
+        end
+
+        def types(node)
+          [types_in_branch(node.lhs), types_in_branch(node.rhs)]
+        end
+
+        def types_in_branch(branch)
+          branch = branch.children.first if branch.method?(:!)
+
+          if branch.method?(:type?)
+            branch.arguments.map(&:value)
+          elsif branch.method?(:defined_type?)
+            # `node.defined_type?` relates to `node.type == :defined?`
+            'defined?'
+          else
+            branch.method_name.to_s.delete_suffix('_type?')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for cops that define `on_send` without define `on_csend`.
+      #
+      # Although in some cases it can be predetermined that safe navigation
+      # will never be used with the code checked by a specific cop, in general
+      # it is good practice to handle safe navigation methods if handling any
+      # `send` node.
+      #
+      # NOTE: It is expected to disable this cop for cops that check for method calls
+      # on receivers that cannot be nil (`self`, a literal, a constant), and
+      # method calls that will never have a receiver (ruby keywords like `raise`,
+      # macros like `attr_reader`, DSL methods, etc.), and other checks that wouldn't
+      # make sense to support safe navigation.
+      #
+      # @example
+      #   # bad
+      #   class MyCop < RuboCop::Cop:Base
+      #     def on_send(node)
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good - explicit method definition
+      #   class MyCop < RuboCop::Cop:Base
+      #     def on_send(node)
+      #       # ...
+      #     end
+      #
+      #     def on_csend(node)
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good - alias
+      #   class MyCop < RuboCop::Cop:Base
+      #     def on_send(node)
+      #       # ...
+      #     end
+      #     alias on_csend on_send
+      #   end
+      #
+      #   # good - alias_method
+      #   class MyCop < RuboCop::Cop:Base
+      #     def on_send(node)
+      #       # ...
+      #     end
+      #     alias_method :on_csend, :on_send
+      #   end
+      class OnSendWithoutOnCSend < Base
+        RESTRICT_ON_SEND = %i[alias_method].freeze
+        MSG = 'Cop defines `on_send` but not `on_csend`.'
+
+        def on_new_investigation
+          @on_send_definition = nil
+          @on_csend_definition = nil
+        end
+
+        def on_investigation_end
+          return unless @on_send_definition && !@on_csend_definition
+
+          add_offense(@on_send_definition)
+        end
+
+        def on_def(node)
+          @on_send_definition = node if node.method?(:on_send)
+          @on_csend_definition = node if node.method?(:on_csend)
+        end
+
+        def on_alias(node)
+          @on_send_definition = node if node.new_identifier.value == :on_send
+          @on_csend_definition = node if node.new_identifier.value == :on_csend
+        end
+
+        def on_send(node) # rubocop:disable InternalAffairs/OnSendWithoutOnCSend
+          new_identifier = node.first_argument
+          return unless new_identifier.basic_literal?
+
+          new_identifier = new_identifier.value
+
+          @on_send_definition = node if new_identifier == :on_send
+          @on_csend_definition = node if new_identifier == :on_csend
+        end
+      end
+    end
+  end
+end

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

@@ -47,7 +47,7 @@ module RuboCop
         # @!method redundant_source_range(node)
         def_node_matcher :redundant_source_range, <<~PATTERN
           {
-            (send $(send _ :source_range) :source)
+            (call $(call _ :source_range) :source)
             (send nil? :add_offense $(send _ :source_range) ...)
             (send _ {
               :replace :insert_before :insert_before_multi :insert_after :insert_after_multi
@@ -59,6 +59,7 @@ module RuboCop
 
         def on_send(node)
           return unless (source_range = redundant_source_range(node))
+          return unless source_range.receiver
           return if source_range.receiver.send_type? && source_range.receiver.method?(:buffer)
 
           selector = source_range.loc.selector
@@ -67,6 +68,7 @@ module RuboCop
             corrector.remove(source_range.loc.dot.join(selector))
           end
         end
+        alias on_csend on_send
       end
     end
   end

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

@@ -34,8 +34,8 @@ module RuboCop
         # @!method single_line_comparison(node)
         def_node_matcher :single_line_comparison, <<~PATTERN
           {
-            (send (send $_receiver {:line :first_line}) {:== :!=} (send _receiver :last_line))
-            (send (send $_receiver :last_line) {:== :!=} (send _receiver {:line :first_line}))
+            (send (call $_receiver {:line :first_line}) {:== :!=} (call _receiver :last_line))
+            (send (call $_receiver :last_line) {:== :!=} (call _receiver {:line :first_line}))
           }
         PATTERN
 
@@ -43,7 +43,8 @@ module RuboCop
           return unless (receiver = single_line_comparison(node))
 
           bang = node.method?(:!=) ? '!' : ''
-          preferred = "#{bang}#{extract_receiver(receiver)}.single_line?"
+          dot = receiver.parent.loc.dot.source
+          preferred = "#{bang}#{extract_receiver(receiver)}#{dot}single_line?"
 
           add_offense(node, message: format(MSG, preferred: preferred)) do |corrector|
             corrector.replace(node, preferred)
@@ -53,7 +54,7 @@ module RuboCop
         private
 
         def extract_receiver(node)
-          node = node.receiver if node.send_type? && %i[loc source_range].include?(node.method_name)
+          node = node.receiver if node.call_type? && %i[loc source_range].include?(node.method_name)
           node.source
         end
       end

data/lib/rubocop/cop/internal_affairs.rb

@@ -15,9 +15,12 @@ require_relative 'internal_affairs/method_name_equal'
 require_relative 'internal_affairs/node_destructuring'
 require_relative 'internal_affairs/node_first_or_last_argument'
 require_relative 'internal_affairs/node_matcher_directive'
+require_relative 'internal_affairs/node_pattern_groups'
+require_relative 'internal_affairs/node_type_multiple_predicates'
 require_relative 'internal_affairs/node_type_predicate'
 require_relative 'internal_affairs/numblock_handler'
 require_relative 'internal_affairs/offense_location_keyword'
+require_relative 'internal_affairs/on_send_without_on_csend'
 require_relative 'internal_affairs/operator_keyword'
 require_relative 'internal_affairs/processed_source_buffer_name'
 require_relative 'internal_affairs/redundant_context_config_parameter'

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Layout
       # Bare access modifiers (those not applying to specific methods) should be
-      # indented as deep as method definitions, or as deep as the class/module
+      # indented as deep as method definitions, or as deep as the `class`/`module`
       # keyword, depending on configuration.
       #
       # @example EnforcedStyle: indent (default)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Check that the arguments on a multi-line method definition are aligned.
+      # Check that the arguments on a multi-line method call are aligned.
       #
       # @example EnforcedStyle: with_first_argument (default)
       #   # good

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

@@ -188,7 +188,7 @@ module RuboCop
         # In offense message, we want to show the assignment LHS rather than
         # the entire assignment.
         def find_lhs_node(node)
-          node = node.lhs while node.op_asgn_type? || node.masgn_type?
+          node = node.lhs while node.type?(:op_asgn, :masgn)
           node
         end
 

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

@@ -3,23 +3,23 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks if the code style follows the ExpectedOrder configuration:
+      # Checks if the code style follows the `ExpectedOrder` configuration:
       #
       # `Categories` allows us to map macro names into a category.
       #
       # Consider an example of code style that covers the following order:
       #
-      # * Module inclusion (include, prepend, extend)
+      # * Module inclusion (`include`, `prepend`, `extend`)
       # * Constants
-      # * Associations (has_one, has_many)
-      # * Public attribute macros (attr_accessor, attr_writer, attr_reader)
-      # * Other macros (validates, validate)
+      # * Associations (`has_one`, `has_many`)
+      # * Public attribute macros (`attr_accessor`, `attr_writer`, `attr_reader`)
+      # * Other macros (`validates`, `validate`)
       # * Public class methods
       # * Initializer
       # * Public instance methods
-      # * Protected attribute macros (attr_accessor, attr_writer, attr_reader)
+      # * Protected attribute macros (`attr_accessor`, `attr_writer`, `attr_reader`)
       # * Protected instance methods
-      # * Private attribute macros (attr_accessor, attr_writer, attr_reader)
+      # * Private attribute macros (`attr_accessor`, `attr_writer`, `attr_reader`)
       # * Private instance methods
       #
       # You can configure the following order:
@@ -236,7 +236,7 @@ module RuboCop
 
           return [] unless class_def
 
-          if class_def.def_type? || class_def.send_type?
+          if class_def.type?(:def, :send)
             [class_def]
           else
             class_def.children.compact
@@ -289,7 +289,7 @@ module RuboCop
         def marked_as_private_constant?(node, name)
           return false unless node.method?(:private_constant)
 
-          node.arguments.any? { |arg| (arg.sym_type? || arg.str_type?) && arg.value == name }
+          node.arguments.any? { |arg| arg.type?(:sym, :str) && arg.value == name }
         end
 
         def end_position_for(node)

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

@@ -120,7 +120,7 @@ module RuboCop
         end
 
         def heredoc?(node)
-          (node.str_type? || node.dstr_type?) && node.heredoc?
+          node.type?(:str, :dstr) && node.heredoc?
         end
 
         def end_range(node)

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

@@ -162,7 +162,7 @@ module RuboCop
         private
 
         def def_location(correction_node)
-          if correction_node.block_type?
+          if correction_node.any_block_type?
             correction_node.source_range.join(correction_node.children.first.source_range)
           else
             correction_node.loc.keyword.join(correction_node.loc.name)
@@ -181,12 +181,12 @@ module RuboCop
         end
 
         def macro_candidate?(node)
-          node.block_type? && node.children.first.macro? &&
+          node.any_block_type? && node.children.first.macro? &&
             empty_line_between_macros.include?(node.children.first.method_name)
         end
 
         def method_candidate?(node)
-          cop_config['EmptyLineBetweenMethodDefs'] && (node.def_type? || node.defs_type?)
+          cop_config['EmptyLineBetweenMethodDefs'] && node.type?(:def, :defs)
         end
 
         def class_candidate?(node)
@@ -246,7 +246,7 @@ module RuboCop
         end
 
         def def_start(node)
-          if node.block_type? && node.children.first.send_type?
+          if node.any_block_type? && node.children.first.send_type?
             node.source_range.line
           else
             node.loc.keyword.line
@@ -258,7 +258,7 @@ module RuboCop
         end
 
         def end_loc(node)
-          if (node.def_type? || node.defs_type?) && node.endless?
+          if node.type?(:def, :defs) && node.endless?
             node.source_range.end
           else
             node.loc.end
@@ -283,6 +283,8 @@ module RuboCop
           case node.type
           when :def, :defs
             :method
+          when :numblock
+            :block
           else
             node.type
           end

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks if empty lines exist around the bodies of `begin`
       # sections. This cop doesn't check empty lines at `begin` body
       # beginning/end and around method definition body.
-      # `Style/EmptyLinesAroundBeginBody` or `Style/EmptyLinesAroundMethodBody`
+      # `Layout/EmptyLinesAroundBeginBody` or `Layout/EmptyLinesAroundMethodBody`
       # can be used for this purpose.
       #
       # @example

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

@@ -182,7 +182,7 @@ module RuboCop
         end
 
         def alignment_node_for_variable_style(node)
-          if (node.case_type? || node.case_match_type?) && node.argument? &&
+          if node.type?(:case, :case_match) && node.argument? &&
              same_line?(node, node.parent)
             return node.parent
           end

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

@@ -225,7 +225,7 @@ module RuboCop
 
         def base_range(send_node, arg_node)
           parent = send_node.parent
-          start_node = if parent && (parent.splat_type? || parent.kwsplat_type?)
+          start_node = if parent&.type?(:splat, :kwsplat)
                          send_node.parent
                        else
                          send_node

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

@@ -7,7 +7,7 @@ module RuboCop
       # where the opening brace and the first key are on separate lines. The
       # other keys' indentations are handled by the HashAlignment cop.
       #
-      # By default, Hash literals that are arguments in a method call with
+      # By default, `Hash` literals that are arguments in a method call with
       # parentheses, and where the opening curly brace of the hash is on the
       # same line as the opening parenthesis of the method call, shall have
       # their first key indented one step (two spaces) more than the position

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

@@ -51,7 +51,7 @@ module RuboCop
 
         def on_hash(node)
           # node.loc.begin tells us whether the hash opens with a {
-          # If it doesn't, Style/FirstMethodArgumentLineBreak will handle it
+          # If it doesn't, Layout/FirstMethodArgumentLineBreak will handle it
           return unless node.loc.begin
 
           check_children_line_break(node, node.children, ignore_last: ignore_last_element?)

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

@@ -5,10 +5,10 @@ module RuboCop
     module Layout
       # Checks the indentation of the first parameter in a method
       # definition. Parameters after the first one are checked by
-      # Layout/ParameterAlignment, not by this cop.
+      # `Layout/ParameterAlignment`, not by this cop.
       #
       # For indenting the first argument of method _calls_, check out
-      # Layout/FirstArgumentIndentation, which supports options related to
+      # `Layout/FirstArgumentIndentation`, which supports options related to
       # nesting that are irrelevant for method _definitions_.
       #
       # @example

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

@@ -102,7 +102,7 @@ module RuboCop
 
         def strings_concatenated_with_backslash?(dstr_node)
           dstr_node.multiline? &&
-            dstr_node.children.all? { |c| c.str_type? || c.dstr_type? } &&
+            dstr_node.children.all? { |c| c.type?(:str, :dstr) } &&
             dstr_node.children.none?(&:multiline?)
         end
 

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

@@ -52,7 +52,7 @@ module RuboCop
         def on_hash(node)
           # This cop only deals with hashes wrapped by a set of curly
           # braces like {foo: 1}. That is, not a kwargs hashes.
-          # Style/MultilineMethodArgumentLineBreaks handles those.
+          # Layout/MultilineMethodArgumentLineBreaks handles those.
           return unless starts_with_curly_brace?(node)
           return unless node.loc.begin
 

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

@@ -99,6 +99,7 @@ module RuboCop
 
           check_line_breaks(node, args, ignore_last: ignore_last_element?)
         end
+        alias on_csend on_send
 
         private
 

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

@@ -109,6 +109,7 @@ module RuboCop
         def on_send(node)
           check_brace_layout(node)
         end
+        alias on_csend on_send
 
         private
 

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

@@ -100,7 +100,7 @@ module RuboCop
 
         def extra_indentation(given_style, parent)
           if given_style == :indented_relative_to_receiver
-            if parent && (parent.splat_type? || parent.kwsplat_type?)
+            if parent&.type?(:splat, :kwsplat)
               configured_indentation_width - parent.loc.operator.length
             else
               configured_indentation_width
@@ -224,7 +224,7 @@ module RuboCop
         end
 
         def find_multiline_block_chain_node(node)
-          return unless (block_node = node.each_descendant(:block, :numblock).first)
+          return unless (block_node = node.each_descendant(:any_block).first)
           return unless block_node.multiline? && block_node.parent.call_type?
 
           if node.receiver.call_type?

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

@@ -103,13 +103,13 @@ module RuboCop
 
         def configured_to_not_be_inspected?(node)
           return true if other_cop_takes_precedence?(node)
+          return false if cop_config['InspectBlocks']
 
-          !cop_config['InspectBlocks'] && (node.block_type? ||
-                                           any_descendant?(node, :block, &:multiline?))
+          node.any_block_type? || any_descendant?(node, :any_block, &:multiline?)
         end
 
         def other_cop_takes_precedence?(node)
-          single_line_block_chain_enabled? && any_descendant?(node, :block) do |block_node|
+          single_line_block_chain_enabled? && any_descendant?(node, :any_block) do |block_node|
             block_node.parent.send_type? && block_node.parent.loc.dot && !block_node.multiline?
           end
         end
@@ -119,8 +119,9 @@ module RuboCop
         end
 
         def convertible_block?(node)
-          parent = node.parent
-          parent&.block_type? && node == parent.send_node &&
+          return false unless (parent = node.parent)
+
+          parent.any_block_type? && node == parent.send_node &&
             (node.parenthesized? || !node.arguments?)
         end
       end

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

@@ -29,7 +29,7 @@ module RuboCop
         MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
               'aligned with `%<beginning>s` at ' \
               '%<begin_loc_line>d, %<begin_loc_column>d.'
-        ANCESTOR_TYPES = %i[kwbegin def defs class module block numblock].freeze
+        ANCESTOR_TYPES = %i[kwbegin def defs class module any_block].freeze
         ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = %i[def defs].freeze
         ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method private_class_method].freeze
 

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

@@ -39,7 +39,7 @@ module RuboCop
 
         def offending_range(node)
           receiver = node.receiver
-          return unless receiver&.block_type?
+          return unless receiver&.any_block_type?
 
           receiver_location = receiver.loc
           closing_block_delimiter_line_num = receiver_location.end.line

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

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for colon (:) not followed by some kind of space.
+      # Checks for colon (`:`) not followed by some kind of space.
       # N.B. this cop does not handle spaces after a ternary operator, which are
-      # instead handled by Layout/SpaceAroundOperators.
+      # instead handled by `Layout/SpaceAroundOperators`.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for comma (,) not followed by some kind of space.
+      # Checks for comma (`,`) not followed by some kind of space.
       #
       # @example
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for semicolon (;) not followed by some kind of space.
+      # Checks for semicolon (`;`) not followed by some kind of space.
       #
       # @example
       #   # bad

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

@@ -36,6 +36,7 @@ module RuboCop
         ACCEPT_LEFT_PAREN = %w[break defined? next not rescue return super yield].freeze
         ACCEPT_LEFT_SQUARE_BRACKET = %w[super yield].freeze
         ACCEPT_NAMESPACE_OPERATOR = 'super'
+        RESTRICT_ON_SEND = %i[!].freeze
 
         def on_and(node)
           check(node, [:operator].freeze) if node.keyword?

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for comma (,) preceded by space.
+      # Checks for comma (`,`) preceded by space.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for semicolon (;) preceded by space.
+      # Checks for semicolon (`;`) preceded by space.
       #
       # @example
       #   # bad