class RDoc::Options

RDoc::Options handles the parsing and storage of options

Saved Options ↑

You can save some options like the markup format in the .rdoc_options file in your gem. The easiest way to do this is:

rdoc --markup tomdoc --write-options

Which will automatically create the file and fill it with the options you specified.

The following options will not be saved since they interfere with the user’s preferences or with the normal operation of RDoc:

  • --coverage-report

  • --dry-run

  • --encoding

  • --force-update

  • --format

  • --pipe

  • --quiet

  • --template

  • --verbose

Custom Options ↑

Generators can hook into RDoc::Options to add generator-specific command line options.

When --format is encountered in ARGV, RDoc calls ::setup_options on the generator class to add extra options to the option parser. Options for custom generators must occur after --format. rdoc --help will list options for all installed generators.

Example:

class RDoc::Generator::Spellcheck
  RDoc::RDoc.add_generator self

  def self.setup_options rdoc_options
    op = rdoc_options.option_parser

    op.on('--spell-dictionary DICTIONARY',
          RDoc::Options::Path) do |dictionary|
      rdoc_options.spell_dictionary = dictionary
    end
  end
end

Of course, RDoc::Options does not respond to spell_dictionary by default so you will need to add it:

class RDoc::Options

  ##
  # The spell dictionary used by the spell-checking plugin.

  attr_accessor :spell_dictionary

end

Option Validators ↑

OptionParser validators will validate and cast user input values. In addition to the validators that ship with OptionParser (String, Integer, Float, TrueClass, FalseClass, Array, Regexp, Date, Time, URI, etc.), RDoc::Options adds Path, PathArray and Template.

Constants

DEFAULT_EXCLUDE
Directory

Option validator for OptionParser that matches a directory that exists on the filesystem.

Path

Option validator for OptionParser that matches a file or directory that exists on the filesystem.

PathArray

Option validator for OptionParser that matches a comma-separated list of files or directories that exist on the filesystem.

SPECIAL

RDoc options ignored (or handled specially) by –write-options

Template

Option validator for OptionParser that matches a template directory for an installed generator that lives in "rdoc/generator/template/#{template_name}"

Attributes

apply_default_exclude [R]

Exclude the default patterns as well if true.

canonical_root [RW]

The preferred root URL for the documentation

charset [RW]

Character-set for HTML output. encoding is preferred over charset

class_module_path_prefix [RW]

The prefix to use for class and module page paths

coverage_report [RW]

If true, only report on undocumented files

dry_run [RW]

If true, RDoc will not write any files.

embed_mixins [RW]

Embed mixin methods, attributes, and constants into class documentation. Set via --[no-]embed-mixins (Default is false.)

encoding [RW]

The output encoding. All input files will be transcoded to this encoding.

The default encoding is UTF-8. This is set via –encoding.

exclude [W]

Files matching this pattern will be excluded

file_path_prefix [RW]

The prefix to use for file page paths

files [RW]

The list of files to be processed

footer_content [RW]

Custom footer content configuration for themes that support it. Currently only supported by the Aliki theme.

A hash where keys are column titles and values are hashes of link text => URL pairs. Each column will be displayed in the upper footer section.

Example:

{
  "DOCUMENTATION" => {"Home" => "/index.html", "Guide" => "/guide.html"},
  "RESOURCES" => {"RDoc" => "https://ruby.github.io/rdoc/", "GitHub" => "https://github.com/ruby/rdoc"}
}
force_output [RW]

Create the output even if the output directory does not look like an rdoc output directory

force_update [RW]

Scan newer sources than the flag file if true.

formatter [RW]

Formatter to mark up text with

generator [RW]

Description of the output generator (set with the --format option)

generator_options [RW]

Loaded generator options. Used to prevent –help from loading the same options multiple times.

line_numbers [RW]

Include line numbers in the source code

locale [RW]

The output locale.

locale_dir [RW]

The directory where locale data live.

main_page [RW]

Name of the file, class or module to display in the initial index page (if not specified the first file we encounter is used)

markup [RW]

The markup format. One of: rdoc (the default), markdown, rd, tomdoc. See Markup Formats.

op_dir [RW]

The name of the output directory

option_parser [RW]

The OptionParser for this instance

output_decoration [RW]

Output heading decorations?

page_dir [RW]

