second_step 0.1.0 → 0.1.2

data/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/gems/2.2.0/gems/second_step-0.1.1/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/2.2.0/rdoc/mixin.rb

@@ -0,0 +1,120 @@
+##
+# A Mixin adds features from a module into another context.  RDoc::Include and
+# RDoc::Extend are both mixins.
+
+class RDoc::Mixin < RDoc::CodeObject
+
+  ##
+  # Name of included module
+
+  attr_accessor :name
+
+  ##
+  # Creates a new Mixin for +name+ with +comment+
+
+  def initialize(name, comment)
+    super()
+    @name = name
+    self.comment = comment
+    @module = nil # cache for module if found
+  end
+
+  ##
+  # Mixins are sorted by name
+
+  def <=> other
+    return unless self.class === other
+
+    name <=> other.name
+  end
+
+  def == other # :nodoc:
+    self.class === other and @name == other.name
+  end
+
+  alias eql? == # :nodoc:
+
+  ##
+  # Full name based on #module
+
+  def full_name
+    m = self.module
+    RDoc::ClassModule === m ? m.full_name : @name
+  end
+
+  def hash # :nodoc:
+    [@name, self.module].hash
+  end
+
+  def inspect # :nodoc:
+    "#<%s:0x%x %s.%s %s>" % [
+      self.class,
+      object_id,
+      parent_name, self.class.name.downcase, @name,
+    ]
+  end
+
+  ##
+  # Attempts to locate the included module object.  Returns the name if not
+  # known.
+  #
+  # The scoping rules of Ruby to resolve the name of an included module are:
+  # - first look into the children of the current context;
+  # - if not found, look into the children of included modules,
+  #   in reverse inclusion order;
+  # - if still not found, go up the hierarchy of names.
+  #
+  # This method has <code>O(n!)</code> behavior when the module calling
+  # include is referencing nonexistent modules.  Avoid calling #module until
+  # after all the files are parsed.  This behavior is due to ruby's constant
+  # lookup behavior.
+  #
+  # As of the beginning of October, 2011, no gem includes nonexistent modules.
+
+  def module
+    return @module if @module
+
+    # search the current context
+    return @name unless parent
+    full_name = parent.child_name(@name)
+    @module = @store.modules_hash[full_name]
+    return @module if @module
+    return @name if @name =~ /^::/
+
+    # search the includes before this one, in reverse order
+    searched = parent.includes.take_while { |i| i != self }.reverse
+    searched.each do |i|
+      inc = i.module
+      next if String === inc
+      full_name = inc.child_name(@name)
+      @module = @store.modules_hash[full_name]
+      return @module if @module
+    end
+
+    # go up the hierarchy of names
+    up = parent.parent
+    while up
+      full_name = up.child_name(@name)
+      @module = @store.modules_hash[full_name]
+      return @module if @module
+      up = up.parent
+    end
+
+    @name
+  end
+
+  ##
+  # Sets the store for this class or module and its contained code objects.
+
+  def store= store
+    super
+
+    @file = @store.add_file @file.full_name if @file
+  end
+
+  def to_s # :nodoc:
+    "#{self.class.name.downcase} #@name in: #{parent}"
+  end
+
+end
+

data/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/gems/2.2.0/gems/second_step-0.1.1/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/2.2.0/rdoc/normal_class.rb

