rdoc 7.2.0 → 8.0.0

data/lib/rdoc/markup/to_html_crossref.rb

@@ -8,9 +8,7 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
 
   # :stopdoc:
   ALL_CROSSREF_REGEXP = RDoc::CrossReference::ALL_CROSSREF_REGEXP
-  CLASS_REGEXP_STR    = RDoc::CrossReference::CLASS_REGEXP_STR
   CROSSREF_REGEXP     = RDoc::CrossReference::CROSSREF_REGEXP
-  METHOD_REGEXP_STR   = RDoc::CrossReference::METHOD_REGEXP_STR
   # :startdoc:
 
   ##
@@ -29,15 +27,19 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
   # references are removed unless +show_hash+ is true.  Only method names
   # preceded by '#' or '::' are linked, unless +hyperlink_all+ is true.
 
-  def initialize(options, from_path, context, markup = nil)
+  def initialize(from_path, context, pipe: false, output_decoration: true,
+                 hyperlink_all: false, show_hash: false,
+                 autolink_excluded_words: [], warn_missing_rdoc_ref: true)
     raise ArgumentError, 'from_path cannot be nil' if from_path.nil?
 
-    super options, markup
+    super(pipe: pipe, output_decoration: output_decoration)
 
     @context       = context
     @from_path     = from_path
-    @hyperlink_all = @options.hyperlink_all
-    @show_hash     = @options.show_hash
+    @hyperlink_all = hyperlink_all
+    @show_hash     = show_hash
+    @autolink_excluded_words = autolink_excluded_words
+    @warn_missing_rdoc_ref = warn_missing_rdoc_ref
 
     @cross_reference = RDoc::CrossReference.new @context
   end
@@ -48,30 +50,30 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
 
     # The crossref must be linked before tidylink because Klass.method[:sym]
     # will be processed as a tidylink first and will be broken.
-    crossref_re = @options.hyperlink_all ? ALL_CROSSREF_REGEXP : CROSSREF_REGEXP
+    crossref_re = @hyperlink_all ? ALL_CROSSREF_REGEXP : CROSSREF_REGEXP
     @markup.add_regexp_handling crossref_re, :CROSSREF
   end
 
   ##
   # Creates a link to the reference +name+ if the name exists.  If +text+ is
   # given it is used as the link text, otherwise +name+ is used.
+  # Returns +nil+ if the link target could not be resolved.
 
   def cross_reference(name, text = nil, code = true, rdoc_ref: false)
-    lookup = name
+    # Strip '#' for link display text (e.g. #method shows as "method" in links)
+    display = !@show_hash && name.start_with?('#') ? name[1..] : name
 