Directory where guides, FAQ, and other pages not associated with a class live. You may leave this unset if these are at the root of your project.

pipe [RW]

Is RDoc in pipe mode?

rdoc_include [RW]

Array of directories to search for files to satisfy an :include:

root [RW]

Root of the source documentation will be generated for. Set this when building documentation outside the source directory. Defaults to the current directory.

server_port [R]

When set to a port number, starts a live-reloading server instead of writing files. Defaults to false (no server). Set via --server[=PORT].

show_hash [RW]

Include the ‘#’ at the front of hyperlinked instance method names

skip_tests [RW]

Indicates if files of test suites should be skipped

static_path [RW]

Directory to copy static files from

tab_width [RW]

The number of columns in a tab

template [RW]

Template to be used when generating output

template_dir [RW]

Directory the template lives in

template_stylesheets [RW]

Additional template stylesheets

title [RW]

Documentation title

update_output_dir [RW]

Should RDoc update the timestamps in the output dir?

verbosity [RW]

Verbosity, zero means quiet

visibility [R]

Minimum visibility of a documented method. One of :public, :protected, :private or :nodoc.

The :nodoc visibility ignores all directives related to visibility. The other visibilities may be overridden on a per-method basis with the :doc: directive.

warn_missing_rdoc_ref [RW]

Warn if rdoc-ref links can’t be resolved Default is true

webcvs [RW]

URL of web cvs frontend

Public Class Methods

load_options ()

Loads options from .rdoc_options if the file exists, otherwise creates a new RDoc::Options instance.

# File lib/rdoc/options.rb, line 1382
def self.load_options
  options_file = File.expand_path '.rdoc_options'
  return Options.new unless File.exist? options_file

  ::RDoc.load_yaml

  content = File.read('.rdoc_options')

  if defined?(Psych)
    begin
      options = Psych.safe_load content, permitted_classes: [Options, Symbol]
    rescue Psych::SyntaxError
      raise Error, "#{options_file} is not a valid rdoc options file"
    end
  else
    options = ::RDoc.yaml_serializer.load(content)
  end

  return Options.new unless options # Allow empty file.

  raise Error, "#{options_file} is not a valid rdoc options file" unless
    Options === options or Hash === options

  if Hash === options
    # Override the default values with the contents of YAML file.
    options = Options.new options
  end

  options
end

Public Instance Methods

check_files ()

Check that the files on the command line exist

# File lib/rdoc/options.rb, line 548
def check_files
  @files.delete_if do |file|
    if File.exist? file
      if File.readable? file
        false
      else
        warn "file '#{file}' not readable"

        true
      end
    else
      warn "file '#{file}' not found"

      true
    end
  end
end
check_generator ()

Ensure only one generator is loaded

# File lib/rdoc/options.rb, line 569
def check_generator
  if @generator
    raise OptionParser::InvalidOption,
      "generator already set to #{@generator_name}"
  end
end
default_title= (string)

Set the title, but only if not already set. Used to set the title from a source file, so that a title set from the command line will have the priority.

# File lib/rdoc/options.rb, line 581
def default_title=(string)
  @title ||= string
end
exclude ()

Create a regexp for exclude

# File lib/rdoc/options.rb, line 614
def exclude
  if @exclude.nil? or Regexp === @exclude
    # done, #finish is being re-run
    @exclude
  elsif !@apply_default_exclude and @exclude.empty?
    nil
  else
    exclude = @exclude
    exclude |= DEFAULT_EXCLUDE if @apply_default_exclude
    Regexp.new(exclude.join("|"))
  end
end
finish ()

Completes any unfinished option setup business such as filtering for existent files, creating a regexp for exclude and setting a default template.

# File lib/rdoc/options.rb, line 632
def finish
  if @write_options
    write_options
    exit
  end

  @op_dir ||= 'doc'

  root = @root.to_s
  if @rdoc_include.empty? || !@rdoc_include.include?(root)
    @rdoc_include << root
  end

  @exclude = self.exclude

  finish_page_dir

  check_files

  # If no template was specified, use the default template for the output
  # formatter

  unless @template
    @template     = @generator_name
    @template_dir = template_dir_for @template
  end

  if @locale_name
    @locale = I18n::Locale[@locale_name]
    @locale.load(@locale_dir)
  else
    @locale = nil
  end

  self