@@ -0,0 +1,92 @@
+##
+# A normal class, neither singleton nor anonymous
+
+class RDoc::NormalClass < RDoc::ClassModule
+
+  ##
+  # The ancestors of this class including modules.  Unlike Module#ancestors,
+  # this class is not included in the result.  The result will contain both
+  # RDoc::ClassModules and Strings.
+
+  def ancestors
+    if String === superclass then
+      super << superclass
+    elsif superclass then
+      ancestors = super
+      ancestors << superclass
+      ancestors.concat superclass.ancestors
+    else
+      super
+    end
+  end
+
+  def aref_prefix # :nodoc:
+    'class'
+  end
+
+  ##
+  # The definition of this class, <tt>class MyClassName</tt>
+
+  def definition
+    "class #{full_name}"
+  end
+
+  def direct_ancestors
+    superclass ? super + [superclass] : super
+  end
+
+  def inspect # :nodoc:
+    superclass = @superclass ? " < #{@superclass}" : nil
+    "<%s:0x%x class %s%s includes: %p extends: %p attributes: %p methods: %p aliases: %p>" % [
+      self.class, object_id,
+      full_name, superclass, @includes, @extends, @attributes, @method_list, @aliases
+    ]
+  end
+
+  def to_s # :nodoc:
+    display = "#{self.class.name} #{self.full_name}"
+    if superclass
+      display << ' < ' << (superclass.is_a?(String) ? superclass : superclass.full_name)
+    end
+    display << ' -> ' << is_alias_for.to_s if is_alias_for
+    display
+  end
+
+  def pretty_print q # :nodoc:
+    superclass = @superclass ? " < #{@superclass}" : nil
+
+    q.group 2, "[class #{full_name}#{superclass} ", "]" do
+      q.breakable
+      q.text "includes:"
+      q.breakable
+      q.seplist @includes do |inc| q.pp inc end
+
+      q.breakable
+      q.text "constants:"
+      q.breakable
+      q.seplist @constants do |const| q.pp const end
+
+      q.breakable
+      q.text "attributes:"
+      q.breakable
+      q.seplist @attributes do |attr| q.pp attr end
+
+      q.breakable
+      q.text "methods:"
+      q.breakable
+      q.seplist @method_list do |meth| q.pp meth end
+
+      q.breakable
+      q.text "aliases:"
+      q.breakable
+      q.seplist @aliases do |aliaz| q.pp aliaz end
+
+      q.breakable
+      q.text "comment:"
+      q.breakable
+      q.pp comment
+    end
+  end
+
+end
+

data/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/gems/2.2.0/gems/second_step-0.1.1/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/2.2.0/rdoc/normal_module.rb

@@ -0,0 +1,73 @@
+##
+# A normal module, like NormalClass
+
+class RDoc::NormalModule < RDoc::ClassModule
+
+  def aref_prefix # :nodoc:
+    'module'
+  end
+
+  def inspect # :nodoc:
+    "#<%s:0x%x module %s includes: %p extends: %p attributes: %p methods: %p aliases: %p>" % [
+      self.class, object_id,
+      full_name, @includes, @extends, @attributes, @method_list, @aliases
+    ]
+  end
+
+  ##
+  # The definition of this module, <tt>module MyModuleName</tt>
+
+  def definition
+    "module #{full_name}"
+  end
+
+  ##
+  # This is a module, returns true
+
+  def module?
+    true
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, "[module #{full_name}: ", "]" do
+      q.breakable
+      q.text "includes:"
+      q.breakable
+      q.seplist @includes do |inc| q.pp inc end
+      q.breakable
+
+      q.breakable
+      q.text "constants:"
+      q.breakable
+      q.seplist @constants do |const| q.pp const end
+
+      q.text "attributes:"
+      q.breakable
+      q.seplist @attributes do |attr| q.pp attr end
+      q.breakable
+
+      q.text "methods:"
+      q.breakable
+      q.seplist @method_list do |meth| q.pp meth end
+      q.breakable
+
+      q.text "aliases:"
+      q.breakable
+      q.seplist @aliases do |aliaz| q.pp aliaz end
+      q.breakable
+
+      q.text "comment:"
+      q.breakable
+      q.pp comment
+    end
+  end
+
+  ##
+  # Modules don't have one, raises NoMethodError
+
+  def superclass
+    raise NoMethodError, "#{full_name} is a module"
+  end
+
+end
+

data/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/gems/2.2.0/gems/second_step-0.1.1/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/2.2.0/rdoc/options.rb