-    name = name[1..-1] unless @show_hash if name[0, 1] == '#'
-
-    if !name.end_with?('+@', '-@') && match = name.match(/(.*[^#:])?@(.*)/)
+    if !display.end_with?('+@', '-@') && match = display.match(/(.*[^#:])?@(.*)/)
       context_name = match[1]
-      label = RDoc::Text.decode_legacy_label(match[2])
-      text ||= "#{label} at <code>#{context_name}</code>" if context_name
+      label = convert_string(RDoc::Text.decode_legacy_label(match[2]))
+      text ||= "#{label} at <code>#{convert_string(context_name)}</code>" if context_name
       text ||= label
       code = false
     else
-      text ||= name
+      text ||= convert_string(display)
     end
 
-    link lookup, text, code, rdoc_ref: rdoc_ref
+    link(name, text, code, rdoc_ref: rdoc_ref)
   end
 
   ##
@@ -83,7 +85,7 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
 
   def handle_regexp_CROSSREF(name)
     return convert_string(name) if in_tidylink_label?
-    return name if @options.autolink_excluded_words&.include?(name)
+    return name if @autolink_excluded_words&.include?(name)
 
     return name if name =~ /@[\w-]+\.[\w-]/ # labels that look like emails
 
@@ -93,8 +95,7 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
       # cross-references to "new" in text, for instance)
       return name if name =~ /\A[a-z]*\z/
     end
-
-    cross_reference name, rdoc_ref: false
+    cross_reference(name, rdoc_ref: false) || convert_string(name)
   end
 
   ##
@@ -106,7 +107,8 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
 
     case url
     when /\Ardoc-ref:/
-      cross_reference $', rdoc_ref: true
+      ref = $'
+      cross_reference(ref, rdoc_ref: true) || convert_string(ref)
     else
       super
     end
@@ -126,7 +128,8 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
       if in_tidylink_label?
         convert_string(url)
       else
-        cross_reference $', rdoc_ref: true
+        ref = $'
+        cross_reference(ref, rdoc_ref: true) || convert_string(ref)
       end
     else
       super
@@ -140,96 +143,119 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
   def gen_url(url, text)
     if url =~ /\Ardoc-ref:/
       name = $'
-      cross_reference name, text, name == text, rdoc_ref: true
+      cross_reference(name, text, name == text, rdoc_ref: true) || text
     else
       super
     end
   end
 
   ##
-  # Creates an HTML link to +name+ with the given +text+.
+  # Creates an HTML link to +name+ with the given +html_string+.
+  # +html_string+ should be already escaped and may contain HTML tags.
+  # Returns the link HTML string, or +nil+ if the reference could not be resolved.
 
-  def link(name, text, code = true, rdoc_ref: false)
+  def link(name, html_string, code = true, rdoc_ref: false)
     if !(name.end_with?('+@', '-@')) and name =~ /(.*[^#:])?@/
       name = $1
       label = $'
     end
 
-    ref = @cross_reference.resolve name, text if name
+    ref = @cross_reference.resolve name if name
 
-    case ref
-    when String then
-      if rdoc_ref && @options.warn_missing_rdoc_ref
-        puts "#{@from_path}: `rdoc-ref:#{name}` can't be resolved for `#{text}`"
-      end
-      ref
-    else
-      path = ref ? ref.as_href(@from_path) : +""
+    # Non-text source files (C, Ruby, etc.) don't get HTML pages generated,
+    # so don't auto-link to them. Explicit rdoc-ref: links are still allowed.
+    if !rdoc_ref && RDoc::TopLevel === ref && !ref.text?
+      return
+    end
+
+    if ref
+      path = ref.as_href(@from_path)
 
       if code and RDoc::CodeObject === ref and !(RDoc::TopLevel === ref)
-        text = "<code>#{CGI.escapeHTML text}</code>"
+        html_string = "<code>#{html_string}</code>"
       end
-
-      if label
-        # Decode legacy labels (e.g., "What-27s+Here" -> "What's Here")
-        # then convert to GitHub-style anchor format
-        decoded_label = RDoc::Text.decode_legacy_label(label)
-        formatted_label = RDoc::Text.to_anchor(decoded_label)
-
-        # Case 1: Path already has an anchor (e.g., method link)
-        #   Input:  C1#method@label -> path="C1.html#method-i-m"
-        #   Output: C1.html#method-i-m-label
-        if path =~ /#/
-          path << "-#{formatted_label}"
-
-        # Case 2: Label matches a section title
-        #   Input:  C1@Section -> path="C1.html", section "Section" exists
-        #   Output: C1.html#section (uses section.aref for GitHub-style)
-        elsif (section = ref&.sections&.find { |s| decoded_label == s.title })
-          path << "##{section.aref}"
-
-        # Case 3: Ref has an aref (class/module context)
-        #   Input:  C1@heading -> path="C1.html", ref=C1 class
-        #   Output: C1.html#class-c1-heading
-        elsif ref.respond_to?(:aref)
-          path << "##{ref.aref}-#{formatted_label}"
-
-        # Case 4: No context, just the label (e.g., TopLevel/file)
-        #   Input:  README@section -> path="README_md.html"
-        #   Output: README_md.html#section
-        else
-          path << "##{formatted_label}"
-        end
+    elsif name
+      if rdoc_ref && @warn_missing_rdoc_ref
+        puts "#{@from_path}: `rdoc-ref:#{name}` can't be resolved for `#{html_string}`"
       end
+      return
+    else
+      # A bare label reference like @foo still produces a valid anchor link
+      return unless label
+      path = +""
+    end
 
-      "<a href=\"#{path}\">#{text}</a>"
+    if label
+      # Decode legacy labels (e.g., "What-27s+Here" -> "What's Here")
+      # then convert to GitHub-style anchor format
+      decoded_label = RDoc::Text.decode_legacy_label(label)
+      formatted_label = RDoc::Text.to_anchor(decoded_label)
+
+      # Case 1: Path already has an anchor (e.g., method link)
+      #   Input:  C1#method@label -> path="C1.html#method-i-m"
+      #   Output: C1.html#method-i-m-label
+      if path =~ /#/
+        path << "-#{formatted_label}"
+
+      # Case 2: Label matches a section title
+      #   Input:  C1@Section -> path="C1.html", section "Section" exists
+      #   Output: C1.html#section (uses section.aref for GitHub-style)
+      elsif (section = ref&.sections&.find { |s| decoded_label == s.title })
+        path << "##{section.aref}"
+
+      # Case 3: Ref has an aref (class/module context)
+      #   Input:  C1@heading -> path="C1.html", ref=C1 class
+      #   Output: C1.html#class-c1-heading
+      elsif ref.respond_to?(:aref)
+        path << "##{ref.aref}-#{formatted_label}"
+
+      # Case 4: No context, just the label (e.g., TopLevel/file)
+      #   Input:  README@section -> path="README_md.html"
+      #   Output: README_md.html#section
+      else
+        path << "##{formatted_label}"
+      end
     end
+
+    "<a href=\"#{path}\">#{html_string}</a>"
   end
 
   def handle_TT(code)
-    emit_inline(tt_cross_reference(code) || "<code>#{CGI.escapeHTML code}</code>")
+    emit_inline(tt_cross_reference(code) || "<code>#{convert_string(code)}</code>")
   end
 
   # Applies additional special handling on top of the one defined in ToHtml.
   # When a tidy link is <tt>{Foo}[rdoc-ref:Foo]</tt>, the label part is surrounded by <tt><code></code></tt>.
   # TODO: reconsider this workaround.
   def apply_tidylink_label_special_handling(label, url)
-    if url == "rdoc-ref:#{label}" && cross_reference(label).include?('<code>')
+    if url == "rdoc-ref:#{label}" && cross_reference(label)&.include?('<code>')
       "<code>#{convert_string(label)}</code>"
     else
       super
     end
   end
 
+  # Handles cross-reference and suppressed-crossref inside tt tag.
+  # Returns nil if code is not an existing cross-reference nor a suppressed-crossref.
   def tt_cross_reference(code)
     return if in_tidylink_label?
 
-    crossref_regexp = @options.hyperlink_all ? ALL_CROSSREF_REGEXP : CROSSREF_REGEXP
-    match = crossref_regexp.match(code)
+    crossref_regexp = @hyperlink_all ? ALL_CROSSREF_REGEXP : CROSSREF_REGEXP
+    # REGEXP sometimes matches a string that starts with a backslash but is not a
+    # suppressed cross-reference (for example, `\+`), so the backslash-removed
+    # part needs to be checked against crossref_regexp.
+    match = crossref_regexp.match(code.delete_prefix('\\'))
     return unless match && match.begin(1).zero?
     return unless match.post_match.match?(/\A[[:punct:]\s]*\z/)
 
-    ref = cross_reference(code)
-    ref if ref != code
+    # cross_reference(file_page) may return a link without code tag.
+    # We need to check it because this method shouldn't return an html text without code tag.
+    if code.start_with?('\\')
+      # Remove leading backslash if crossref exists
+      "<code>#{convert_string(code[1..])}</code>" if cross_reference(code[1..])&.include?('<code>')
+    else
+      html = cross_reference(code)
+      html if html&.include?('<code>')
+    end
   end
 end

data/lib/rdoc/markup/to_html_snippet.rb

@@ -34,8 +34,8 @@ class RDoc::Markup::ToHtmlSnippet < RDoc::Markup::ToHtml
   # next word boundary after the given number of +characters+ or +paragraphs+
   # of text have been encountered.
 
-  def initialize(options, characters = 100, paragraphs = 3, markup = nil)
-    super options, markup
+  def initialize(characters = 100, paragraphs = 3)
+    super()
 
     @character_limit = characters
     @paragraph_limit = paragraphs
@@ -109,7 +109,7 @@ class RDoc::Markup::ToHtmlSnippet < RDoc::Markup::ToHtml
     input = verbatim.text.rstrip
     text = truncate(input, @character_limit - @characters)
     @characters += input.length
-    text << ' ...' unless text == input
+    text << " #{TO_HTML_CHARACTERS[text.encoding][:ellipsis]}" unless text == input
 
     super RDoc::Markup::Verbatim.new text
 
@@ -262,14 +262,14 @@ class RDoc::Markup::ToHtmlSnippet < RDoc::Markup::ToHtml
     return ['', 0] if limit <= 0
     @inline_character_limit = limit
     res = super
-    res << ' ...' if @inline_character_limit <= 0
+    res << " #{TO_HTML_CHARACTERS[text.encoding][:ellipsis]}" if @inline_character_limit <= 0
     @characters += limit - @inline_character_limit
     res
   end
 
   def to_html(item)
     throw :done if @characters >= @character_limit
-    to_html_characters(handle_inline(item))
+    handle_inline(item)
   end
 
   ##

data/lib/rdoc/markup/to_joined_paragraph.rb

@@ -8,11 +8,6 @@
 # other markup syntax items will not work.
 
 class RDoc::Markup::ToJoinedParagraph < RDoc::Markup::Formatter
-
-  def initialize # :nodoc:
-    super nil
-  end
-
   def start_accepting # :nodoc:
   end
 

data/lib/rdoc/markup/to_label.rb

@@ -14,8 +14,8 @@ class RDoc::Markup::ToLabel < RDoc::Markup::Formatter
   ##
   # Creates a new formatter that will output HTML-safe labels
 
-  def initialize(markup = nil)
-    super nil, markup
+  def initialize
+    super
 
     @markup.add_regexp_handling RDoc::CrossReference::CROSSREF_REGEXP, :CROSSREF
 

data/lib/rdoc/markup/to_markdown.rb

@@ -9,7 +9,7 @@ class RDoc::Markup::ToMarkdown < RDoc::Markup::ToRdoc
   ##
   # Creates a new formatter that will output Markdown format text
 
-  def initialize(markup = nil)
+  def initialize
     super
 
     @headings[1] = ['# ',      '']

data/lib/rdoc/markup/to_rdoc.rb

@@ -52,8 +52,8 @@ class RDoc::Markup::ToRdoc < RDoc::Markup::Formatter
   ##
   # Creates a new formatter that will output (mostly) \RDoc markup
 
-  def initialize(markup = nil)
-    super nil, markup
+  def initialize
+    super
 
     @markup.add_regexp_handling(/\\\S/, :SUPPRESSED_CROSSREF)
     @width = 78

data/lib/rdoc/markup/to_table_of_contents.rb

@@ -25,7 +25,7 @@ class RDoc::Markup::ToTableOfContents < RDoc::Markup::Formatter
   attr_accessor :omit_headings_below
 
   def initialize # :nodoc:
-    super nil
+    super
 
     @omit_headings_below = nil
   end

data/lib/rdoc/markup/to_tt_only.rb

@@ -15,13 +15,6 @@ class RDoc::Markup::ToTtOnly < RDoc::Markup::Formatter
 
   attr_reader :res
 
-  ##
-  # Creates a new tt-only formatter.
-
-  def initialize(markup = nil)
-    super nil, markup
-  end
-
   ##
   # Adds tts from +block_quote+ to the output
 

data/lib/rdoc/markup/verbatim.rb

@@ -9,7 +9,7 @@ class RDoc::Markup::Verbatim < RDoc::Markup::Raw
 
   attr_accessor :format
 
-  def initialize *parts # :nodoc:
+  def initialize(*parts) # :nodoc:
     super
 
     @format = nil

data/lib/rdoc/options.rb

@@ -74,23 +74,6 @@ require 'pathname'
 
 class RDoc::Options
 
-  ##
-  # The deprecated options.
-
-  DEPRECATED = {
-    '--accessor'      => 'support discontinued',
-    '--diagram'       => 'support discontinued',
-    '--help-output'   => 'support discontinued',
-    '--image-format'  => 'was an option for --diagram',
-    '--inline-source' => 'source code is now always inlined',
-    '--merge'         => 'ri now always merges class information',
-    '--one-file'      => 'support discontinued',
-    '--op-name'       => 'support discontinued',
-    '--opname'        => 'support discontinued',
-    '--promiscuous'   => 'files always only document their content',
-    '--ri-system'     => 'Ruby installers use other techniques',
-  }
-
   ##
   # RDoc options ignored (or handled specially) by --write-options
 
@@ -112,8 +95,8 @@ class RDoc::Options
     pipe
     rdoc_include
     root
+    server_port
     static_path
-    stylesheet_url
     template
     template_dir
     update_output_dir
@@ -346,6 +329,13 @@ class RDoc::Options
 
   attr_reader :visibility
 
+  ##
+  # When set to a port number, starts a live-reloading server instead of
+  # writing files.  Defaults to +false+ (no server).  Set via
+  # <tt>--server[=PORT]</tt>.
+
+  attr_reader :server_port
+
   ##
   # Indicates if files of test suites should be skipped
   attr_accessor :skip_tests
@@ -428,9 +418,9 @@ class RDoc::Options
     @output_decoration = true
     @rdoc_include = []
     @root = Pathname(Dir.pwd)
+    @server_port = false
     @show_hash = false
     @static_path = []
-    @stylesheet_url = nil # TODO remove in RDoc 4
     @tab_width = 8
     @template = nil
     @template_dir = nil
@@ -609,7 +599,12 @@ class RDoc::Options
     ivars.sort.each do |ivar|
       yaml[ivar] = instance_variable_get("@#{ivar}")
     end
-    yaml.to_yaml
+
+    if yaml.respond_to?(:to_yaml)
+      yaml.to_yaml
+    else
+      RDoc.yaml_serializer.dump(yaml)
+    end
   end
 
   ##
@@ -769,14 +764,6 @@ Usage: #{opt.program_name} [options] [names...]
       end
       opt.banner += "  - TomDoc:  Only in ruby files\n"
 
-      opt.banner += "\n  The following options are deprecated:\n\n"
-
-      name_length = DEPRECATED.keys.sort_by { |k| k.length }.last.length
-
-      DEPRECATED.sort_by { |k,| k }.each do |name, reason|
-        opt.banner += "    %*1$2$s  %3$s\n" % [-name_length, name, reason]
-      end
-
       opt.accept Template do |template|
         template_dir = template_dir_for template
 
@@ -913,7 +900,7 @@ Usage: #{opt.program_name} [options] [names...]
 
       opt.separator nil
 
-      opt.on("--visibility=VISIBILITY", "-V", RDoc::VISIBILITIES + [:nodoc],
+      opt.on("--visibility=VISIBILITY", RDoc::VISIBILITIES + [:nodoc],
              "Minimum visibility to document a method.",
              "One of 'public', 'protected' (the default),",
              "'private' or 'nodoc' (show everything)") do |value|
@@ -1013,14 +1000,6 @@ Usage: #{opt.program_name} [options] [names...]
         @op_dir = value
       end
 
-      opt.separator nil
-
-      opt.on("-d",
-             "Deprecated --diagram option.",
-             "Prevents firing debug mode",
-             "with legacy invocation.") do |value|
-      end
-
       opt.separator nil
       opt.separator 'HTML generator options:'
       opt.separator nil
@@ -1158,6 +1137,15 @@ Usage: #{opt.program_name} [options] [names...]
       opt.separator "Generic options:"
       opt.separator nil
 
+      opt.on("--server[=PORT]", Integer,
+             "Start a web server to preview",
+             "documentation with live reload.",
+             "Defaults to port 4000.") do |port|
+        @server_port = port || 4000
+      end
+
+      opt.separator nil
+
       opt.on("--write-options",
              "Write .rdoc_options to the current",
              "directory with the given options.  Not all",
@@ -1230,15 +1218,12 @@ Usage: #{opt.program_name} [options] [names...]
       opt.separator nil
     end
 
-    deprecated = []
     invalid = []
 
     begin
       opts.parse! argv
     rescue OptionParser::ParseError => e
-      if DEPRECATED[e.args.first] then
-        deprecated << e.args.first
-      elsif %w[--format --ri -r --ri-site -R].include? e.args.first then
+      if %w[--format --ri -r --ri-site -R].include? e.args.first then
         raise
       else
         invalid << e.args.join(' ')
@@ -1254,12 +1239,6 @@ Usage: #{opt.program_name} [options] [names...]
       invalid << '-p (with files)'
     end
 
-    unless quiet then
-      deprecated.each do |opt|
-        $stderr.puts 'option ' + opt + ' is deprecated: ' + DEPRECATED[opt]
-      end
-    end
-
     unless invalid.empty? then
       invalid = "invalid options: #{invalid.join ', '}"
 
@@ -1405,10 +1384,16 @@ Usage: #{opt.program_name} [options] [names...]
 
     RDoc.load_yaml
 
-    begin
-      options = YAML.safe_load File.read('.rdoc_options'), permitted_classes: [RDoc::Options, Symbol]
-    rescue Psych::SyntaxError
-      raise RDoc::Error, "#{options_file} is not a valid rdoc options file"
+    content = File.read('.rdoc_options')
+
+    if defined?(Psych)
+      begin
+        options = Psych.safe_load content, permitted_classes: [RDoc::Options, Symbol]
+      rescue Psych::SyntaxError
+        raise RDoc::Error, "#{options_file} is not a valid rdoc options file"
+      end
+    else
+      options = RDoc.yaml_serializer.load(content)
     end
 
     return RDoc::Options.new unless options # Allow empty file.

data/lib/rdoc/parser/c.rb

@@ -248,7 +248,7 @@ class RDoc::Parser::C < RDoc::Parser
   # method that reference the same function.
 
   def add_alias(var_name, class_obj, old_name, new_name, comment)
-    al = RDoc::Alias.new '', old_name, new_name, comment, singleton: @singleton_classes.key?(var_name)
+    al = RDoc::Alias.new old_name, new_name, comment, singleton: @singleton_classes.key?(var_name)
     al.record_location @top_level
     class_obj.add_alias al
     @stats.add_alias al
@@ -683,6 +683,7 @@ class RDoc::Parser::C < RDoc::Parser
       container.name = base_name if base_name
 
       container.record_location @top_level
+      @top_level.add_to_classes_or_modules container
       @classes[raw_name] = container
     end
     @classes[raw_name]
@@ -847,7 +848,7 @@ class RDoc::Parser::C < RDoc::Parser
 
     name = attr_name.gsub(/rb_intern(?:_const)?\("([^"]+)"\)/, '\1')
 
-    attr = RDoc::Attr.new '', name, rw, comment
+    attr = RDoc::Attr.new name, rw, comment
 
     attr.record_location @top_level
     class_obj.add_attribute attr
@@ -898,6 +899,7 @@ class RDoc::Parser::C < RDoc::Parser
     end
 
     cm.record_location enclosure.top_level
+    enclosure.top_level.add_to_classes_or_modules cm
 
     find_class_comment cm.full_name, cm
 
@@ -1005,7 +1007,7 @@ class RDoc::Parser::C < RDoc::Parser
       end
 
       singleton = singleton || %w[singleton_method module_function].include?(type)
-      meth_obj = RDoc::AnyMethod.new '', meth_name, singleton: singleton
+      meth_obj = RDoc::AnyMethod.new meth_name, singleton: singleton
       meth_obj.c_function = function
 
       p_count = Integer(param_count) rescue -1
@@ -1014,7 +1016,7 @@ class RDoc::Parser::C < RDoc::Parser
         file_name = File.join @file_dir, source_file
 
         if File.exist? file_name then
-          file_content = File.read file_name
+          file_content = RDoc::Encoding.read_file file_name, @options.encoding
         else
           @options.warn "unknown source #{source_file} for #{meth_name} in #{@file_name}"
         end
@@ -1089,11 +1091,10 @@ class RDoc::Parser::C < RDoc::Parser
   # Look for directives in a normal comment block:
   #
   #   /*
-  #    * :title: My Awesome Project
+  #    * :nodoc:
   #    */
   #
   # This method modifies the +comment+
-  # Both :main: and :title: directives are deprecated and will be removed in RDoc 7.
 
   def look_for_directives_in(context, comment)
     comment.text, format = @preprocess.run_pre_processes(comment.text, context, comment.line || 1, :c)