end
finish_page_dir ()

Fixes the page_dir to be relative to the root_dir and adds the page_dir to the files list.

# File lib/rdoc/options.rb, line 673
def finish_page_dir
  return unless @page_dir

  @files << @page_dir

  page_dir = Pathname(@page_dir)
  begin
    page_dir = page_dir.expand_path.relative_path_from @root
  rescue ArgumentError
    # On Windows, sometimes crosses different drive letters.
    page_dir = page_dir.expand_path
  end

  @page_dir = page_dir
end
generator_descriptions ()

Returns a properly-space list of generators and their descriptions.

# File lib/rdoc/options.rb, line 692
def generator_descriptions
  lengths = []

  generators = RDoc::GENERATORS.map do |name, generator|
    lengths << name.length

    description = generator::DESCRIPTION if
      generator.const_defined? :DESCRIPTION

    [name, description]
  end

  longest = lengths.max

  generators.sort.map do |name, description|
    if description
      "  %-*s - %s" % [longest, name, description]
    else
      "  #{name}"
    end
  end.join "\n"
end
parse (argv)

Parses command line options.

# File lib/rdoc/options.rb, line 718
    def parse(argv)
      ignore_invalid = true

      argv.insert(0, *ENV['RDOCOPT'].split) if ENV['RDOCOPT']

      opts = OptionParser.new do |opt|
        @option_parser = opt
        opt.program_name = File.basename $0
        opt.version = VERSION
        opt.release = nil
        opt.summary_indent = ' ' * 4
        opt.banner = <<-EOF
Usage: #{opt.program_name} [options] [names...]

  Files are parsed, and the information they contain collected, before any
  output is produced. This allows cross references between all files to be
  resolved. If a name is a directory, it is traversed. If no names are
  specified, all Ruby files in the current directory (and subdirectories) are
  processed.

  How RDoc generates output depends on the output formatter being used, and on
  the options you give.

  Options can be specified via the RDOCOPT environment variable, which
  functions similar to the RUBYOPT environment variable for ruby.

    $ export RDOCOPT="--show-hash"

  will make rdoc show hashes in method links by default.  Command-line options
  always will override those in RDOCOPT.

  Available formatters:

#{generator_descriptions}

  RDoc understands the following file formats:

      EOF

        parsers = Hash.new { |h, parser| h[parser] = [] }

        Parser.parsers.each do |regexp, parser|
          parsers[parser.name.sub('RDoc::Parser::', '')] << regexp.source
        end

        parsers.sort.each do |parser, regexp|
          opt.banner += "  - #{parser}: #{regexp.join ', '}\n"
        end
        opt.banner += "  - TomDoc:  Only in ruby files\n"

        opt.accept Template do |template|
          template_dir = template_dir_for template

          unless template_dir
            $stderr.puts "could not find template #{template}"
            nil
          else
            [template, template_dir]
          end
        end

        opt.accept Directory do |directory|
          directory = File.expand_path directory

          raise OptionParser::InvalidArgument unless File.directory? directory

          directory
        end

        opt.accept Path do |path|
          path = File.expand_path path

          raise OptionParser::InvalidArgument unless File.exist? path

          path
        end

        opt.accept PathArray do |paths,|
          paths = if paths
                    paths.split(',').map { |d| d unless d.empty? }
                  end

          paths.map do |path|
            path = File.expand_path path

            raise OptionParser::InvalidArgument unless File.exist? path

            path
          end
        end

        opt.separator nil
        opt.separator "Parsing options:"
        opt.separator nil

        opt.on("--encoding=ENCODING", "-e", ::Encoding.list.map { |e| e.name },
               "Specifies the output encoding.  All files",
               "read will be converted to this encoding.",
               "The default encoding is UTF-8.",
               "--encoding is preferred over --charset") do |value|
                 @encoding = ::Encoding.find value
                 @charset = @encoding.name # may not be valid value
               end

        opt.separator nil

        opt.on("--locale=NAME",
               "Specifies the output locale.") do |value|
          @locale_name = value
        end

        opt.on("--locale-data-dir=DIR",
               "Specifies the directory where locale data live.") do |value|
          @locale_dir = value
        end

        opt.separator nil

        opt.on("--all", "-a",
               "Synonym for --visibility=private.") do |value|
          @visibility = :private
        end

        opt.separator nil

        opt.on("--exclude=PATTERN", "-x", Regexp,
               "Do not process files or directories",
               "matching PATTERN.") do |value|
          @exclude << value
        end

        opt.on("--[no-]apply-default-exclude",
               "Use default PATTERN to exclude.") do |value|
          @apply_default_exclude = value
        end

        opt.separator nil

        opt.on("--no-skipping-tests", nil,
               "Don't skip generating documentation for test and spec files") do |value|
          @skip_tests = false
        end

        opt.separator nil

        opt.on("--extension=NEW=OLD", "-E",
               "Treat files ending with .new as if they",
               "ended with .old. Using '-E cgi=rb' will",
               "cause xxx.cgi to be parsed as a Ruby file.") do |value|
          new, old = value.split(/=/, 2)

          unless new and old
            raise OptionParser::InvalidArgument, "Invalid parameter to '-E'"
          end

          unless Parser.alias_extension old, new
            raise OptionParser::InvalidArgument, "Unknown extension .#{old} to -E"
          end
        end

        opt.separator nil

        opt.on("--[no-]force-update", "-U",
               "Forces rdoc to scan all sources even if",
               "no files are newer than the flag file.") do |value|
          @force_update = value
        end

        opt.separator nil

        opt.on("--pipe", "-p",
               "Convert RDoc on stdin to HTML") do
          @pipe = true
        end

        opt.separator nil

        opt.on("--tab-width=WIDTH", "-w", Integer,
               "Set the width of tab characters.") do |value|
          raise OptionParser::InvalidArgument,
                "#{value} is an invalid tab width" if value <= 0
          @tab_width = value
        end

        opt.separator nil

        opt.on("--visibility=VISIBILITY", VISIBILITIES + [:nodoc],
               "Minimum visibility to document a method.",
               "One of 'public', 'protected' (the default),",
               "'private' or 'nodoc' (show everything)") do |value|
          @visibility = value
        end

        opt.separator nil

        opt.on("--[no-]embed-mixins",
               "Embed mixin methods, attributes, and constants",
               "into class documentation. (default false)") do |value|
          @embed_mixins = value
        end

        opt.separator nil

        markup_formats = Text::MARKUP_FORMAT.keys.sort

        opt.on("--markup=MARKUP", markup_formats,
               "The markup format for the named files.",
               "The default is rdoc.  Valid values are:",
               markup_formats.join(', ')) do |value|
          @markup = value
        end

        opt.separator nil

        opt.on("--root=ROOT", Directory,
               "Root of the source tree documentation",
               "will be generated for.  Set this when",
               "building documentation outside the",
               "source directory.  Default is the",
               "current directory.") do |root|
          @root = Pathname(root)
        end

        opt.separator nil

        opt.on("--page-dir=DIR", Directory,
               "Directory where guides, your FAQ or",
               "other pages not associated with a class",
               "live.  Set this when you don't store",
               "such files at your project root.",
               "NOTE: Do not use the same file name in",
               "the page dir and the root of your project") do |page_dir|
          @page_dir = page_dir
        end

        opt.separator nil
        opt.separator "Common generator options:"
        opt.separator nil

        opt.on("--force-output", "-O",
               "Forces rdoc to write the output files,",
               "even if the output directory exists",
               "and does not seem to have been created",
               "by rdoc.") do |value|
          @force_output = value
        end

        opt.separator nil

        generator_text = @generators.keys.map { |name| "  #{name}" }.sort

        opt.on("-f", "--fmt=FORMAT", "--format=FORMAT", @generators.keys,
               "Set the output formatter.  One of:", *generator_text) do |value|
          check_generator

          @generator_name = value.downcase
          setup_generator
        end

        opt.separator nil

        opt.on("--include=DIRECTORIES", "-i", PathArray,
               "Set (or add to) the list of directories to",
               "be searched when satisfying :include:",
               "requests. Can be used more than once.") do |value|
          @rdoc_include.concat value.map { |dir| dir.strip }
        end

        opt.separator nil

        opt.on("--[no-]coverage-report=[LEVEL]", "--[no-]dcov", "-C", Integer,
               "Prints a report on undocumented items.",
               "Does not generate files.") do |value|
          value = 0 if value.nil? # Integer converts -C to nil

          @coverage_report = value
          @force_update = true if value
        end

        opt.separator nil

        opt.on("--output=DIR", "--op", "-o",
               "Set the output directory.") do |value|
          @op_dir = value
        end

        opt.separator nil
        opt.separator 'HTML generator options:'
        opt.separator nil

        opt.on("--charset=CHARSET", "-c",
               "Specifies the output HTML character-set.",
               "Use --encoding instead of --charset if",
               "available.") do |value|
          @charset = value
        end

        opt.separator nil

        opt.on("--autolink-excluded-words=WORDS", Array,
               "Words to be ignored in autolink cross-references") do |value|
          @autolink_excluded_words.concat value
        end

        opt.separator nil

        opt.on("--hyperlink-all", "-A",
               "Generate hyperlinks for all words that",
               "correspond to known methods, even if they",
               "do not start with '#' or '::' (legacy",
               "behavior).") do |value|
          @hyperlink_all = value
        end

        opt.separator nil

        opt.on("--main=NAME", "-m",
               "NAME will be the initial page displayed.") do |value|
          @main_page = value
        end

        opt.separator nil

        opt.on("--[no-]line-numbers", "-N",
               "Include line numbers in the source code.",
               "By default, only the number of the first",
               "line is displayed, in a leading comment.") do |value|
          @line_numbers = value
        end

        opt.separator nil

        opt.on("--show-hash", "-H",
               "A name of the form #name in a comment is a",
               "possible hyperlink to an instance method",
               "name. When displayed, the '#' is removed",
               "unless this option is specified.") do |value|
          @show_hash = value
        end

        opt.separator nil

        opt.on("--template=NAME", "-T", Template,
               "Set the template used when generating",
               "output. The default depends on the",
               "formatter used.") do |(template, template_dir)|
          @template     = template
          @template_dir = template_dir
        end

        opt.separator nil

        opt.on("--template-stylesheets=FILES", PathArray,
               "Set (or add to) the list of files to",
               "include with the html template.") do |value|
          @template_stylesheets.concat value
        end

        opt.separator nil

        opt.on("--title=TITLE", "-t",
               "Set TITLE as the title for HTML output.") do |value|
          @title = value
        end

        opt.separator nil

        opt.on("--copy-files=PATH", Path,
               "Specify a file or directory to copy static",
               "files from.",
               "If a file is given it will be copied into",
               "the output dir.  If a directory is given the",
               "entire directory will be copied.",
               "You can use this multiple times") do |value|
          @static_path << value
        end

        opt.separator nil

        opt.on("--webcvs=URL", "-W",
               "Specify a URL for linking to a web frontend",
               "to CVS. If the URL contains a '\%s', the",
               "name of the current file will be",
               "substituted; if the URL doesn't contain a",
               "'\%s', the filename will be appended to it.") do |value|
          @webcvs = value
        end

        opt.separator nil
        opt.separator "ri generator options:"
        opt.separator nil

        opt.on("--ri", "-r",
               "Generate output for use by `ri`. The files",
               "are stored in the '.rdoc' directory under",
               "your home directory unless overridden by a",
               "subsequent --op parameter, so no special",
               "privileges are needed.") do |value|
          check_generator

          @generator_name = "ri"
          @op_dir ||= RI::Paths::HOMEDIR
          setup_generator
        end

        opt.separator nil

        opt.on("--ri-site", "-R",
               "Generate output for use by `ri`. The files",
               "are stored in a site-wide directory,",
               "making them accessible to others, so",
               "special privileges are needed.") do |value|
          check_generator

          @generator_name = "ri"
          @op_dir = RI::Paths.site_dir
          setup_generator
        end

        opt.separator nil
        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",
               "options will be used.  See RDoc::Options",
               "for details.") do |value|
          @write_options = true
        end

        opt.separator nil

        opt.on("--[no-]dry-run",
               "Don't write any files") do |value|
          @dry_run = value
        end

        opt.separator nil

        opt.on("-D", "--[no-]debug",
               "Displays lots on internal stuff.") do |value|
          $DEBUG_RDOC = value
        end

        opt.separator nil

        opt.on("--warn-missing-rdoc-ref",
               "Warn if rdoc-ref links can't be resolved") do |value|
          @warn_missing_rdoc_ref = value
        end

        opt.separator nil

        opt.on("--[no-]ignore-invalid",
               "Ignore invalid options and continue",
               "(default true).") do |value|
          ignore_invalid = value
        end

        opt.separator nil

        opt.on("--quiet", "-q",
               "Don't show progress as we parse.") do |value|
          @verbosity = 0
        end

        opt.separator nil

        opt.on("--verbose", "-V",
               "Display extra progress as RDoc parses") do |value|
          @verbosity = 2
        end

        opt.separator nil

        opt.on("--version", "-v", "print the version") do
          puts opt.version
          exit
        end

        opt.separator nil

        opt.on("--help", "-h", "Display this help") do
          RDoc::GENERATORS.each_key do |generator|
            setup_generator generator
          end

          puts opt.help
          exit
        end

        opt.separator nil
      end

      invalid = []

      begin
        opts.parse! argv
      rescue OptionParser::ParseError => e
        if %w[--format --ri -r --ri-site -R].include? e.args.first
          raise
        else
          invalid << e.args.join(' ')
        end

        retry
      end

      setup_generator unless @generator

      if @pipe and not argv.empty?
        @pipe = false
        invalid << '-p (with files)'
      end

      unless invalid.empty?
        invalid = "invalid options: #{invalid.join ', '}"

        if ignore_invalid
          unless quiet
            $stderr.puts invalid
            $stderr.puts '(invalid options are ignored)'
          end
        else
          unless quiet
            $stderr.puts opts
          end
          $stderr.puts invalid
          exit 1
        end
      end

      @files = argv.dup

      self
    end