@@ -0,0 +1,1251 @@
+require 'optparse'
+require 'pathname'
+
+##
+# RDoc::Options handles the parsing and storage of options
+#
+# == Saved Options
+#
+# You can save some options like the markup format in the
+# <tt>.rdoc_options</tt> 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 <tt>--format</tt> 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 <tt>--format</tt>.  <tt>rdoc --help</tt>
+# 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.
+
+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
+
+  SPECIAL = %w[
+    coverage_report
+    dry_run
+    encoding
+    files
+    force_output
+    force_update
+    generator
+    generator_name
+    generator_options
+    generators
+    op_dir
+    option_parser
+    pipe
+    rdoc_include
+    root
+    static_path
+    stylesheet_url
+    template
+    template_dir
+    update_output_dir
+    verbosity
+    write_options
+  ]
+
+  ##
+  # Option validator for OptionParser that matches a directory that exists on
+  # the filesystem.
+
+  Directory = Object.new
+
+  ##
+  # Option validator for OptionParser that matches a file or directory that
+  # exists on the filesystem.
+
+  Path = Object.new
+
+  ##
+  # Option validator for OptionParser that matches a comma-separated list of
+  # files or directories that exist on the filesystem.
+
+  PathArray = Object.new
+
+  ##
+  # Option validator for OptionParser that matches a template directory for an
+  # installed generator that lives in
+  # <tt>"rdoc/generator/template/#{template_name}"</tt>
+
+  Template = Object.new
+
+  ##
+  # Character-set for HTML output.  #encoding is preferred over #charset
+
+  attr_accessor :charset
+
+  ##
+  # If true, RDoc will not write any files.
+
+  attr_accessor :dry_run
+
+  ##
+  # The output encoding.  All input files will be transcoded to this encoding.
+  #
+  # The default encoding is UTF-8.  This is set via --encoding.
+
+  attr_accessor :encoding
+
+  ##
+  # Files matching this pattern will be excluded
+
+  attr_accessor :exclude
+
+  ##
+  # The list of files to be processed
+
+  attr_accessor :files
+
+  ##
+  # Create the output even if the output directory does not look
+  # like an rdoc output directory
+
+  attr_accessor :force_output
+
+  ##
+  # Scan newer sources than the flag file if true.
+
+  attr_accessor :force_update
+
+  ##
+  # Formatter to mark up text with
+
+  attr_accessor :formatter
+
+  ##
+  # Description of the output generator (set with the <tt>--format</tt> option)
+
+  attr_accessor :generator
+
+  ##
+  # For #==
+
+  attr_reader :generator_name # :nodoc:
+
+  ##
+  # Loaded generator options.  Used to prevent --help from loading the same
+  # options multiple times.
+
+  attr_accessor :generator_options
+
+  ##
+  # Old rdoc behavior: hyperlink all words that match a method name,
+  # even if not preceded by '#' or '::'
+
+  attr_accessor :hyperlink_all
+
+  ##
+  # Include line numbers in the source code
+
+  attr_accessor :line_numbers
+
+  ##
+  # The output locale.
+
+  attr_accessor :locale
+
+  ##
+  # The directory where locale data live.
+
+  attr_accessor :locale_dir
+
+  ##
+  # Name of the file, class or module to display in the initial index page (if
+  # not specified the first file we encounter is used)
+
+  attr_accessor :main_page
+
+  ##
+  # The default markup format.  The default is 'rdoc'.  'markdown', 'tomdoc'
+  # and 'rd' are also built-in.
+
+  attr_accessor :markup
+
+  ##
+  # If true, only report on undocumented files
+
+  attr_accessor :coverage_report
+
+  ##
+  # The name of the output directory
+
+  attr_accessor :op_dir
+
+  ##
+  # The OptionParser for this instance
+
+  attr_accessor :option_parser
+
+  ##
+  # Output heading decorations?
+  attr_accessor :output_decoration
+
+  ##
+  # 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.
+
+  attr_accessor :page_dir
+
+  ##
+  # Is RDoc in pipe mode?
+
+  attr_accessor :pipe
+
+  ##
+  # Array of directories to search for files to satisfy an :include:
+
+  attr_accessor :rdoc_include
+
+  ##
+  # Root of the source documentation will be generated for.  Set this when
+  # building documentation outside the source directory.  Defaults to the
+  # current directory.
+
+  attr_accessor :root
+
+  ##
+  # Include the '#' at the front of hyperlinked instance method names
+
+  attr_accessor :show_hash
+
+  ##
+  # Directory to copy static files from
+
+  attr_accessor :static_path
+
+  ##
+  # The number of columns in a tab
+
+  attr_accessor :tab_width
+
+  ##
+  # Template to be used when generating output
+
+  attr_accessor :template
+
+  ##
+  # Directory the template lives in
+
+  attr_accessor :template_dir
+
+  ##
+  # Additional template stylesheets
+
+  attr_accessor :template_stylesheets
+
+  ##
+  # Documentation title
+
+  attr_accessor :title
+
+  ##
+  # Should RDoc update the timestamps in the output dir?
+
+  attr_accessor :update_output_dir
+
+  ##
+  # Verbosity, zero means quiet
+
+  attr_accessor :verbosity
+
+  ##
+  # URL of web cvs frontend
+
+  attr_accessor :webcvs
+
+  ##
+  # 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.
+
+  attr_reader :visibility
+
+  def initialize # :nodoc:
+    init_ivars
+  end
+
+  def init_ivars # :nodoc:
+    @dry_run = false
+    @exclude = []
+    @files = nil
+    @force_output = false
+    @force_update = true
+    @generator = nil
+    @generator_name = nil
+    @generator_options = []
+    @generators = RDoc::RDoc::GENERATORS
+    @hyperlink_all = false
+    @line_numbers = false
+    @locale = nil
+    @locale_name = nil
+    @locale_dir = 'locale'
+    @main_page = nil
+    @markup = 'rdoc'
+    @coverage_report = false
+    @op_dir = nil
+    @page_dir = nil
+    @pipe = false
+    @output_decoration = true
+    @rdoc_include = []
+    @root = Pathname(Dir.pwd)
+    @show_hash = false
+    @static_path = []
+    @stylesheet_url = nil # TODO remove in RDoc 4
+    @tab_width = 8
+    @template = nil
+    @template_dir = nil
+    @template_stylesheets = []
+    @title = nil
+    @update_output_dir = true
+    @verbosity = 1
+    @visibility = :protected
+    @webcvs = nil
+    @write_options = false
+
+    if Object.const_defined? :Encoding then
+      @encoding = Encoding::UTF_8
+      @charset = @encoding.name
+    else
+      @encoding = nil
+      @charset = 'UTF-8'
+    end
+  end
+
+  def init_with map # :nodoc:
+    init_ivars
+
+    encoding = map['encoding']
+    @encoding = if Object.const_defined? :Encoding then
+                  encoding ? Encoding.find(encoding) : encoding
+                end
+
+    @charset        = map['charset']
+    @exclude        = map['exclude']
+    @generator_name = map['generator_name']
+    @hyperlink_all  = map['hyperlink_all']
+    @line_numbers   = map['line_numbers']
+    @locale_name    = map['locale_name']
+    @locale_dir     = map['locale_dir']
+    @main_page      = map['main_page']
+    @markup         = map['markup']
+    @op_dir         = map['op_dir']
+    @show_hash      = map['show_hash']
+    @tab_width      = map['tab_width']
+    @template_dir   = map['template_dir']
+    @title          = map['title']
+    @visibility     = map['visibility']
+    @webcvs         = map['webcvs']
+
+    @rdoc_include = sanitize_path map['rdoc_include']
+    @static_path  = sanitize_path map['static_path']
+  end
+
+  def yaml_initialize tag, map # :nodoc:
+    init_with map
+  end
+
+  def == other # :nodoc:
+    self.class === other and
+      @encoding       == other.encoding       and
+      @generator_name == other.generator_name and
+      @hyperlink_all  == other.hyperlink_all  and
+      @line_numbers   == other.line_numbers   and
+      @locale         == other.locale         and
+      @locale_dir     == other.locale_dir and
+      @main_page      == other.main_page      and
+      @markup         == other.markup         and
+      @op_dir         == other.op_dir         and
+      @rdoc_include   == other.rdoc_include   and
+      @show_hash      == other.show_hash      and
+      @static_path    == other.static_path    and
+      @tab_width      == other.tab_width      and
+      @template       == other.template       and
+      @title          == other.title          and
+      @visibility     == other.visibility     and
+      @webcvs         == other.webcvs
+  end
+
+  ##
+  # Check that the files on the command line exist
+
+  def check_files
+    @files.delete_if do |file|
+      if File.exist? file then
+        if File.readable? file then
+          false
+        else
+          warn "file '#{file}' not readable"
+
+          true
+        end
+      else
+        warn "file '#{file}' not found"
+
+        true
+      end
+    end
+  end
+
+  ##
+  # Ensure only one generator is loaded
+
+  def check_generator
+    if @generator then
+      raise OptionParser::InvalidOption,
+        "generator already set to #{@generator_name}"
+    end
+  end
+
+  ##
+  # 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.
+
+  def default_title=(string)
+    @title ||= string
+  end
+
+  ##
+  # For dumping YAML
+
+  def encode_with coder # :nodoc:
+    encoding = @encoding ? @encoding.name : nil
+
+    coder.add 'encoding', encoding
+    coder.add 'static_path',  sanitize_path(@static_path)
+    coder.add 'rdoc_include', sanitize_path(@rdoc_include)
+
+    ivars = instance_variables.map { |ivar| ivar.to_s[1..-1] }
+    ivars -= SPECIAL
+
+    ivars.sort.each do |ivar|
+      coder.add ivar, instance_variable_get("@#{ivar}")
+    end
+  end
+
+  ##
+  # Completes any unfinished option setup business such as filtering for
+  # existent files, creating a regexp for #exclude and setting a default
+  # #template.
+
+  def finish
+    @op_dir ||= 'doc'
+
+    @rdoc_include << "." if @rdoc_include.empty?
+    root = @root.to_s
+    @rdoc_include << root unless @rdoc_include.include?(root)
+
+    if @exclude.nil? or Regexp === @exclude then
+      # done, #finish is being re-run
+    elsif @exclude.empty? then
+      @exclude = nil
+    else
+      @exclude = Regexp.new(@exclude.join("|"))
+    end
+
+    finish_page_dir
+
+    check_files
+
+    # If no template was specified, use the default template for the output
+    # formatter
+
+    unless @template then
+      @template     = @generator_name
+      @template_dir = template_dir_for @template
+    end
+
+    if @locale_name
+      @locale = RDoc::I18n::Locale[@locale_name]
+      @locale.load(@locale_dir)
+    else
+      @locale = nil
+    end
+
+    self
+  end
+
+  ##
+  # Fixes the page_dir to be relative to the root_dir and adds the page_dir to
+  # the files list.
+
+  def finish_page_dir
+    return unless @page_dir
+
+    @files << @page_dir.to_s
+
+    page_dir = @page_dir.expand_path.relative_path_from @root
+
+    @page_dir = page_dir
+  end
+
+  ##
+  # Returns a properly-space list of generators and their descriptions.
+
+  def generator_descriptions
+    lengths = []
+
+    generators = RDoc::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 then
+        "  %-*s - %s" % [longest, name, description]
+      else
+        "  #{name}"
+      end
+    end.join "\n"
+  end
+
+  ##
+  # Parses command line options.
+
+  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 = RDoc::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] = [] }
+
+      RDoc::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.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
+
+        unless template_dir then
+          $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 then
+                  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
+
+      if Object.const_defined? :Encoding then
+        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
+      end
+
+
+      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.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 then
+          raise OptionParser::InvalidArgument, "Invalid parameter to '-E'"
+        end
+
+        unless RDoc::Parser.alias_extension old, new then
+          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",
+             "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", "-V", RDoc::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
+
+      markup_formats = RDoc::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 = Pathname(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.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
+
+      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("--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 << 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 ||= RDoc::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 = RDoc::RI::Paths.site_dir
+        setup_generator
+      end
+
+      opt.separator nil
+      opt.separator "Generic options:"
+      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("--[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::RDoc::GENERATORS.each_key do |generator|
+          setup_generator generator
+        end
+
+        puts opt.help
+        exit
+      end
+
+      opt.separator nil
+    end
+
+    setup_generator 'darkfish' if
+      argv.grep(/\A(-f|--fmt|--format|-r|-R|--ri|--ri-site)\b/).empty?
+
+    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
+        raise
+      else
+        invalid << e.args.join(' ')
+      end
+
+      retry
+    end
+
+    unless @generator then
+      @generator = RDoc::Generator::Darkfish
+      @generator_name = 'darkfish'
+    end
+
+    if @pipe and not argv.empty? then
+      @pipe = false
+      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 ', '}"
+
+      if ignore_invalid then
+        unless quiet then
+          $stderr.puts invalid
+          $stderr.puts '(invalid options are ignored)'
+        end
+      else
+        unless quiet then
+          $stderr.puts opts
+        end
+        $stderr.puts invalid
+        exit 1
+      end
+    end
+
+    @files = argv.dup
+
+    finish
+
+    if @write_options then
+      write_options
+      exit
+    end
+
+    self
+  end
+
+  ##
+  # Don't display progress as we process the files
+
+  def quiet
+    @verbosity.zero?
+  end
+
+  ##
+  # Set quietness to +bool+
+
+  def quiet= bool
+    @verbosity = bool ? 0 : 1
+  end
+
+  ##
+  # Removes directories from +path+ that are outside the current directory
+
+  def sanitize_path path
+    require 'pathname'
+    dot = Pathname.new('.').expand_path
+
+    path.reject do |item|
+      path = Pathname.new(item).expand_path
+      relative = path.relative_path_from(dot).to_s
+      relative.start_with? '..'
+    end
+  end
+
+  ##
+  # 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.
+
+  def setup_generator generator_name = @generator_name
+    @generator = @generators[generator_name]
+
+    unless @generator then
+      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 then
+      @option_parser ||= OptionParser.new
+      @generator.setup_options self
+    end
+  end
+
+  ##
+  # Finds the template dir for +template+
+
+  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
+
+  ##
+  # This is compatibility code for syck
+
+  def to_yaml opts = {} # :nodoc:
+    return super if YAML.const_defined?(:ENGINE) and not YAML::ENGINE.syck?
+
+    YAML.quick_emit self, opts do |out|
+      out.map taguri, to_yaml_style do |map|
+        encode_with map
+      end
+    end
+  end
+
+  # 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.
+
+  def visibility= visibility
+    case visibility
+    when :all
+      @visibility = :private
+    else
+      @visibility = visibility
+    end
+  end
+
+  ##
+  # Displays a warning using Kernel#warn if we're being verbose
+
+  def warn message
+    super message if @verbosity > 1
+  end
+
+  ##
+  # Writes the YAML file .rdoc_options to the current directory containing the
+  # parsed options.
+
+  def write_options
+    RDoc.load_yaml
+
+    open '.rdoc_options', 'w' do |io|
+      io.set_encoding Encoding::UTF_8 if Object.const_defined? :Encoding
+
+      YAML.dump self, io
+    end
+  end
+
+end
+