quiet ()

Don’t display progress as we process the files

# File lib/rdoc/options.rb, line 1268
def quiet
  @verbosity.zero?
end
quiet= (bool)

Set quietness to bool

# File lib/rdoc/options.rb, line 1275
def quiet=(bool)
  @verbosity = bool ? 0 : 1
end
sanitize_path (path)

Removes directories from path that are outside the current directory

# File lib/rdoc/options.rb, line 1282
def sanitize_path(path)
  require 'pathname'
  dot = Pathname.new('.').expand_path

  path.reject do |item|
    path = Pathname.new(item).expand_path
    is_reject = nil
    relative = nil
    begin
      relative = path.relative_path_from(dot).to_s
    rescue ArgumentError
      # On Windows, sometimes crosses different drive letters.
      is_reject = true
    else
      is_reject = relative.start_with? '..'
    end
    is_reject
  end
end
setup_generator (generator_name = @generator_name)

Set up an output generator for the named generator_name.

If the found generator responds to :setup_options it will be called with the options instance. This allows generators to add custom options or set default options.

# File lib/rdoc/options.rb, line 1309
def setup_generator(generator_name = @generator_name)
  @generator = @generators[generator_name]

  unless @generator
    raise OptionParser::InvalidArgument,
          "Invalid output formatter #{generator_name}"
  end

  return if @generator_options.include? @generator

  @generator_name = generator_name
  @generator_options << @generator

  if @generator.respond_to? :setup_options
    @option_parser ||= OptionParser.new
    @generator.setup_options self
  end
end
template_dir_for (template)

Finds the template dir for template

# File lib/rdoc/options.rb, line 1331
def template_dir_for(template)
  template_path = File.join 'rdoc', 'generator', 'template', template

  $LOAD_PATH.map do |path|
    File.join File.expand_path(path), template_path
  end.find do |dir|
    File.directory? dir
  end
end
visibility= (visibility)

Sets the minimum visibility of a documented method.

Accepts :public, :protected, :private, :nodoc, or :all.

When :all is passed, visibility is set to :private, similarly to RDOCOPT=“–all”, see visibility for more information.

# File lib/rdoc/options.rb, line 1348
def visibility=(visibility)
  case visibility
  when :all
    @visibility = :private
  else
    @visibility = visibility
  end
end
warn (message)

Displays a warning using Kernel#warn if we’re being verbose

Calls superclass method 
# File lib/rdoc/options.rb, line 1360
def warn(message)
  super message if @verbosity > 1
end
write_options ()

Writes the YAML file .rdoc_options to the current directory containing the parsed options.

# File lib/rdoc/options.rb, line 1368
def write_options
  ::RDoc.load_yaml

  File.open '.rdoc_options', 'w' do |io|
    io.set_encoding ::Encoding::UTF_8

    io.print to_yaml
  end
end