Complete RDoc namespace change

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@15018 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

11 files changed, 0 insertions, 3971 deletions

diff --git a/lib/rdoc/generators/chm.rb b/lib/rdoc/generators/chm.rb
deleted file mode 100644
index ce05d38d50..0000000000
--- a/lib/rdoc/generators/chm.rb
+++ /dev/null
@@ -1,113 +0,0 @@
-require 'rdoc/generators/html'
-
-class RDoc::Generators::CHM < RDoc::Generators::HTML
-
-  HHC_PATH = "c:/Program Files/HTML Help Workshop/hhc.exe"
-
-  ##
-  # Standard generator factory
-
-  def self.for(options)
-    new(options)
-  end
-
-  def initialize(*args)
-    super
-    @op_name = @options.op_name || "rdoc"
-    check_for_html_help_workshop
-  end
-
-  def check_for_html_help_workshop
-    stat = File.stat(HHC_PATH)
-  rescue
-    $stderr <<
-      "\n.chm output generation requires that Microsoft's Html Help\n" <<
-      "Workshop is installed. RDoc looks for it in:\n\n    " <<
-      HHC_PATH <<
-      "\n\nYou can download a copy for free from:\n\n" <<
-      "    http://msdn.microsoft.com/library/default.asp?" <<
-      "url=/library/en-us/htmlhelp/html/hwMicrosoftHTMLHelpDownloads.asp\n\n"
-  end
-
-  ##
-  # Generate the html as normal, then wrap it in a help project
-
-  def generate(info)
-    super
-    @project_name = @op_name + ".hhp"
-    create_help_project
-  end
-
-  ##
-  # The project contains the project file, a table of contents and an index
-
-  def create_help_project
-    create_project_file
-    create_contents_and_index
-    compile_project
-  end
-
-  ##
-  # The project file links together all the various
-  # files that go to make up the help.
-
-  def create_project_file
-    template = RDoc::TemplatePage.new @template::HPP_FILE
-    values = { "title" => @options.title, "opname" => @op_name }
-    files = []
-    @files.each do |f|
-      files << { "html_file_name" => f.path }
-    end
-
-    values['all_html_files'] = files
-
-    File.open(@project_name, "w") do |f|
-      template.write_html_on(f, values)
-    end
-  end
-
-  ##
-  # The contents is a list of all files and modules.
-  # For each we include  as sub-entries the list
-  # of methods they contain. As we build the contents
-  # we also build an index file
-
-  def create_contents_and_index
-    contents = []
-    index    = []
-
-    (@files+@classes).sort.each do |entry|
-      content_entry = { "c_name" => entry.name, "ref" => entry.path }
-      index << { "name" => entry.name, "aref" => entry.path }
-
-      internals = []
-
-      methods = entry.build_method_summary_list(entry.path)
-
-      content_entry["methods"] = methods unless methods.empty?
-      contents << content_entry
-      index.concat methods
-    end
-
-    values = { "contents" => contents }
-    template = RDoc::TemplatePage.new @template::CONTENTS
-    File.open("contents.hhc", "w") do |f|
-      template.write_html_on(f, values)
-    end
-
-    values = { "index" => index }
-    template = RDoc::TemplatePage.new @template::CHM_INDEX
-    File.open("index.hhk", "w") do |f|
-      template.write_html_on(f, values)
-    end
-  end
-
-  ##
-  # Invoke the windows help compiler to compiler the project
-
-  def compile_project
-    system(HHC_PATH, @project_name)
-  end
-
-end
-
diff --git a/lib/rdoc/generators/chm/chm.rb b/lib/rdoc/generators/chm/chm.rb
deleted file mode 100644
index 4134420668..0000000000
--- a/lib/rdoc/generators/chm/chm.rb
+++ /dev/null
@@ -1,98 +0,0 @@
-require 'rdoc/generators/chm'
-require 'rdoc/generators/html/html'
-
-module RDoc::Generators::CHM::CHM
-
-  HTML = RDoc::Generators::HTML::HTML
-
-  INDEX = HTML::INDEX
-
-  CLASS_INDEX = HTML::CLASS_INDEX
-  CLASS_PAGE = HTML::CLASS_PAGE
-  FILE_INDEX = HTML::FILE_INDEX
-  FILE_PAGE = HTML::FILE_PAGE
-  METHOD_INDEX = HTML::METHOD_INDEX
-  METHOD_LIST = HTML::METHOD_LIST
-
-  FR_INDEX_BODY = HTML::FR_INDEX_BODY
-
-  # This is a nasty little hack, but hhc doesn't support the <?xml tag, so...
-  BODY = HTML::BODY.sub!(/<\?xml.*\?>/, '')
-  SRC_PAGE = HTML::SRC_PAGE.sub!(/<\?xml.*\?>/, '')
-
-  HPP_FILE = <<-EOF
-[OPTIONS]
-Auto Index = Yes
-Compatibility=1.1 or later
-Compiled file=<%= values["opname"] %>.chm
-Contents file=contents.hhc
-Full-text search=Yes
-Index file=index.hhk
-Language=0x409 English(United States)
-Title=<%= values["title"] %>
-
-[FILES]
-<% values["all_html_files"].each do |all_html_files| %>
-<%= all_html_files["html_file_name"] %>
-<% end # values["all_html_files"] %>
-  EOF
-
-  CONTENTS = <<-EOF
-<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
-<HTML>
-<HEAD>
-<meta name="GENERATOR" content="Microsoft&reg; HTML Help Workshop 4.1">
-<!-- Sitemap 1.0 -->
-</HEAD><BODY>
-<OBJECT type="text/site properties">
-	<param name="Foreground" value="0x80">
-	<param name="Window Styles" value="0x800025">
-	<param name="ImageType" value="Folder">
-</OBJECT>
-<UL>
-<% values["contents"].each do |contents| %>
-	<LI> <OBJECT type="text/sitemap">
-		<param name="Name" value="<%= contents["c_name"] %>">
-		<param name="Local" value="<%= contents["ref"] %>">
-		</OBJECT>
-<% if contents["methods"] then %>
-<ul>
-<% contents["methods"].each do |methods| %>
-	<LI> <OBJECT type="text/sitemap">
-		<param name="Name" value="<%= methods["name"] %>">
-		<param name="Local" value="<%= methods["aref"] %>">
-		</OBJECT>
-<% end # contents["methods"] %>
-</ul>
-<% end %>
-        </LI>
-<% end # values["contents"] %>
-</UL>
-</BODY></HTML>
-  EOF
-
-  CHM_INDEX = <<-EOF
-<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
-<HTML>
-<HEAD>
-<meta name="GENERATOR" content="Microsoft&reg; HTML Help Workshop 4.1">
-<!-- Sitemap 1.0 -->
-</HEAD><BODY>
-<OBJECT type="text/site properties">
-	<param name="Foreground" value="0x80">
-	<param name="Window Styles" value="0x800025">
-	<param name="ImageType" value="Folder">
-</OBJECT>
-<UL>
-<% values["index"].each do |index| %>
-	<LI> <OBJECT type="text/sitemap">
-		<param name="Name" value="<%= index["name"] %>">
-		<param name="Local" value="<%= index["aref"] %>">
-		</OBJECT>
-<% end # values["index"] %>
-</UL>
-</BODY></HTML>
-  EOF
-
-end
-
diff --git a/lib/rdoc/generators/html.rb b/lib/rdoc/generators/html.rb
deleted file mode 100644
index 10244576df..0000000000
--- a/lib/rdoc/generators/html.rb
+++ /dev/null
@@ -1,1531 +0,0 @@
-require 'fileutils'
-
-require 'rdoc/generators'
-require 'rdoc/markup/simple_markup/to_html'
-
-module RDoc::Generators
-
-  ##
-  # Build a hash of all items that can be cross-referenced.
-  # This is used when we output required and included names:
-  # if the names appear in this hash, we can generate
-  # an html cross reference to the appropriate description.
-  # We also use this when parsing comment blocks: any decorated
-  # words matching an entry in this list are hyperlinked.
-
-  class AllReferences
-    @@refs = {}
-
-    def AllReferences::reset
-      @@refs = {}
-    end
-
-    def AllReferences.add(name, html_class)
-      @@refs[name] = html_class
-    end
-
-    def AllReferences.[](name)
-      @@refs[name]
-    end
-
-    def AllReferences.keys
-      @@refs.keys
-    end
-  end
-
-  ##
-  # Subclass of the SM::ToHtml class that supports looking
-  # up words in the AllReferences list. Those that are
-  # found (like AllReferences in this comment) will
-  # be hyperlinked
-
-  class HyperlinkHtml < SM::ToHtml
-
-    ##
-    # We need to record the html path of our caller so we can generate
-    # correct relative paths for any hyperlinks that we find
-    def initialize(from_path, context, options)
-      super()
-
-      @from_path = from_path
-
-      @parent_name = context.parent_name
-      @parent_name += "::" if @parent_name
-      @context = context
-
-      @options = options
-    end
-
-    ##
-    # We're invoked when any text matches the CROSSREF pattern
-    # (defined in MarkUp). If we fine the corresponding reference,
-    # generate a hyperlink. If the name we're looking for contains
-    # no punctuation, we look for it up the module/class chain. For
-    # example, HyperlinkHtml is found, even without the Generators::
-    # prefix, because we look for it in module Generators first.
-
-    def handle_special_CROSSREF(special)
-      name = special.text
-      if name[0,1] == '#'
-        lookup = name[1..-1]
-        name = lookup unless @options.show_hash
-      else
-        lookup = name
-      end
-
-      # Find class, module, or method in class or module.
-      if /([A-Z]\w*)[.\#](\w+[!?=]?)/ =~ lookup
-        container = $1
-        method = $2
-        ref = @context.find_symbol(container, method)
-      elsif /([A-Za-z]\w*)[.\#](\w+(\([\.\w+\*\/\+\-\=\<\>]+\))?)/ =~ lookup
-        container = $1
-        method = $2
-        ref = @context.find_symbol(container, method)
-      else
-        ref = @context.find_symbol(lookup)
-      end
-
-      if ref and ref.document_self
-        "<a href=\"#{ref.as_href(@from_path)}\">#{name}</a>"
-      else
-        name
-      end
-    end
-
-    ##
-    # Generate a hyperlink for url, labeled with text. Handle the
-    # special cases for img: and link: described under handle_special_HYPEDLINK
-
-    def gen_url(url, text)
-      if url =~ /([A-Za-z]+):(.*)/
-        type = $1
-        path = $2
-      else
-        type = "http"
-        path = url
-        url  = "http://#{url}"
-      end
-
-      if type == "link"
-        if path[0,1] == '#'     # is this meaningful?
-          url = path
-        else
-          url = HTML.gen_url(@from_path, path)
-        end
-      end
-
-      if (type == "http" || type == "link") &&
-          url =~ /\.(gif|png|jpg|jpeg|bmp)$/
-
-        "<img src=\"#{url}\" />"
-      else
-        "<a href=\"#{url}\">#{text.sub(%r{^#{type}:/*}, '')}</a>"
-      end
-    end
-
-    ##
-    # And we're invoked with a potential external hyperlink mailto:
-    # just gets inserted. http: links are checked to see if they
-    # reference an image. If so, that image gets inserted using an
-    # <img> tag. Otherwise a conventional <a href> is used.  We also
-    # support a special type of hyperlink, link:, which is a reference
-    # to a local file whose path is relative to the --op directory.
-
-    def handle_special_HYPERLINK(special)
-      url = special.text
-      gen_url(url, url)
-    end
-
-    ##
-    # Here's a hypedlink where the label is different to the URL
-    #  <label>[url]
-
-    def handle_special_TIDYLINK(special)
-      text = special.text
-#      unless text =~ /(\S+)\[(.*?)\]/
-      unless text =~ /\{(.*?)\}\[(.*?)\]/ or text =~ /(\S+)\[(.*?)\]/
-        return text
-      end
-      label = $1
-      url   = $2
-      gen_url(url, label)
-    end
-
-  end
-
-  ##
-  # Handle common markup tasks for the various Html classes
-
-  module MarkUp
-
-    ##
-    # Convert a string in markup format into HTML. We keep a cached
-    # SimpleMarkup object lying around after the first time we're
-    # called per object.
-
-    def markup(str, remove_para=false)
-      return '' unless str
-      unless defined? @markup
-        @markup = SM::SimpleMarkup.new
-
-        # class names, variable names, or instance variables
-        @markup.add_special(/(
-                               \w+(::\w+)*[.\#]\w+(\([\.\w+\*\/\+\-\=\<\>]+\))?  # A::B.meth(**) (for operator in Fortran95)
-                             | \#\w+(\([.\w\*\/\+\-\=\<\>]+\))?  #  meth(**) (for operator in Fortran95)
-                             | \b([A-Z]\w*(::\w+)*[.\#]\w+)  #    A::B.meth
-                             | \b([A-Z]\w+(::\w+)*)       #    A::B..
-                             | \#\w+[!?=]?                #    #meth_name
-                             | \b\w+([_\/\.]+\w+)*[!?=]?  #    meth_name
-                             )/x,
-                            :CROSSREF)
-
-        # external hyperlinks
-        @markup.add_special(/((link:|https?:|mailto:|ftp:|www\.)\S+\w)/, :HYPERLINK)
-
-        # and links of the form  <text>[<url>]
-        @markup.add_special(/(((\{.*?\})|\b\S+?)\[\S+?\.\S+?\])/, :TIDYLINK)
-#        @markup.add_special(/\b(\S+?\[\S+?\.\S+?\])/, :TIDYLINK)
-
-      end
-      unless defined? @html_formatter
-        @html_formatter = HyperlinkHtml.new(self.path, self, @options)
-      end
-
-      # Convert leading comment markers to spaces, but only
-      # if all non-blank lines have them
-
-      if str =~ /^(?>\s*)[^\#]/
-        content = str
-      else
-        content = str.gsub(/^\s*(#+)/)  { $1.tr('#',' ') }
-      end
-
-      res = @markup.convert(content, @html_formatter)
-      if remove_para
-        res.sub!(/^<p>/, '')
-        res.sub!(/<\/p>$/, '')
-      end
-      res
-    end
-
-    ##
-    # Qualify a stylesheet URL; if if +css_name+ does not begin with '/' or
-    # 'http[s]://', prepend a prefix relative to +path+. Otherwise, return it
-    # unmodified.
-
-    def style_url(path, css_name=nil)
-#      $stderr.puts "style_url( #{path.inspect}, #{css_name.inspect} )"
-      css_name ||= CSS_NAME
-      if %r{^(https?:/)?/} =~ css_name
-        return css_name
-      else
-        return HTML.gen_url(path, css_name)
-      end
-    end
-
-    ##
-    # Build a webcvs URL with the given 'url' argument. URLs with a '%s' in them
-    # get the file's path sprintfed into them; otherwise they're just catenated
-    # together.
-
-    def cvs_url(url, full_path)
-      if /%s/ =~ url
-        return sprintf( url, full_path )
-      else
-        return url + full_path
-      end
-    end
-
-  end
-
-  ##
-  # A Context is built by the parser to represent a container: contexts
-  # hold classes, modules, methods, require lists and include lists.
-  # ClassModule and TopLevel are the context objects we process here
-
-  class ContextUser
-
-    include MarkUp
-
-    attr_reader :context
-
-    def initialize(context, options)
-      @context = context
-      @options = options
-
-      # HACK ugly
-      @template = options.template_class
-    end
-
-    ##
-    # convenience method to build a hyperlink
-
-    def href(link, cls, name)
-      %{<a href="#{link}" class="#{cls}">#{name}</a>} #"
-    end
-
-    ##
-    # Returns a reference to outselves to be used as an href= the form depends
-    # on whether we're all in one file or in multiple files
-
-    def as_href(from_path)
-      if @options.all_one_file
-        "#" + path
-      else
-        HTML.gen_url(from_path, path)
-      end
-    end
-
-    ##
-    # Create a list of HtmlMethod objects for each method in the corresponding
-    # context object. If the @options.show_all variable is set (corresponding
-    # to the <tt>--all</tt> option, we include all methods, otherwise just the
-    # public ones.
-
-    def collect_methods
-      list = @context.method_list
-      unless @options.show_all
-        list = list.find_all {|m| m.visibility == :public || m.visibility == :protected || m.force_documentation }
-      end
-      @methods = list.collect {|m| HtmlMethod.new(m, self, @options) }
-    end
-
-    ##
-    # Build a summary list of all the methods in this context
-
-    def build_method_summary_list(path_prefix="")
-      collect_methods unless @methods
-      meths = @methods.sort
-      res = []
-      meths.each do |meth|
-        res << {
-          "name" => CGI.escapeHTML(meth.name),
-          "aref" => "#{path_prefix}\##{meth.aref}"
-        }
-      end
-      res
-    end
-
-    ##
-    # Build a list of aliases for which we couldn't find a
-    # corresponding method
-
-    def build_alias_summary_list(section)
-      values = []
-      @context.aliases.each do |al|
-        next unless al.section == section
-        res = {
-          'old_name' => al.old_name,
-          'new_name' => al.new_name,
-        }
-        if al.comment && !al.comment.empty?
-          res['desc'] = markup(al.comment, true)
-        end
-        values << res
-      end
-      values
-    end
-
-    ##
-    # Build a list of constants
-
-    def build_constants_summary_list(section)
-      values = []
-      @context.constants.each do |co|
-        next unless co.section == section
-        res = {
-          'name'  => co.name,
-          'value' => CGI.escapeHTML(co.value)
-        }
-        res['desc'] = markup(co.comment, true) if co.comment && !co.comment.empty?
-        values << res
-      end
-      values
-    end
-
-    def build_requires_list(context)
-      potentially_referenced_list(context.requires) {|fn| [fn + ".rb"] }
-    end
-
-    def build_include_list(context)
-      potentially_referenced_list(context.includes)
-    end
-
-    ##
-    # Build a list from an array of <i>Htmlxxx</i> items. Look up each
-    # in the AllReferences hash: if we find a corresponding entry,
-    # we generate a hyperlink to it, otherwise just output the name.
-    # However, some names potentially need massaging. For example,
-    # you may require a Ruby file without the .rb extension,
-    # but the file names we know about may have it. To deal with
-    # this, we pass in a block which performs the massaging,
-    # returning an array of alternative names to match
-
-    def potentially_referenced_list(array)
-      res = []
-      array.each do |i|
-        ref = AllReferences[i.name]
-#         if !ref
-#           container = @context.parent
-#           while !ref && container
-#             name = container.name + "::" + i.name
-#             ref = AllReferences[name]
-#             container = container.parent
-#           end
-#         end
-
-        ref = @context.find_symbol(i.name)
-        ref = ref.viewer if ref
-
-        if !ref && block_given?
-          possibles = yield(i.name)
-          while !ref and !possibles.empty?
-            ref = AllReferences[possibles.shift]
-          end
-        end
-        h_name = CGI.escapeHTML(i.name)
-        if ref and ref.document_self
-          path = url(ref.path)
-          res << { "name" => h_name, "aref" => path }
-        else
-          res << { "name" => h_name }
-        end
-      end
-      res
-    end
-
-    ##
-    # Build an array of arrays of method details. The outer array has up
-    # to six entries, public, private, and protected for both class
-    # methods, the other for instance methods. The inner arrays contain
-    # a hash for each method
-
-    def build_method_detail_list(section)
-      outer = []
-
-      methods = @methods.sort
-      for singleton in [true, false]
-        for vis in [ :public, :protected, :private ]
-          res = []
-          methods.each do |m|
-            if m.section == section and
-                m.document_self and
-                m.visibility == vis and
-                m.singleton == singleton
-              row = {}
-              if m.call_seq
-                row["callseq"] = m.call_seq.gsub(/->/, '&rarr;')
-              else
-                row["name"]        = CGI.escapeHTML(m.name)
-                row["params"]      = m.params
-              end
-              desc = m.description.strip
-              row["m_desc"]      = desc unless desc.empty?
-              row["aref"]        = m.aref
-              row["visibility"]  = m.visibility.to_s
-
-              alias_names = []
-              m.aliases.each do |other|
-                if other.viewer   # won't be if the alias is private
-                  alias_names << {
-                    'name' => other.name,
-                    'aref'  => other.viewer.as_href(path)
-                  }
-                end
-              end
-              unless alias_names.empty?
-                row["aka"] = alias_names
-              end
-
-              if @options.inline_source
-                code = m.source_code
-                row["sourcecode"] = code if code
-              else
-                code = m.src_url
-                if code
-                  row["codeurl"] = code
-                  row["imgurl"]  = m.img_url
-                end
-              end
-              res << row
-            end
-          end
-          if res.size > 0
-            outer << {
-              "type"     => vis.to_s.capitalize,
-              "category" => singleton ? "Class" : "Instance",
-              "methods"  => res
-            }
-          end
-        end
-      end
-      outer
-    end
-
-    ##
-    # Build the structured list of classes and modules contained
-    # in this context.
-
-    def build_class_list(level, from, section, infile=nil)
-      res = ""
-      prefix = "&nbsp;&nbsp;::" * level;
-
-      from.modules.sort.each do |mod|
-        next unless mod.section == section
-        next if infile && !mod.defined_in?(infile)
-        if mod.document_self
-          res <<
-            prefix <<
-            "Module " <<
-            href(url(mod.viewer.path), "link", mod.full_name) <<
-            "<br />\n" <<
-            build_class_list(level + 1, mod, section, infile)
-        end
-      end
-
-      from.classes.sort.each do |cls|
-        next unless cls.section == section
-        next if infile && !cls.defined_in?(infile)
-        if cls.document_self
-          res      <<
-            prefix <<
-            "Class " <<
-            href(url(cls.viewer.path), "link", cls.full_name) <<
-            "<br />\n" <<
-            build_class_list(level + 1, cls, section, infile)
-        end
-      end
-
-      res
-    end
-
-    def url(target)
-      HTML.gen_url(path, target)
-    end
-
-    def aref_to(target)
-      if @options.all_one_file
-        "#" + target
-      else
-        url(target)
-      end
-    end
-
-    def document_self
-      @context.document_self
-    end
-
-    def diagram_reference(diagram)
-      res = diagram.gsub(/((?:src|href)=")(.*?)"/) {
-        $1 + url($2) + '"'
-      }
-      res
-    end
-
-    ##
-    # Find a symbol in ourselves or our parent
-
-    def find_symbol(symbol, method=nil)
-      res = @context.find_symbol(symbol, method)
-      if res
-        res = res.viewer
-      end
-      res
-    end
-
-    ##
-    # create table of contents if we contain sections
-
-    def add_table_of_sections
-      toc = []
-      @context.sections.each do |section|
-        if section.title
-          toc << {
-            'secname' => section.title,
-            'href'    => section.sequence
-          }
-        end
-      end
-
-      @values['toc'] = toc unless toc.empty?
-    end
-
-  end
-
-  ##
-  # Wrap a ClassModule context
-
-  class HtmlClass < ContextUser
-
-    attr_reader :path
-
-    def initialize(context, html_file, prefix, options)
-      super(context, options)
-
-      @html_file = html_file
-      @is_module = context.is_module?
-      @values    = {}
-
-      context.viewer = self
-
-      if options.all_one_file
-        @path = context.full_name
-      else
-        @path = http_url(context.full_name, prefix)
-      end
-
-      collect_methods
-
-      AllReferences.add(name, self)
-    end
-
-    ##
-    # Returns the relative file name to store this class in, which is also its
-    # url
-
-    def http_url(full_name, prefix)
-      path = full_name.dup
-      if path['<<']
-        path.gsub!(/<<\s*(\w*)/) { "from-#$1" }
-      end
-      File.join(prefix, path.split("::")) + ".html"
-    end
-
-    def name
-      @context.full_name
-    end
-
-    def parent_name
-      @context.parent.full_name
-    end
-
-    def index_name
-      name
-    end
-
-    def write_on(f)
-      value_hash
-      template = RDoc::TemplatePage.new(@template::BODY,
-                                        @template::CLASS_PAGE,
-                                        @template::METHOD_LIST)
-      template.write_html_on(f, @values)
-    end
-
-    def value_hash
-      class_attribute_values
-      add_table_of_sections
-
-      @values["charset"] = @options.charset
-      @values["style_url"] = style_url(path, @options.css)
-
-      d = markup(@context.comment)
-      @values["description"] = d unless d.empty?
-
-      ml = build_method_summary_list @path
-      @values["methods"] = ml unless ml.empty?
-
-      il = build_include_list(@context)
-      @values["includes"] = il unless il.empty?
-
-      @values["sections"] = @context.sections.map do |section|
-
-        secdata = {
-          "sectitle" => section.title,
-          "secsequence" => section.sequence,
-          "seccomment" => markup(section.comment)
-        }
-
-        al = build_alias_summary_list(section)
-        secdata["aliases"] = al unless al.empty?
-
-        co = build_constants_summary_list(section)
-        secdata["constants"] = co unless co.empty?
-
-        al = build_attribute_list(section)
-        secdata["attributes"] = al unless al.empty?
-
-        cl = build_class_list(0, @context, section)
-        secdata["classlist"] = cl unless cl.empty?
-
-        mdl = build_method_detail_list(section)
-        secdata["method_list"] = mdl unless mdl.empty?
-
-        secdata
-      end
-
-      @values
-    end
-
-    def build_attribute_list(section)
-      atts = @context.attributes.sort
-      res = []
-      atts.each do |att|
-        next unless att.section == section
-        if att.visibility == :public || att.visibility == :protected || @options.show_all
-          entry = {
-            "name"   => CGI.escapeHTML(att.name),
-            "rw"     => att.rw,
-            "a_desc" => markup(att.comment, true)
-          }
-          unless att.visibility == :public || att.visibility == :protected
-            entry["rw"] << "-"
-          end
-          res << entry
-        end
-      end
-      res
-    end
-
-    def class_attribute_values
-      h_name = CGI.escapeHTML(name)
-
-      @values["path"]      = @path
-      @values["classmod"]  = @is_module ? "Module" : "Class"
-      @values["title"]     = "#{@values['classmod']}: #{h_name}"
-
-      c = @context
-      c = c.parent while c and !c.diagram
-      if c && c.diagram
-        @values["diagram"] = diagram_reference(c.diagram)
-      end
-
-      @values["full_name"] = h_name
-
-      parent_class = @context.superclass
-
-      if parent_class
-        @values["parent"] = CGI.escapeHTML(parent_class)
-
-        if parent_name
-          lookup = parent_name + "::" + parent_class
-        else
-          lookup = parent_class
-        end
-
-        parent_url = AllReferences[lookup] || AllReferences[parent_class]
-
-        if parent_url and parent_url.document_self
-          @values["par_url"] = aref_to(parent_url.path)
-        end
-      end
-
-      files = []
-      @context.in_files.each do |f|
-        res = {}
-        full_path = CGI.escapeHTML(f.file_absolute_name)
-
-        res["full_path"]     = full_path
-        res["full_path_url"] = aref_to(f.viewer.path) if f.document_self
-
-        if @options.webcvs
-          res["cvsurl"] = cvs_url( @options.webcvs, full_path )
-        end
-
-        files << res
-      end
-
-      @values['infiles'] = files
-    end
-
-    def <=>(other)
-      self.name <=> other.name
-    end
-
-  end
-
-  ##
-  # Handles the mapping of a file's information to HTML. In reality,
-  # a file corresponds to a +TopLevel+ object, containing modules,
-  # classes, and top-level methods. In theory it _could_ contain
-  # attributes and aliases, but we ignore these for now.
-
-  class HtmlFile < ContextUser
-
-    attr_reader :path
-    attr_reader :name
-
-    def initialize(context, options, file_dir)
-      super(context, options)
-
-      @values = {}
-
-      if options.all_one_file
-        @path = filename_to_label
-      else
-        @path = http_url(file_dir)
-      end
-
-      @name = @context.file_relative_name
-
-      collect_methods
-      AllReferences.add(name, self)
-      context.viewer = self
-    end
-
-    def http_url(file_dir)
-      File.join(file_dir, @context.file_relative_name.tr('.', '_')) +
-        ".html"
-    end
-
-    def filename_to_label
-      @context.file_relative_name.gsub(/%|\/|\?|\#/) do |s|
-        '%%%x' % s[0].unpack('C')
-      end
-    end
-
-    def index_name
-      name
-    end
-
-    def parent_name
-      nil
-    end
-
-    def value_hash
-      file_attribute_values
-      add_table_of_sections
-
-      @values["charset"]   = @options.charset
-      @values["href"]      = path
-      @values["style_url"] = style_url(path, @options.css)
-
-      if @context.comment
-        d = markup(@context.comment)
-        @values["description"] = d if d.size > 0
-      end
-
-      ml = build_method_summary_list
-      @values["methods"] = ml unless ml.empty?
-
-      il = build_include_list(@context)
-      @values["includes"] = il unless il.empty?
-
-      rl = build_requires_list(@context)
-      @values["requires"] = rl unless rl.empty?
-
-      if @options.promiscuous
-        file_context = nil
-      else
-        file_context = @context
-      end
-
-
-      @values["sections"] = @context.sections.map do |section|
-
-        secdata = {
-          "sectitle" => section.title,
-          "secsequence" => section.sequence,
-          "seccomment" => markup(section.comment)
-        }
-
-        cl = build_class_list(0, @context, section, file_context)
-        @values["classlist"] = cl unless cl.empty?
-
-        mdl = build_method_detail_list(section)
-        secdata["method_list"] = mdl unless mdl.empty?
-
-        al = build_alias_summary_list(section)
-        secdata["aliases"] = al unless al.empty?
-
-        co = build_constants_summary_list(section)
-        @values["constants"] = co unless co.empty?
-
-        secdata
-      end
-
-      @values
-    end
-
-    def write_on(f)
-      value_hash
-
-      template = RDoc::TemplatePage.new(@template::BODY,
-                                        @template::FILE_PAGE,
-                                        @template::METHOD_LIST)
-
-      template.write_html_on(f, @values)
-    end
-
-    def file_attribute_values
-      full_path = @context.file_absolute_name
-      short_name = File.basename(full_path)
-
-      @values["title"] = CGI.escapeHTML("File: #{short_name}")
-
-      if @context.diagram
-        @values["diagram"] = diagram_reference(@context.diagram)
-      end
-
-      @values["short_name"]   = CGI.escapeHTML(short_name)
-      @values["full_path"]    = CGI.escapeHTML(full_path)
-      @values["dtm_modified"] = @context.file_stat.mtime.to_s
-
-      if @options.webcvs
-        @values["cvsurl"] = cvs_url( @options.webcvs, @values["full_path"] )
-      end
-    end
-
-    def <=>(other)
-      self.name <=> other.name
-    end
-
-  end
-
-  class HtmlMethod
-
-    include MarkUp
-
-    attr_reader :context
-    attr_reader :src_url
-    attr_reader :img_url
-    attr_reader :source_code
-
-    @@seq = "M000000"
-
-    @@all_methods = []
-
-    def self.reset
-      @@all_methods = []
-    end
-
-    def initialize(context, html_class, options)
-      @context    = context
-      @html_class = html_class
-      @options    = options
-
-      # HACK ugly
-      @template = options.template_class
-
-      @@seq       = @@seq.succ
-      @seq        = @@seq
-      @@all_methods << self
-
-      context.viewer = self
-
-      if (ts = @context.token_stream)
-        @source_code = markup_code(ts)
-        unless @options.inline_source
-          @src_url = create_source_code_file(@source_code)
-          @img_url = HTML.gen_url(path, 'source.png')
-        end
-      end
-
-      AllReferences.add(name, self)
-    end
-
-    ##
-    # Returns a reference to outselves to be used as an href= the form depends
-    # on whether we're all in one file or in multiple files
-
-    def as_href(from_path)
-      if @options.all_one_file
-        "#" + path
-      else
-        HTML.gen_url(from_path, path)
-      end
-    end
-
-    def name
-      @context.name
-    end
-
-    def section
-      @context.section
-    end
-
-    def index_name
-      "#{@context.name} (#{@html_class.name})"
-    end
-
-    def parent_name
-      if @context.parent.parent
-        @context.parent.parent.full_name
-      else
-        nil
-      end
-    end
-
-    def aref
-      @seq
-    end
-
-    def path
-      if @options.all_one_file
-        aref
-      else
-        @html_class.path + "#" + aref
-      end
-    end
-
-    def description
-      markup(@context.comment)
-    end
-
-    def visibility
-      @context.visibility
-    end
-
-    def singleton
-      @context.singleton
-    end
-
-    def call_seq
-      cs = @context.call_seq
-      if cs
-        cs.gsub(/\n/, "<br />\n")
-      else
-        nil
-      end
-    end
-
-    def params
-      # params coming from a call-seq in 'C' will start with the
-      # method name
-      if p !~ /^\w/
-        p = @context.params.gsub(/\s*\#.*/, '')
-        p = p.tr("\n", " ").squeeze(" ")
-        p = "(" + p + ")" unless p[0] == ?(
-
-        if (block = @context.block_params)
-         # If this method has explicit block parameters, remove any
-         # explicit &block
-
-         p.sub!(/,?\s*&\w+/, '')
-
-          block.gsub!(/\s*\#.*/, '')
-          block = block.tr("\n", " ").squeeze(" ")
-          if block[0] == ?(
-            block.sub!(/^\(/, '').sub!(/\)/, '')
-          end
-          p << " {|#{block.strip}| ...}"
-        end
-      end
-      CGI.escapeHTML(p)
-    end
-
-    def create_source_code_file(code_body)
-      meth_path = @html_class.path.sub(/\.html$/, '.src')
-      FileUtils.mkdir_p(meth_path)
-      file_path = File.join(meth_path, @seq) + ".html"
-
-      template = RDoc::TemplatePage.new(@template::SRC_PAGE)
-      File.open(file_path, "w") do |f|
-        values = {
-          'title'     => CGI.escapeHTML(index_name),
-          'code'      => code_body,
-          'style_url' => style_url(file_path, @options.css),
-          'charset'   => @options.charset
-        }
-        template.write_html_on(f, values)
-      end
-      HTML.gen_url(path, file_path)
-    end
-
-    def self.all_methods
-      @@all_methods
-    end
-
-    def <=>(other)
-      @context <=> other.context
-    end
-
-    ##
-    # Given a sequence of source tokens, mark up the source code
-    # to make it look purty.
-
-    def markup_code(tokens)
-      src = ""
-      tokens.each do |t|
-        next unless t
-        #    p t.class
-#        style = STYLE_MAP[t.class]
-        style = case t
-                when RubyToken::TkCONSTANT then "ruby-constant"
-                when RubyToken::TkKW       then "ruby-keyword kw"
-                when RubyToken::TkIVAR     then "ruby-ivar"
-                when RubyToken::TkOp       then "ruby-operator"
-                when RubyToken::TkId       then "ruby-identifier"
-                when RubyToken::TkNode     then "ruby-node"
-                when RubyToken::TkCOMMENT  then "ruby-comment cmt"
-                when RubyToken::TkREGEXP   then "ruby-regexp re"
-                when RubyToken::TkSTRING   then "ruby-value str"
-                when RubyToken::TkVal      then "ruby-value"
-                else
-                    nil
-                end
-
-        text = CGI.escapeHTML(t.text)
-
-        if style
-          src << "<span class=\"#{style}\">#{text}</span>"
-        else
-          src << text
-        end
-      end
-
-      add_line_numbers(src) if @options.include_line_numbers
-      src
-    end
-
-    ##
-    # We rely on the fact that the first line of a source code listing has
-    #    # File xxxxx, line dddd
-
-    def add_line_numbers(src)
-      if src =~ /\A.*, line (\d+)/
-        first = $1.to_i - 1
-        last  = first + src.count("\n")
-        size = last.to_s.length
-        real_fmt = "%#{size}d: "
-        fmt = " " * (size+2)
-        src.gsub!(/^/) do
-          res = sprintf(fmt, first)
-          first += 1
-          fmt = real_fmt
-          res
-        end
-      end
-    end
-
-    def document_self
-      @context.document_self
-    end
-
-    def aliases
-      @context.aliases
-    end
-
-    def find_symbol(symbol, method=nil)
-      res = @context.parent.find_symbol(symbol, method)
-      if res
-        res = res.viewer
-      end
-      res
-    end
-
-  end
-
-  ##
-  # We're responsible for generating all the HTML files
-  # from the object tree defined in code_objects.rb. We
-  # generate:
-  #
-  # [files]   an html file for each input file given. These
-  #           input files appear as objects of class
-  #           TopLevel
-  #
-  # [classes] an html file for each class or module encountered.
-  #           These classes are not grouped by file: if a file
-  #           contains four classes, we'll generate an html
-  #           file for the file itself, and four html files
-  #           for the individual classes.
-  #
-  # [indices] we generate three indices for files, classes,
-  #           and methods. These are displayed in a browser
-  #           like window with three index panes across the
-  #           top and the selected description below
-  #
-  # Method descriptions appear in whatever entity (file, class,
-  # or module) that contains them.
-  #
-  # We generate files in a structure below a specified subdirectory,
-  # normally +doc+.
-  #
-  #  opdir
-  #     |
-  #     |___ files
-  #     |       |__  per file summaries
-  #     |
-  #     |___ classes
-  #             |__ per class/module descriptions
-  #
-  # HTML is generated using the Template class.
-
-  class HTML
-
-    include MarkUp
-
-    ##
-    # Converts a target url to one that is relative to a given path
-
-    def self.gen_url(path, target)
-      from          = File.dirname(path)
-      to, to_file   = File.split(target)
-
-      from = from.split("/")
-      to   = to.split("/")
-
-      while from.size > 0 and to.size > 0 and from[0] == to[0]
-        from.shift
-        to.shift
-      end
-
-      from.fill("..")
-      from.concat(to)
-      from << to_file
-      File.join(*from)
-    end
-
-    ##
-    # Generators may need to return specific subclasses depending on the
-    # options they are passed. Because of this we create them using a factory
-
-    def self.for(options)
-      AllReferences.reset
-      HtmlMethod.reset
-
-      if options.all_one_file
-        HTMLInOne.new(options)
-      else
-        HTML.new(options)
-      end
-    end
-
-    class <<self
-      protected :new
-    end
-
-    ##
-    # Set up a new HTML generator. Basically all we do here is load up the
-    # correct output temlate
-
-    def initialize(options) #:not-new:
-      @options    = options
-      load_html_template
-    end
-
-    ##
-    # Build the initial indices and output objects
-    # based on an array of TopLevel objects containing
-    # the extracted information.
-
-    def generate(toplevels)
-      @toplevels  = toplevels
-      @files      = []
-      @classes    = []
-
-      write_style_sheet
-      gen_sub_directories()
-      build_indices
-      generate_html
-    end
-
-    private
-
-    ##
-    # Load up the HTML template specified in the options.
-    # If the template name contains a slash, use it literally
-
-    def load_html_template
-      template = @options.template
-
-      unless template =~ %r{/|\\} then
-        template = File.join("rdoc/generators",
-                             @options.generator.key, template)
-      end
-
-      require template
-
-      @template = self.class.const_get @options.template.upcase
-      @options.template_class = @template
-
-    rescue LoadError
-      $stderr.puts "Could not find HTML template '#{template}'"
-      exit 99
-    end
-
-    ##
-    # Write out the style sheet used by the main frames
-
-    def write_style_sheet
-      return unless @template.constants.include? :STYLE or
-                    @template.constants.include? 'STYLE'
-
-      template = RDoc::TemplatePage.new @template::STYLE
-
-      unless @options.css then
-        File.open(CSS_NAME, "w") do |f|
-          values = {}
-
-          if @template.constants.include? :FONTS or
-             @template.constants.include? 'FONTS' then
-            values["fonts"] = @template::FONTS
-          end
-
-          template.write_html_on(f, values)
-        end
-      end
-    end
-
-    ##
-    # See the comments at the top for a description of the directory structure
-
-    def gen_sub_directories
-      FileUtils.mkdir_p(FILE_DIR)
-      FileUtils.mkdir_p(CLASS_DIR)
-    rescue
-      $stderr.puts $!.message
-      exit 1
-    end
-
-    ##
-    # Generate:
-    #
-    # * a list of HtmlFile objects for each TopLevel object.
-    # * a list of HtmlClass objects for each first level
-    #   class or module in the TopLevel objects
-    # * a complete list of all hyperlinkable terms (file,
-    #   class, module, and method names)
-
-    def build_indices
-      @toplevels.each do |toplevel|
-        @files << HtmlFile.new(toplevel, @options, FILE_DIR)
-      end
-
-      RDoc::TopLevel.all_classes_and_modules.each do |cls|
-        build_class_list(cls, @files[0], CLASS_DIR)
-      end
-    end
-
-    def build_class_list(from, html_file, class_dir)
-      @classes << HtmlClass.new(from, html_file, class_dir, @options)
-      from.each_classmodule do |mod|
-        build_class_list(mod, html_file, class_dir)
-      end
-    end
-
-    ##
-    # Generate all the HTML
-
-    def generate_html
-      # the individual descriptions for files and classes
-      gen_into(@files)
-      gen_into(@classes)
-      # and the index files
-      gen_file_index
-      gen_class_index
-      gen_method_index
-      gen_main_index
-
-      # this method is defined in the template file
-      write_extra_pages if defined? write_extra_pages
-    end
-
-    def gen_into(list)
-      list.each do |item|
-        if item.document_self
-          op_file = item.path
-          FileUtils.mkdir_p(File.dirname(op_file))
-          File.open(op_file, "w") { |file| item.write_on(file) }
-        end
-      end
-
-    end
-
-    def gen_file_index
-      gen_an_index @files, 'Files', @template::FILE_INDEX, "fr_file_index.html"
-    end
-
-    def gen_class_index
-      gen_an_index(@classes, 'Classes', @template::CLASS_INDEX,
-                   "fr_class_index.html")
-    end
-
-    def gen_method_index
-      gen_an_index(HtmlMethod.all_methods, 'Methods', @template::METHOD_INDEX,
-                   "fr_method_index.html")
-    end
-
-    def gen_an_index(collection, title, template, filename)
-      template = RDoc::TemplatePage.new @template::FR_INDEX_BODY, template
-      res = []
-      collection.sort.each do |f|
-        if f.document_self
-          res << { "href" => f.path, "name" => f.index_name }
-        end
-      end
-
-      values = {
-        "entries"    => res,
-        'list_title' => CGI.escapeHTML(title),
-        'index_url'  => main_url,
-        'charset'    => @options.charset,
-        'style_url'  => style_url('', @options.css),
-      }
-
-      File.open(filename, "w") do |f|
-        template.write_html_on(f, values)
-      end
-    end
-
-    ##
-    # The main index page is mostly a template frameset, but includes the
-    # initial page. If the <tt>--main</tt> option was given, we use this as
-    # our main page, otherwise we use the first file specified on the command
-    # line.
-
-    def gen_main_index
-      template = RDoc::TemplatePage.new @template::INDEX
-
-      open 'index.html', 'w'  do |f|
-        classes = @classes.sort.map { |klass| klass.value_hash }
-
-        values = {
-          'main_page'     => @main_page,
-          'initial_page'  => main_url,
-          'style_url'     => style_url('', @options.css),
-          'title'         => CGI.escapeHTML(@options.title),
-          'charset'       => @options.charset,
-          'classes'       => classes,
-        }
-
-        values['inline_source'] = @options.inline_source
-
-        template.write_html_on f, values
-      end
-    end
-
-    ##
-    # Returns the url of the main page
-
-    def main_url
-      @main_page = @options.main_page
-      @main_page_ref = nil
-      if @main_page
-        @main_page_ref = AllReferences[@main_page]
-        if @main_page_ref then
-          @main_page_path = @main_page_ref.path
-        else
-          $stderr.puts "Could not find main page #{@main_page}"
-        end
-      end
-
-      unless @main_page_path then
-        file = @files.find { |file| file.document_self }
-        @main_page_path = file.path if file
-      end
-
-      unless @main_page_path then
-        $stderr.puts "Couldn't find anything to document"
-        $stderr.puts "Perhaps you've used :stopdoc: in all classes"
-        exit 1
-      end
-
-      @main_page_path
-    end
-
-  end
-
-  class HTMLInOne < HTML
-
-    def initialize(*args)
-      super
-    end
-
-    ##
-    # Build the initial indices and output objects
-    # based on an array of TopLevel objects containing
-    # the extracted information.
-
-    def generate(info)
-      @toplevels  = info
-      @files      = []
-      @classes    = []
-      @hyperlinks = {}
-
-      build_indices
-      generate_xml
-    end
-
-    ##
-    # Generate:
-    #
-    # * a list of HtmlFile objects for each TopLevel object.
-    # * a list of HtmlClass objects for each first level
-    #   class or module in the TopLevel objects
-    # * a complete list of all hyperlinkable terms (file,
-    #   class, module, and method names)
-
-    def build_indices
-
-      @toplevels.each do |toplevel|
-        @files << HtmlFile.new(toplevel, @options, FILE_DIR)
-      end
-
-      RDoc::TopLevel.all_classes_and_modules.each do |cls|
-        build_class_list(cls, @files[0], CLASS_DIR)
-      end
-    end
-
-    def build_class_list(from, html_file, class_dir)
-      @classes << HtmlClass.new(from, html_file, class_dir, @options)
-      from.each_classmodule do |mod|
-        build_class_list(mod, html_file, class_dir)
-      end
-    end
-
-    ##
-    # Generate all the HTML. For the one-file case, we generate
-    # all the information in to one big hash
-
-    def generate_xml
-      values = {
-        'charset' => @options.charset,
-        'files'   => gen_into(@files),
-        'classes' => gen_into(@classes),
-        'title'        => CGI.escapeHTML(@options.title),
-      }
-
-      # this method is defined in the template file
-      write_extra_pages if defined? write_extra_pages
-
-      template = RDoc::TemplatePage.new @template::ONE_PAGE
-
-      if @options.op_name
-        opfile = File.open(@options.op_name, "w")
-      else
-        opfile = $stdout
-      end
-      template.write_html_on(opfile, values)
-    end
-
-    def gen_into(list)
-      res = []
-      list.each do |item|
-        res << item.value_hash
-      end
-      res
-    end
-
-    def gen_file_index
-      gen_an_index(@files, 'Files')
-    end
-
-    def gen_class_index
-      gen_an_index(@classes, 'Classes')
-    end
-
-    def gen_method_index
-      gen_an_index(HtmlMethod.all_methods, 'Methods')
-    end
-
-    def gen_an_index(collection, title)
-      res = []
-      collection.sort.each do |f|
-        if f.document_self
-          res << { "href" => f.path, "name" => f.index_name }
-        end
-      end
-
-      return {
-        "entries" => res,
-        'list_title' => title,
-        'index_url'  => main_url,
-      }
-    end
-
-  end
-
-end
-
diff --git a/lib/rdoc/generators/html/hefss.rb b/lib/rdoc/generators/html/hefss.rb
deleted file mode 100644
index c7b4fcc449..0000000000
--- a/lib/rdoc/generators/html/hefss.rb
+++ /dev/null
@@ -1,414 +0,0 @@
-require 'rdoc/generators/html'
-require 'rdoc/generators/html/html'
-
-module RDoc::Generators::HTML::HEFSS
-
-  FONTS = "Verdana, Arial, Helvetica, sans-serif"
-
-STYLE = <<-EOF
-body,p { font-family: Verdana, Arial, Helvetica, sans-serif;
-       color: #000040; background: #BBBBBB;
-}
-
-td { font-family: Verdana, Arial, Helvetica, sans-serif;
-       color: #000040;
-}
-
-.attr-rw { font-size: small; color: #444488 }
-
-.title-row {color:      #eeeeff;
-	    background: #BBBBDD;
-}
-
-.big-title-font { color: white;
-                  font-family: Verdana, Arial, Helvetica, sans-serif;
-                  font-size: large;
-                  height: 50px}
-
-.small-title-font { color: purple;
-                    font-family: Verdana, Arial, Helvetica, sans-serif;
-                    font-size: small; }
-
-.aqua { color: purple }
-
-.method-name, attr-name {
-      font-family: monospace; font-weight: bold;
-}
-
-.tablesubtitle {
-   width: 100%;
-   margin-top: 1ex;
-   margin-bottom: .5ex;
-   padding: 5px 0px 5px 20px;
-   font-size: large;
-   color: purple;
-   background: #BBBBCC;
-}
-
-.tablesubsubtitle {
-   width: 100%;
-   margin-top: 1ex;
-   margin-bottom: .5ex;
-   padding: 5px 0px 5px 20px;
-   font-size: medium;
-   color: white;
-   background: #BBBBCC;
-}
-
-.name-list {
-  font-family: monospace;
-  margin-left: 40px;
-  margin-bottom: 2ex;
-  line-height: 140%;
-}
-
-.description {
-  margin-left: 40px;
-  margin-bottom: 2ex;
-  line-height: 140%;
-}
-
-.methodtitle {
-  font-size: medium;
-  text_decoration: none;
-  padding: 3px 3px 3px 20px;
-  color: #0000AA;
-}
-
-.column-title {
-  font-size: medium;
-  font-weight: bold;
-  text_decoration: none;
-  padding: 3px 3px 3px 20px;
-  color: #3333CC;
-  }
-
-.variable-name {
-  font-family: monospace;
-  font-size: medium;
-  text_decoration: none;
-  padding: 3px 3px 3px 20px;
-  color: #0000AA;
-}
-
-.row-name {
-  font-size: medium;
-  font-weight: medium;
-  font-family: monospace;
-  text_decoration: none;
-  padding: 3px 3px 3px 20px;
-}
-
-.paramsig {
-   font-size: small;
-}
-
-.srcbut { float: right }
-
-  EOF
-
-  BODY = <<-EOF
-<html><head>
-  <title><%= values["title"] %></title>
-  <meta http-equiv="Content-Type" content="text/html; charset=<%= values["charset"] %>">
-  <link rel="stylesheet" href="<%= values["style_url"] %>" type="text/css" media="screen" />
-  <script type="text/javascript" language="JavaScript">
-  <!--
-  function popCode(url) {
-    parent.frames.source.location = url
-  }
-  //-->
-  </script>
-</head>
-<body bgcolor="#BBBBBB">
-
-<%= template_include %>  <!-- banner header -->
-
-<% if values["diagram"] then %>
-<table width="100%"><tr><td align="center">
-<%= values["diagram"] %>
-</td></tr></table>
-<% end %>
-
-<% if values["description"] then %>
-<div class="description"><%= values["description"] %></div>
-<% end %>
-
-<% if values["requires"] then %>
-<table cellpadding="5" width="100%">
-<tr><td class="tablesubtitle">Required files</td></tr>
-</table><br />
-<div class="name-list">
-<% values["requires"].each do |requires| %>
-<%= href requires["aref"], requires["name"] %>
-<% end # values["requires"] %>
-<% end %>
-</div>
-
-<% if values["sections"] then %>
-<% values["sections"].each do |sections| %>
-<% if sections["method_list"] then %>
-<% sections["method_list"].each do |method_list| %>
-<% if method_list["methods"] then %>
-<table cellpadding="5" width="100%">
-<tr><td class="tablesubtitle">Subroutines and Functions</td></tr>
-</table><br />
-<div class="name-list">
-<% method_list["methods"].each do |methods| %>
-<a href="<%= methods["codeurl"] %>" target="source"><%= methods["name"] %></a>
-<% end # values["methods"] %>
-</div>
-<% end %>
-<% end # values["method_list"] %>
-<% end %>
-
-<% if sections["attributes"] then %>
-<table cellpadding="5" width="100%">
-<tr><td class="tablesubtitle">Arguments</td></tr>
-</table><br />
-<table cellspacing="5">
-<% sections["attributes"].each do |attributes| %>
-     <tr valign="top">
-<% if attributes["rw"] then %>
-       <td align="center" class="attr-rw">&nbsp;[<%= attributes["rw"] %>]&nbsp;</td>
-<% end %>
-<% unless attributes["rw"] then %>
-       <td></td>
-<% end %>
-       <td class="attr-name"><%= attributes["name"] %></td>
-       <td><%= attributes["a_desc"] %></td>
-     </tr>
-<% end # values["attributes"] %>
-</table>
-<% end %>
-<% end # values["sections"] %>
-<% end %>
-
-<% if values["classlist"] then %>
-<table cellpadding="5" width="100%">
-<tr><td class="tablesubtitle">Modules</td></tr>
-</table><br />
-<%= values["classlist"] %><br />
-<% end %>
-
-  <%= template_include %>  <!-- method descriptions -->
-
-</body>
-</html>
-  EOF
-
-  FILE_PAGE = <<-EOF
-<table width="100%">
- <tr class="title-row">
- <td><table width="100%"><tr>
-   <td class="big-title-font" colspan="2"><font size="-3"><b>File</b><br /></font><%= values["short_name"] %></td>
-   <td align="right"><table cellspacing="0" cellpadding="2">
-         <tr>
-           <td  class="small-title-font">Path:</td>
-           <td class="small-title-font"><%= values["full_path"] %>
-<% if values["cvsurl"] then %>
-				&nbsp;(<a href="<%= values["cvsurl"] %>"><acronym title="Concurrent Versioning System">CVS</acronym></a>)
-<% end %>
-           </td>
-         </tr>
-         <tr>
-           <td class="small-title-font">Modified:</td>
-           <td class="small-title-font"><%= values["dtm_modified"] %></td>
-         </tr>
-        </table>
-    </td></tr></table></td>
-  </tr>
-</table><br />
-  EOF
-
-  CLASS_PAGE = <<-EOF
-<table width="100%" border="0" cellspacing="0">
- <tr class="title-row">
- <td class="big-title-font">
-   <font size="-3"><b><%= values["classmod"] %></b><br /></font><%= values["full_name"] %>
- </td>
- <td align="right">
-   <table cellspacing="0" cellpadding="2">
-     <tr valign="top">
-      <td class="small-title-font">In:</td>
-      <td class="small-title-font">
-<% values["infiles"].each do |infiles| %>
-<%= href infiles["full_path_url"], infiles["full_path"] %>
-<% if infiles["cvsurl"] then %>
-&nbsp;(<a href="<%= infiles["cvsurl"] %>"><acronym title="Concurrent Versioning System">CVS</acronym></a>)
-<% end %>
-<% end # values["infiles"] %>
-      </td>
-     </tr>
-<% if values["parent"] then %>
-     <tr>
-      <td class="small-title-font">Parent:</td>
-      <td class="small-title-font">
-<% if values["par_url"] then %>
-        <a href="<%= values["par_url"] %>" class="cyan">
-<% end %>
-<%= values["parent"] %>
-<% if values["par_url"] then %>
-         </a>
-<% end %>
-      </td>
-     </tr>
-<% end %>
-   </table>
-  </td>
-  </tr>
-</table><br />
-  EOF
-
-  METHOD_LIST = <<-EOF
-<% if values["includes"] then %>
-<div class="tablesubsubtitle">Uses</div><br />
-<div class="name-list">
-<% values["includes"].each do |includes| %>
-    <span class="method-name"><%= href includes["aref"], includes["name"] %></span>
-<% end # values["includes"] %>
-</div>
-<% end %>
-
-<% if values["sections"] then %>
-<% values["sections"].each do |sections| %>
-<% if sections["method_list"] then %>
-<% sections["method_list"].each do |method_list| %>
-<% if method_list["methods"] then %>
-<table cellpadding="5" width="100%">
-<tr><td class="tablesubtitle"><%= method_list["type"] %> <%= method_list["category"] %> methods</td></tr>
-</table>
-<% method_list["methods"].each do |methods| %>
-<table width="100%" cellspacing="0" cellpadding="5" border="0">
-<tr><td class="methodtitle">
-<a name="<%= methods["aref"] %>">
-<b><%= methods["name"] %></b><%= methods["params"] %>
-<% if methods["codeurl"] then %>
-<a href="<%= methods["codeurl"] %>" target="source" class="srclink">src</a>
-<% end %>
-</a></td></tr>
-</table>
-<% if method_list["m_desc"] then %>
-<div class="description">
-<%= method_list["m_desc"] %>
-</div>
-<% end %>
-<% end # method_list["methods"] %>
-<% end %>
-<% end # sections["method_list"] %>
-<% end %>
-<% end # values["sections"] %>
-<% end %>
-  EOF
-
-  SRC_PAGE = <<-EOF
-<html>
-<head><title><%= values["title"] %></title>
-<meta http-equiv="Content-Type" content="text/html; charset=<%= values["charset"] %>">
-<style type="text/css">
-  .kw { color: #3333FF; font-weight: bold }
-  .cmt { color: green; font-style: italic }
-  .str { color: #662222; font-style: italic }
-  .re  { color: #662222; }
-.ruby-comment    { color: green; font-style: italic }
-.ruby-constant   { color: #4433aa; font-weight: bold; }
-.ruby-identifier { color: #222222;  }
-.ruby-ivar       { color: #2233dd; }
-.ruby-keyword    { color: #3333FF; font-weight: bold }
-.ruby-node       { color: #777777; }
-.ruby-operator   { color: #111111;  }
-.ruby-regexp     { color: #662222; }
-.ruby-value      { color: #662222; font-style: italic }
-</style>
-</head>
-<body bgcolor="#BBBBBB">
-<pre><%= values["code"] %></pre>
-</body>
-</html>
-  EOF
-
-  FR_INDEX_BODY = %{
-<%= template_include %>
-}
-
-  FILE_INDEX = <<-EOF
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=<%= values["charset"] %>">
-<style type="text/css">
-<!--
-  body {
-background-color: #bbbbbb;
-     font-family: #{FONTS};
-       font-size: 11px;
-      font-style: normal;
-     line-height: 14px;
-           color: #000040;
-  }
-div.banner {
-  background: #bbbbcc;
-  color:      white;
-  padding: 1;
-  margin: 0;
-  font-size: 90%;
-  font-weight: bold;
-  line-height: 1.1;
-  text-align: center;
-  width: 100%;
-}
-
--->
-</style>
-<base target="docwin">
-</head>
-<body>
-<div class="banner"><%= values["list_title"] %></div>
-<% values["entries"].each do |entries| %>
-<a href="<%= entries["href"] %>"><%= entries["name"] %></a><br />
-<% end # values["entries"] %>
-</body></html>
-  EOF
-
-  CLASS_INDEX = FILE_INDEX
-  METHOD_INDEX = FILE_INDEX
-
-  INDEX = <<-EOF
-<html>
-<head>
-  <title><%= values["title"] %></title>
-  <meta http-equiv="Content-Type" content="text/html; charset=<%= values["charset"] %>">
-</head>
-
-<frameset cols="20%,*">
-    <frameset rows="15%,35%,50%">
-        <frame src="fr_file_index.html"   title="Files" name="Files">
-        <frame src="fr_class_index.html"  name="Modules">
-        <frame src="fr_method_index.html" name="Subroutines and Functions">
-    </frameset>
-    <frameset rows="80%,20%">
-      <frame  src="<%= values["initial_page"] %>" name="docwin">
-      <frame  src="blank.html" name="source">
-    </frameset>
-    <noframes>
-          <body bgcolor="#BBBBBB">
-            Click <a href="html/index.html">here</a> for a non-frames
-            version of this page.
-          </body>
-    </noframes>
-</frameset>
-
-</html>
-  EOF
-
-  # Blank page to use as a target
-  BLANK = %{
-<html><body bgcolor="#BBBBBB"></body></html>
-}
-
-  def write_extra_pages
-    template = TemplatePage.new(BLANK)
-    File.open("blank.html", "w") { |f| template.write_html_on(f, {}) }
-  end
-
-end
-
diff --git a/lib/rdoc/generators/html/html.rb b/lib/rdoc/generators/html/html.rb
deleted file mode 100644
index 4eb7a86975..0000000000
--- a/lib/rdoc/generators/html/html.rb
+++ /dev/null
@@ -1,704 +0,0 @@
-require 'rdoc/generators/html'
-require 'rdoc/generators/html/one_page_html'
-
-##
-# = CSS2 RDoc HTML template
-#
-# This is a template for RDoc that uses XHTML 1.0 Transitional and dictates a
-# bit more of the appearance of the output to cascading stylesheets than the
-# default. It was designed for clean inline code display, and uses DHTMl to
-# toggle the visbility of each method's source with each click on the '[source]'
-# link.
-#
-# == Authors
-#
-# * Michael Granger <ged@FaerieMUD.org>
-#
-# Copyright (c) 2002, 2003 The FaerieMUD Consortium. Some rights reserved.
-#
-# This work is licensed under the Creative Commons Attribution License. To view
-# a copy of this license, visit http://creativecommons.org/licenses/by/1.0/ or
-# send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford, California
-# 94305, USA.
-
-module RDoc::Generators::HTML::HTML
-
-  FONTS = "Verdana,Arial,Helvetica,sans-serif"
-
-  STYLE = <<-EOF
-body {
-    font-family: Verdana,Arial,Helvetica,sans-serif;
-    font-size:   90%;
-    margin: 0;
-    margin-left: 40px;
-    padding: 0;
-    background: white;
-}
-
-h1,h2,h3,h4 { margin: 0; color: #efefef; background: transparent; }
-h1 { font-size: 150%; }
-h2,h3,h4 { margin-top: 1em; }
-
-a { background: #eef; color: #039; text-decoration: none; }
-a:hover { background: #039; color: #eef; }
-
-/* Override the base stylesheet's Anchor inside a table cell */
-td > a {
-  background: transparent;
-  color: #039;
-  text-decoration: none;
-}
-
-/* and inside a section title */
-.section-title > a {
-  background: transparent;
-  color: #eee;
-  text-decoration: none;
-}
-
-/* === Structural elements =================================== */
-
-div#index {
-    margin: 0;
-    margin-left: -40px;
-    padding: 0;
-    font-size: 90%;
-}
-
-
-div#index a {
-    margin-left: 0.7em;
-}
-
-div#index .section-bar {
-   margin-left: 0px;
-   padding-left: 0.7em;
-   background: #ccc;
-   font-size: small;
-}
-
-
-div#classHeader, div#fileHeader {
-    width: auto;
-    color: white;
-    padding: 0.5em 1.5em 0.5em 1.5em;
-    margin: 0;
-    margin-left: -40px;
-    border-bottom: 3px solid #006;
-}
-
-div#classHeader a, div#fileHeader a {
-    background: inherit;
-    color: white;
-}
-
-div#classHeader td, div#fileHeader td {
-    background: inherit;
-    color: white;
-}
-
-
-div#fileHeader {
-    background: #057;
-}
-
-div#classHeader {
-    background: #048;
-}
-
-
-.class-name-in-header {
-  font-size:  180%;
-  font-weight: bold;
-}
-
-
-div#bodyContent {
-    padding: 0 1.5em 0 1.5em;
-}
-
-div#description {
-    padding: 0.5em 1.5em;
-    background: #efefef;
-    border: 1px dotted #999;
-}
-
-div#description h1,h2,h3,h4,h5,h6 {
-    color: #125;;
-    background: transparent;
-}
-
-div#validator-badges {
-    text-align: center;
-}
-div#validator-badges img { border: 0; }
-
-div#copyright {
-    color: #333;
-    background: #efefef;
-    font: 0.75em sans-serif;
-    margin-top: 5em;
-    margin-bottom: 0;
-    padding: 0.5em 2em;
-}
-
-
-/* === Classes =================================== */
-
-table.header-table {
-    color: white;
-    font-size: small;
-}
-
-.type-note {
-    font-size: small;
-    color: #DEDEDE;
-}
-
-.xxsection-bar {
-    background: #eee;
-    color: #333;
-    padding: 3px;
-}
-
-.section-bar {
-   color: #333;
-   border-bottom: 1px solid #999;
-    margin-left: -20px;
-}
-
-
-.section-title {
-    background: #79a;
-    color: #eee;
-    padding: 3px;
-    margin-top: 2em;
-    margin-left: -30px;
-    border: 1px solid #999;
-}
-
-.top-aligned-row {  vertical-align: top }
-.bottom-aligned-row { vertical-align: bottom }
-
-/* --- Context section classes ----------------------- */
-
-.context-row { }
-.context-item-name { font-family: monospace; font-weight: bold; color: black; }
-.context-item-value { font-size: small; color: #448; }
-.context-item-desc { color: #333; padding-left: 2em; }
-
-/* --- Method classes -------------------------- */
-.method-detail {
-    background: #efefef;
-    padding: 0;
-    margin-top: 0.5em;
-    margin-bottom: 1em;
-    border: 1px dotted #ccc;
-}
-.method-heading {
-  color: black;
-  background: #ccc;
-  border-bottom: 1px solid #666;
-  padding: 0.2em 0.5em 0 0.5em;
-}
-.method-signature { color: black; background: inherit; }
-.method-name { font-weight: bold; }
-.method-args { font-style: italic; }
-.method-description { padding: 0 0.5em 0 0.5em; }
-
-/* --- Source code sections -------------------- */
-
-a.source-toggle { font-size: 90%; }
-div.method-source-code {
-    background: #262626;
-    color: #ffdead;
-    margin: 1em;
-    padding: 0.5em;
-    border: 1px dashed #999;
-    overflow: hidden;
-}
-
-div.method-source-code pre { color: #ffdead; overflow: hidden; }
-
-/* --- Ruby keyword styles --------------------- */
-
-.standalone-code { background: #221111; color: #ffdead; overflow: hidden; }
-
-.ruby-constant  { color: #7fffd4; background: transparent; }
-.ruby-keyword { color: #00ffff; background: transparent; }
-.ruby-ivar    { color: #eedd82; background: transparent; }
-.ruby-operator  { color: #00ffee; background: transparent; }
-.ruby-identifier { color: #ffdead; background: transparent; }
-.ruby-node    { color: #ffa07a; background: transparent; }
-.ruby-comment { color: #b22222; font-weight: bold; background: transparent; }
-.ruby-regexp  { color: #ffa07a; background: transparent; }
-.ruby-value   { color: #7fffd4; background: transparent; }
-EOF
-
-
-#####################################################################
-### H E A D E R   T E M P L A T E
-#####################################################################
-
-  XHTML_PREAMBLE = <<-EOF
-<?xml version="1.0" encoding="<%= values["charset"] %>"?>
-<!DOCTYPE html
-     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-  EOF
-
-  HEADER = XHTML_PREAMBLE + <<-EOF
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-  <title><%= values["title"] %></title>
-  <meta http-equiv="Content-Type" content="text/html; charset=<%= values["charset"] %>" />
-  <meta http-equiv="Content-Script-Type" content="text/javascript" />
-  <link rel="stylesheet" href="<%= values["style_url"] %>" type="text/css" media="screen" />
-  <script type="text/javascript">
-  // <![CDATA[
-
-  function popupCode( url ) {
-    window.open(url, "Code", "resizable=yes,scrollbars=yes,toolbar=no,status=no,height=150,width=400")
-  }
-
-  function toggleCode( id ) {
-    if ( document.getElementById )
-      elem = document.getElementById( id );
-    else if ( document.all )
-      elem = eval( "document.all." + id );
-    else
-      return false;
-
-    elemStyle = elem.style;
-
-    if ( elemStyle.display != "block" ) {
-      elemStyle.display = "block"
-    } else {
-      elemStyle.display = "none"
-    }
-
-    return true;
-  }
-
-  // Make codeblocks hidden by default
-  document.writeln( "<style type=\\"text/css\\">div.method-source-code { display: none }</style>" )
-
-  // ]]>
-  </script>
-
-</head>
-<body>
-EOF
-
-#####################################################################
-### C O N T E X T   C O N T E N T   T E M P L A T E
-#####################################################################
-
-  CONTEXT_CONTENT = %{
-}
-
-#####################################################################
-### F O O T E R   T E M P L A T E
-#####################################################################
-
-  FOOTER = <<-EOF
-<div id="validator-badges">
-  <p><small><a href="http://validator.w3.org/check/referer">[Validate]</a></small></p>
-</div>
-
-</body>
-</html>
-  EOF
-
-
-#####################################################################
-### F I L E   P A G E   H E A D E R   T E M P L A T E
-#####################################################################
-
-  FILE_PAGE = <<-EOF
-  <div id="fileHeader">
-    <h1><%= values["short_name"] %></h1>
-    <table class="header-table">
-    <tr class="top-aligned-row">
-      <td><strong>Path:</strong></td>
-      <td><%= values["full_path"] %>
-<% if values["cvsurl"] then %>
-        &nbsp;(<a href="<%= values["cvsurl"] %>"><acronym title="Concurrent Versioning System">CVS</acronym></a>)
-<% end %>
-      </td>
-    </tr>
-    <tr class="top-aligned-row">
-      <td><strong>Last Update:</strong></td>
-      <td><%= values["dtm_modified"] %></td>
-    </tr>
-    </table>
-  </div>
-  EOF
-
-#####################################################################
-### C L A S S   P A G E   H E A D E R   T E M P L A T E
-#####################################################################
-
-  CLASS_PAGE = <<-EOF
-    <div id="classHeader">
-        <table class="header-table">
-        <tr class="top-aligned-row">
-          <td><strong><%= values["classmod"] %></strong></td>
-          <td class="class-name-in-header"><%= values["full_name"] %></td>
-        </tr>
-        <tr class="top-aligned-row">
-            <td><strong>In:</strong></td>
-            <td>
-<% values["infiles"].each do |infiles| %>
-<% if infiles["full_path_url"] then %>
-                <a href="<%= infiles["full_path_url"] %>">
-<% end %>
-                <%= infiles["full_path"] %>
-<% if infiles["full_path_url"] then %>
-                </a>
-<% end %>
-<% if infiles["cvsurl"] then %>
-        &nbsp;(<a href="<%= infiles["cvsurl"] %>"><acronym title="Concurrent Versioning System">CVS</acronym></a>)
-<% end %>
-        <br />
-<% end # values["infiles"] %>
-            </td>
-        </tr>
-
-<% if values["parent"] then %>
-        <tr class="top-aligned-row">
-            <td><strong>Parent:</strong></td>
-            <td>
-<% if values["par_url"] then %>
-                <a href="<%= values["par_url"] %>">
-<% end %>
-                <%= values["parent"] %>
-<% if values["par_url"] then %>
-               </a>
-<% end %>
-            </td>
-        </tr>
-<% end %>
-        </table>
-    </div>
-  EOF
-
-#####################################################################
-### M E T H O D   L I S T   T E M P L A T E
-#####################################################################
-
-  METHOD_LIST = <<-EOF
-
-  <div id="contextContent">
-<% if values["diagram"] then %>
-    <div id="diagram">
-      <%= values["diagram"] %>
-    </div>
-<% end %>
-
-<% if values["description"] then %>
-    <div id="description">
-      <%= values["description"] %>
-    </div>
-<% end %>
-
-<% if values["requires"] then %>
-    <div id="requires-list">
-      <h3 class="section-bar">Required files</h3>
-
-      <div class="name-list">
-<% values["requires"].each do |requires| %>
-        <%= href requires["aref"], requires["name"] %>&nbsp;&nbsp;
-<% end # values["requires"] %>
-      </div>
-    </div>
-<% end %>
-
-<% if values["toc"] then %>
-    <div id="contents-list">
-      <h3 class="section-bar">Contents</h3>
-      <ul>
-<% values["toc"].each do |toc| %>
-      <li><a href="#<%= values["href"] %>"><%= values["secname"] %></a></li>
-<% end # values["toc"] %>
-     </ul>
-<% end %>
-   </div>
-
-<% if values["methods"] then %>
-    <div id="method-list">
-      <h3 class="section-bar">Methods</h3>
-
-      <div class="name-list">
-<% values["methods"].each do |methods| %>
-        <%= href methods["aref"], methods["name"] %>&nbsp;&nbsp;
-<% end # values["methods"] %>
-      </div>
-    </div>
-<% end %>
-
-  </div>
-
-
-    <!-- if includes -->
-<% if values["includes"] then %>
-    <div id="includes">
-      <h3 class="section-bar">Included Modules</h3>
-
-      <div id="includes-list">
-<% values["includes"].each do |includes| %>
-        <span class="include-name"><%= href includes["aref"], includes["name"] %></span>
-<% end # values["includes"] %>
-      </div>
-    </div>
-<% end %>
-
-<% values["sections"].each do |sections| %>
-    <div id="section">
-<% if sections["sectitle"] then %>
-      <h2 class="section-title"><a name="<%= sections["secsequence"] %>"><%= sections["sectitle"] %></a></h2>
-<% if sections["seccomment"] then %>
-      <div class="section-comment">
-        <%= sections["seccomment"] %>
-      </div>
-<% end %>
-<% end %>
-
-<% if values["classlist"] then %>
-    <div id="class-list">
-      <h3 class="section-bar">Classes and Modules</h3>
-
-      <%= values["classlist"] %>
-    </div>
-<% end %>
-
-<% if values["constants"] then %>
-    <div id="constants-list">
-      <h3 class="section-bar">Constants</h3>
-
-      <div class="name-list">
-        <table summary="Constants">
-<% values["constants"].each do |constants| $stderr.puts({ :constants => constants }.inspect) %>
-        <tr class="top-aligned-row context-row">
-          <td class="context-item-name"><%= values["name"] %></td>
-          <td>=</td>
-          <td class="context-item-value"><%= values["value"] %></td>
-<% if values["desc"] then %>
-          <td width="3em">&nbsp;</td>
-          <td class="context-item-desc"><%= values["desc"] %></td>
-<% end %>
-        </tr>
-<% end # values["constants"] %>
-        </table>
-      </div>
-    </div>
-<% end %>
-
-<% if values["aliases"] then %>
-    <div id="aliases-list">
-      <h3 class="section-bar">External Aliases</h3>
-
-      <div class="name-list">
-                        <table summary="aliases">
-<% values["aliases"].each do |aliases| $stderr.puts({ :aliases => aliases }.inspect) %>
-        <tr class="top-aligned-row context-row">
-          <td class="context-item-name"><%= values["old_name"] %></td>
-          <td>-&gt;</td>
-          <td class="context-item-value"><%= values["new_name"] %></td>
-        </tr>
-<% if values["desc"] then %>
-      <tr class="top-aligned-row context-row">
-        <td>&nbsp;</td>
-        <td colspan="2" class="context-item-desc"><%= values["desc"] %></td>
-      </tr>
-<% end %>
-<% end # values["aliases"] %>
-        </table>
-      </div>
-    </div>
-<% end %>
-
-
-<% if values["attributes"] then %>
-    <div id="attribute-list">
-      <h3 class="section-bar">Attributes</h3>
-
-      <div class="name-list">
-        <table>
-<% values["attributes"].each do |attributes| $stderr.puts({ :attributes => attributes }.inspect) %>
-        <tr class="top-aligned-row context-row">
-          <td class="context-item-name"><%= values["name"] %></td>
-<% if values["rw"] then %>
-          <td class="context-item-value">&nbsp;[<%= values["rw"] %>]&nbsp;</td>
-<% end %>
-<% unless values["rw"] then %>
-          <td class="context-item-value">&nbsp;&nbsp;</td>
-<% end %>
-          <td class="context-item-desc"><%= values["a_desc"] %></td>
-        </tr>
-<% end # values["attributes"] %>
-        </table>
-      </div>
-    </div>
-<% end %>
-      
-
-
-    <!-- if method_list -->
-<% if sections["method_list"] then %>
-    <div id="methods">
-<% sections["method_list"].each do |method_list| %>
-<% if method_list["methods"] then %>
-      <h3 class="section-bar"><%= method_list["type"] %> <%= method_list["category"] %> methods</h3>
-
-<% method_list["methods"].each do |methods| %>
-      <div id="method-<%= methods["aref"] %>" class="method-detail">
-        <a name="<%= methods["aref"] %>"></a>
-
-        <div class="method-heading">
-<% if methods["codeurl"] then %>
-          <a href="<%= methods["codeurl"] %>" target="Code" class="method-signature"
-            onclick="popupCode('<%= methods["codeurl"] %>');return false;">
-<% end %>
-<% if methods["sourcecode"] then %>
-          <a href="#<%= methods["aref"] %>" class="method-signature">
-<% end %>
-<% if methods["callseq"] then %>
-          <span class="method-name"><%= methods["callseq"] %></span>
-<% end %>
-<% unless methods["callseq"] then %>
-          <span class="method-name"><%= methods["name"] %></span><span class="method-args"><%= methods["params"] %></span>
-<% end %>
-<% if methods["codeurl"] then %>
-          </a>
-<% end %>
-<% if methods["sourcecode"] then %>
-          </a>
-<% end %>
-        </div>
-
-        <div class="method-description">
-<% if methods["m_desc"] then %>
-          <%= methods["m_desc"] %>
-<% end %>
-<% if methods["sourcecode"] then %>
-          <p><a class="source-toggle" href="#"
-            onclick="toggleCode('<%= methods["aref"] %>-source');return false;">[Source]</a></p>
-          <div class="method-source-code" id="<%= methods["aref"] %>-source">
-<pre>
-<%= methods["sourcecode"] %>
-</pre>
-          </div>
-<% end %>
-        </div>
-      </div>
-
-<% end # method_list["methods"] %>
-<% end %>
-<% end # sections["method_list"] %>
-
-    </div>
-<% end %>
-<% end # values["sections"] %>
-  EOF
-
-#####################################################################
-### B O D Y   T E M P L A T E
-#####################################################################
-
-  BODY = HEADER + %{
-
-<%= template_include %>  <!-- banner header -->
-
-  <div id="bodyContent">
-
-} +  METHOD_LIST + %{
-
-  </div>
-
-} + FOOTER
-
-#####################################################################
-### S O U R C E   C O D E   T E M P L A T E
-#####################################################################
-
-  SRC_PAGE = XHTML_PREAMBLE + <<-EOF
-<html>
-<head>
-  <title><%= values["title"] %></title>
-  <meta http-equiv="Content-Type" content="text/html; charset=<%= values["charset"] %>" />
-  <link rel="stylesheet" href="<%= values["style_url"] %>" type="text/css" media="screen" />
-</head>
-<body class="standalone-code">
-  <pre><%= values["code"] %></pre>
-</body>
-</html>
-  EOF
-
-
-#####################################################################
-### I N D E X   F I L E   T E M P L A T E S
-#####################################################################
-
-  FR_INDEX_BODY = %{
-<%= template_include %>
-}
-
-  FILE_INDEX = XHTML_PREAMBLE + <<-EOF
-<!--
-
-    <%= values["list_title"] %>
-
-  -->
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-  <title><%= values["list_title"] %></title>
-  <meta http-equiv="Content-Type" content="text/html; charset=<%= values["charset"] %>" />
-  <link rel="stylesheet" href="<%= values["style_url"] %>" type="text/css" />
-  <base target="docwin" />
-</head>
-<body>
-<div id="index">
-  <h1 class="section-bar"><%= values["list_title"] %></h1>
-  <div id="index-entries">
-<% values["entries"].each do |entries| %>
-    <a href="<%= entries["href"] %>"><%= entries["name"] %></a><br />
-<% end # values["entries"] %>
-  </div>
-</div>
-</body>
-</html>
-  EOF
-
-  CLASS_INDEX = FILE_INDEX
-  METHOD_INDEX = FILE_INDEX
-
-  INDEX = <<-EOF
-<?xml version="1.0" encoding="<%= values["charset"] %>"?>
-<!DOCTYPE html
-     PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
-     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">
-
-<!--
-
-    <%= values["title"] %>
-
-  -->
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-  <title><%= values["title"] %></title>
-  <meta http-equiv="Content-Type" content="text/html; charset=<%= values["charset"] %>" />
-</head>
-<frameset rows="20%, 80%">
-    <frameset cols="25%,35%,45%">
-        <frame src="fr_file_index.html"   title="Files" name="Files" />
-        <frame src="fr_class_index.html"  name="Classes" />
-        <frame src="fr_method_index.html" name="Methods" />
-    </frameset>
-    <frame src="<%= values["initial_page"] %>" name="docwin" />
-</frameset>
-</html>
-  EOF
-
-end
-
diff --git a/lib/rdoc/generators/html/kilmer.rb b/lib/rdoc/generators/html/kilmer.rb
deleted file mode 100644
index e4c5b115a6..0000000000
--- a/lib/rdoc/generators/html/kilmer.rb
+++ /dev/null
@@ -1,418 +0,0 @@
-require 'rdoc/generators/html'
-
-module RDoc::Generators::HTML::KILMER
-
-  FONTS = "Verdana, Arial, Helvetica, sans-serif"
-
-  STYLE = <<-EOF
-body,td,p { font-family: <%= values["fonts"] %>;
-       color: #000040;
-}
-
-.attr-rw { font-size: xx-small; color: #444488 }
-
-.title-row { background-color: #CCCCFF;
-             color:      #000010;
-}
-
-.big-title-font {
-  color: black;
-  font-weight: bold;
-  font-family: <%= values["fonts"] %>;
-  font-size: large;
-  height: 60px;
-  padding: 10px 3px 10px 3px;
-}
-
-.small-title-font { color: black;
-                    font-family: <%= values["fonts"] %>;
-                    font-size:10; }
-
-.aqua { color: black }
-
-.method-name, .attr-name {
-      font-family: font-family: <%= values["fonts"] %>;
-      font-weight: bold;
-      font-size: small;
-      margin-left: 20px;
-      color: #000033;
-}
-
-.tablesubtitle, .tablesubsubtitle {
-   width: 100%;
-   margin-top: 1ex;
-   margin-bottom: .5ex;
-   padding: 5px 0px 5px 3px;
-   font-size: large;
-   color: black;
-   background-color: #CCCCFF;
-   border: thin;
-}
-
-.name-list {
-  margin-left: 5px;
-  margin-bottom: 2ex;
-  line-height: 105%;
-}
-
-.description {
-  margin-left: 5px;
-  margin-bottom: 2ex;
-  line-height: 105%;
-  font-size: small;
-}
-
-.methodtitle {
-  font-size: small;
-  font-weight: bold;
-  text-decoration: none;
-  color: #000033;
-  background-color: white;
-}
-
-.srclink {
-  font-size: small;
-  font-weight: bold;
-  text-decoration: none;
-  color: #0000DD;
-  background-color: white;
-}
-
-.paramsig {
-   font-size: small;
-}
-
-.srcbut { float: right }
-  EOF
-
-  BODY = <<-EOF
-<html><head>
-  <title><%= values["title"] %></title>
-  <meta http-equiv="Content-Type" content="text/html; charset=<%= values["charset"] %>">
-  <link rel="stylesheet" href="<%= values["style_url"] %>" type="text/css" media="screen" />
-  <script type="text/javascript" language="JavaScript">
-  <!--
-  function popCode(url) {
-    parent.frames.source.location = url
-  }
-  //-->
-  </script>
-</head>
-<body bgcolor="white">
-
-<%= template_include %>  <!-- banner header -->
-
-<% if values["diagram"] then %>
-<table width="100%"><tr><td align="center">
-<%= values["diagram"] %>
-</td></tr></table>
-<% end %>
-
-<% if values["description"] then %>
-<div class="description"><%= values["description"] %></div>
-<% end %>
-
-<% if values["requires"] then %>
-<table cellpadding="5" width="100%">
-<tr><td class="tablesubtitle">Required files</td></tr>
-</table><br />
-<div class="name-list">
-<% values["requires"].each do |requires| %>
-<%= href requires["aref"], requires["name"] %>
-<% end # values["requires"] %>
-<% end %>
-</div>
-
-<% if values["methods"] then %>
-<table cellpadding="5" width="100%">
-<tr><td class="tablesubtitle">Methods</td></tr>
-</table><br />
-<div class="name-list">
-<% values["methods"].each do |methods| %>
-<%= href methods["aref"], methods["name"] %>,
-<% end # values["methods"] %>
-</div>
-<% end %>
-
-
-<% values["sections"].each do |sections| %>
-    <div id="section">
-<% if sections["sectitle"] then %>
-      <h2 class="section-title"><a name="<%= sections["secsequence"] %>"><%= sections["sectitle"] %></a></h2>
-<% if sections["seccomment"] then %>
-      <div class="section-comment">
-        <%= sections["seccomment"] %>
-      </div>
-<% end %>
-<% end %>
-
-<% if sections["attributes"] then %>
-<table cellpadding="5" width="100%">
-<tr><td class="tablesubtitle">Attributes</td></tr>
-</table><br />
-<table cellspacing="5">
-<% sections["attributes"].each do |attributes| %>
-     <tr valign="top">
-<% if attributes["rw"] then %>
-       <td align="center" class="attr-rw">&nbsp;[<%= attributes["rw"] %>]&nbsp;</td>
-<% end %>
-<% unless attributes["rw"] then %>
-       <td></td>
-<% end %>
-       <td class="attr-name"><%= attributes["name"] %></td>
-       <td><%= attributes["a_desc"] %></td>
-     </tr>
-<% end # sections["attributes"] %>
-</table>
-<% end %>
-
-<% if sections["classlist"] then %>
-<table cellpadding="5" width="100%">
-<tr><td class="tablesubtitle">Classes and Modules</td></tr>
-</table><br />
-<%= sections["classlist"] %><br />
-<% end %>
-
-  <%= template_include %>  <!-- method descriptions -->
-
-<% end # values["sections"] %>
-
-</body>
-</html>
-  EOF
-
-  FILE_PAGE = <<-EOF
-<table width="100%">
- <tr class="title-row">
- <td><table width="100%"><tr>
-   <td class="big-title-font" colspan="2"><font size="-3"><b>File</b><br /></font><%= values["short_name"] %></td>
-   <td align="right"><table cellspacing="0" cellpadding="2">
-         <tr>
-           <td  class="small-title-font">Path:</td>
-           <td class="small-title-font"><%= values["full_path"] %>
-<% if values["cvsurl"] then %>
-				&nbsp;(<a href="<%= values["cvsurl"] %>"><acronym title="Concurrent Versioning System">CVS</acronym></a>)
-<% end %>
-           </td>
-         </tr>
-         <tr>
-           <td class="small-title-font">Modified:</td>
-           <td class="small-title-font"><%= values["dtm_modified"] %></td>
-         </tr>
-        </table>
-    </td></tr></table></td>
-  </tr>
-</table><br />
-  EOF
-
-  CLASS_PAGE = <<-EOF
-<table width="100%" border="0" cellspacing="0">
- <tr class="title-row">
- <td class="big-title-font">
-   <font size="-3"><b><%= values["classmod"] %></b><br /></font><%= values["full_name"] %>
- </td>
- <td align="right">
-   <table cellspacing="0" cellpadding="2">
-     <tr valign="top">
-      <td class="small-title-font">In:</td>
-      <td class="small-title-font">
-<% values["infiles"].each do |infiles| %>
-<%= href infiles["full_path_url"], infiles["full_path"] %>
-<% if infiles["cvsurl"] then %>
-&nbsp;(<a href="<%= infiles["cvsurl"] %>"><acronym title="Concurrent Versioning System">CVS</acronym></a>)
-<% end %>
-<% end # values["infiles"] %>
-      </td>
-     </tr>
-<% if values["parent"] then %>
-     <tr>
-      <td class="small-title-font">Parent:</td>
-      <td class="small-title-font">
-<% if values["par_url"] then %>
-        <a href="<%= values["par_url"] %>" class="cyan">
-<% end %>
-<%= values["parent"] %>
-<% if values["par_url"] then %>
-         </a>
-<% end %>
-      </td>
-     </tr>
-<% end %>
-   </table>
-  </td>
-  </tr>
-</table><br />
-  EOF
-
-  METHOD_LIST = <<-EOF
-<% if values["includes"] then %>
-<div class="tablesubsubtitle">Included modules</div><br />
-<div class="name-list">
-<% values["includes"].each do |includes| %>
-    <span class="method-name"><%= href includes["aref"], includes["name"] %></span>
-<% end # values["includes"] %>
-</div>
-<% end %>
-
-<% if values["method_list"] then %>
-<% values["method_list"].each do |method_list| $stderr.puts({ :method_list => method_list }.inspect) %>
-<% if values["methods"] then %>
-<table cellpadding=5 width="100%">
-<tr><td class="tablesubtitle"><%= values["type"] %> <%= values["category"] %> methods</td></tr>
-</table>
-<% values["methods"].each do |methods| $stderr.puts({ :methods => methods }.inspect) %>
-<table width="100%" cellspacing="0" cellpadding="5" border="0">
-<tr><td class="methodtitle">
-<a name="<%= values["aref"] %>">
-<% if values["callseq"] then %>
-<b><%= values["callseq"] %></b>
-<% end %>
-<% unless values["callseq"] then %>
- <b><%= values["name"] %></b><%= values["params"] %>
-<% end %>
-<% if values["codeurl"] then %>
-<a href="<%= values["codeurl"] %>" target="source" class="srclink">src</a>
-<% end %>
-</a></td></tr>
-</table>
-<% if values["m_desc"] then %>
-<div class="description">
-<%= values["m_desc"] %>
-</div>
-<% end %>
-<% if values["aka"] then %>
-<div class="aka">
-This method is also aliased as
-<% values["aka"].each do |aka| $stderr.puts({ :aka => aka }.inspect) %>
-<a href="<%= values["aref"] %>"><%= values["name"] %></a>
-<% end # values["aka"] %>
-</div>
-<% end %>
-<% if values["sourcecode"] then %>
-<pre class="source">
-<%= values["sourcecode"] %>
-</pre>
-<% end %>
-<% end # values["methods"] %>
-<% end %>
-<% end # values["method_list"] %>
-<% end %>
-  EOF
-
-  SRC_PAGE = <<-EOF
-<html>
-<head><title><%= values["title"] %></title>
-<meta http-equiv="Content-Type" content="text/html; charset=<%= values["charset"] %>">
-<style type="text/css">
-.ruby-comment    { color: green; font-style: italic }
-.ruby-constant   { color: #4433aa; font-weight: bold; }
-.ruby-identifier { color: #222222;  }
-.ruby-ivar       { color: #2233dd; }
-.ruby-keyword    { color: #3333FF; font-weight: bold }
-.ruby-node       { color: #777777; }
-.ruby-operator   { color: #111111;  }
-.ruby-regexp     { color: #662222; }
-.ruby-value      { color: #662222; font-style: italic }
-  .kw { color: #3333FF; font-weight: bold }
-  .cmt { color: green; font-style: italic }
-  .str { color: #662222; font-style: italic }
-  .re  { color: #662222; }
-</style>
-</head>
-<body bgcolor="white">
-<pre><%= values["code"] %></pre>
-</body>
-</html>
-  EOF
-
-  FR_INDEX_BODY = %{
-<%= template_include %>
-}
-
-  FILE_INDEX = <<-EOF
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=<%= values["charset"] %>">
-<style>
-<!--
-body {
-  background-color: #ddddff;
-  font-family: #{FONTS};
-  font-size: 11px;
-  font-style: normal;
-  line-height: 14px;
-  color: #000040;
-}
-
-div.banner {
-  background: #0000aa;
-  color: white;
-  padding: 1;
-  margin: 0;
-  font-size: 90%;
-  font-weight: bold;
-  line-height: 1.1;
-  text-align: center;
-  width: 100%;
-}
-
--->
-</style>
-<base target="docwin">
-</head>
-<body>
-<div class="banner"><%= values["list_title"] %></div>
-<% values["entries"].each do |entries| %>
-<a href="<%= entries["href"] %>"><%= entries["name"] %></a><br />
-<% end # values["entries"] %>
-</body></html>
-  EOF
-
-  CLASS_INDEX = FILE_INDEX
-  METHOD_INDEX = FILE_INDEX
-
-  INDEX = <<-EOF
-<html>
-<head>
-  <title><%= values["title"] %></title>
-  <meta http-equiv="Content-Type" content="text/html; charset=<%= values["charset"] %>">
-</head>
-
-<frameset cols="20%,*">
-    <frameset rows="15%,35%,50%">
-        <frame src="fr_file_index.html"   title="Files" name="Files">
-        <frame src="fr_class_index.html"  name="Classes">
-        <frame src="fr_method_index.html" name="Methods">
-    </frameset>
-<% if values["inline_source"] then %>
-      <frame  src="<%= values["initial_page"] %>" name="docwin">
-<% end %>
-<% unless values["inline_source"] then %>
-    <frameset rows="80%,20%">
-      <frame  src="<%= values["initial_page"] %>" name="docwin">
-      <frame  src="blank.html" name="source">
-    </frameset>
-<% end %>
-    <noframes>
-          <body bgcolor="white">
-            Click <a href="html/index.html">here</a> for a non-frames
-            version of this page.
-          </body>
-    </noframes>
-</frameset>
-
-</html>
-  EOF
-
-  # A blank page to use as a target
-  BLANK = %{
-<html><body bgcolor="white"></body></html>
-}
-
-  def write_extra_pages
-    template = TemplatePage.new(BLANK)
-    File.open("blank.html", "w") { |f| template.write_html_on(f, {}) }
-  end
-
-end
-
diff --git a/lib/rdoc/generators/html/one_page_html.rb b/lib/rdoc/generators/html/one_page_html.rb
deleted file mode 100644
index dbac9e2f5a..0000000000
--- a/lib/rdoc/generators/html/one_page_html.rb
+++ /dev/null
@@ -1,121 +0,0 @@
-require 'rdoc/generators/html'
-
-module RDoc::Generators::HTML::ONE_PAGE_HTML
-
-  CONTENTS_XML = <<-EOF
-<% if defined? classes and classes["description"] then %>
-<%= classes["description"] %>
-<% end %>
-
-<% if defined? files and files["requires"] then %>
-<h4>Requires:</h4>
-<ul>
-<% files["requires"].each do |requires| %>
-<% if requires["aref"] then %>
-<li><a href="<%= requires["aref"] %>"><%= requires["name"] %></a></li>
-<% end %>
-<% unless requires["aref"] then %>
-<li><%= requires["name"] %></li>
-<% end %>
-<% end # files["requires"] %>
-</ul>
-<% end %>
-
-<% if defined? classes and classes["includes"] then %>
-<h4>Includes</h4>
-<ul>
-<% classes["includes"].each do |includes| %>
-<% if includes["aref"] then %>
-<li><a href="<%= includes["aref"] %>"><%= includes["name"] %></a></li>
-<% end %>
-<% unless includes["aref"] then %>
-<li><%= includes["name"] %></li>
-<% end %>
-<% end # classes["includes"] %>
-</ul>
-<% end %>
-
-<% if defined? classes and classes["sections"] then %>
-<% classes["sections"].each do |sections| %>
-<% if sections["attributes"] then %>
-<h4>Attributes</h4>
-<table>
-<% sections["attributes"].each do |attributes| %>
-<tr><td><%= attributes["name"] %></td><td><%= attributes["rw"] %></td><td><%= attributes["a_desc"] %></td></tr>
-<% end # sections["attributes"] %>
-</table>
-<% end %>
-
-<% if sections["method_list"] then %>
-<h3>Methods</h3>
-<% sections["method_list"].each do |method_list| %>
-<% if method_list["methods"] then %>
-<% method_list["methods"].each do |methods| %>
-<h4><%= methods["type"] %> <%= methods["category"] %> method: 
-<% if methods["callseq"] then %>
-<a name="<%= methods["aref"] %>"><%= methods["callseq"] %></a>
-<% end %>
-<% unless methods["callseq"] then %>
-<a name="<%= methods["aref"] %>"><%= methods["name"] %><%= methods["params"] %></a></h4>
-<% end %>
-
-<% if methods["m_desc"] then %>
-<%= methods["m_desc"] %>
-<% end %>
-
-<% if methods["sourcecode"] then %>
-<blockquote><pre>
-<%= methods["sourcecode"] %>
-</pre></blockquote>
-<% end %>
-<% end # method_list["methods"] %>
-<% end %>
-<% end # sections["method_list"] %>
-<% end %>
-<% end # classes["sections"] %>
-<% end %>
-  EOF
-
-  ONE_PAGE = %{
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
-  <title><%= values["title"] %></title>
-  <meta http-equiv="Content-Type" content="text/html; charset=<%= values["charset"] %>" />
-</head>
-<body>
-<% values["files"].each do |files| %>
-<h2>File: <%= files["short_name"] %></h2>
-<table>
-  <tr><td>Path:</td><td><%= files["full_path"] %></td></tr>
-  <tr><td>Modified:</td><td><%= files["dtm_modified"] %></td></tr>
-</table>
-} + CONTENTS_XML + %{
-<% end # values["files"] %>
-
-<% if values["classes"] then %>
-<h2>Classes</h2>
-<% values["classes"].each do |classes| %>
-<% if classes["parent"] then %>
-<h3><%= classes["classmod"] %> <%= classes["full_name"] %> &lt; <%= href classes["par_url"], classes["parent"] %></h3>
-<% end %>
-<% unless classes["parent"] then %>
-<h3><%= classes["classmod"] %> <%= classes["full_name"] %></h3>
-<% end %>
-
-<% if classes["infiles"] then %>
-(in files
-<% classes["infiles"].each do |infiles| %>
-<%= href infiles["full_path_url"], infiles["full_path"] %>
-<% end # classes["infiles"] %>
-)
-<% end %>
-} + CONTENTS_XML + %{
-<% end # values["classes"] %>
-<% end %>
-</body>
-</html>
-}
-
-end
-
diff --git a/lib/rdoc/generators/ri.rb b/lib/rdoc/generators/ri.rb
deleted file mode 100644
index a8cacc7501..0000000000
--- a/lib/rdoc/generators/ri.rb
+++ /dev/null
@@ -1,228 +0,0 @@
-require 'rdoc/generators'
-require 'rdoc/markup/simple_markup/to_flow'
-
-require 'rdoc/ri/cache'
-require 'rdoc/ri/reader'
-require 'rdoc/ri/writer'
-require 'rdoc/ri/descriptions'
-
-class RDoc::Generators::RI
-
-  ##
-  # Generators may need to return specific subclasses depending on the
-  # options they are passed. Because of this we create them using a factory
-
-  def self.for(options)
-    new(options)
-  end
-
-  class << self
-    protected :new
-  end
-
-  ##
-  # Set up a new RDoc::Generators::RI.
-
-  def initialize(options) #:not-new:
-    @options   = options
-    @ri_writer = RDoc::RI::Writer.new "."
-    @markup    = SM::SimpleMarkup.new
-    @to_flow   = SM::ToFlow.new
-
-    @generated = {}
-  end
-
-  ##
-  # Build the initial indices and output objects based on an array of
-  # TopLevel objects containing the extracted information.
-
-  def generate(toplevels)
-    RDoc::TopLevel.all_classes_and_modules.each do |cls|
-      process_class(cls)
-    end
-  end
-
-  def process_class(from_class)
-    generate_class_info(from_class)
-
-    # now recure into this classes constituent classess
-    from_class.each_classmodule do |mod|
-      process_class(mod)
-    end
-  end
-
-  def generate_class_info(cls)
-    if cls === RDoc::NormalModule
-      cls_desc = RDoc::RI::ModuleDescription.new
-    else
-      cls_desc = RDoc::RI::ClassDescription.new
-      cls_desc.superclass  = cls.superclass
-    end
-    cls_desc.name        = cls.name
-    cls_desc.full_name   = cls.full_name
-    cls_desc.comment     = markup(cls.comment)
-
-    cls_desc.attributes = cls.attributes.sort.map do |a|
-      RDoc::RI::Attribute.new(a.name, a.rw, markup(a.comment))
-    end
-
-    cls_desc.constants = cls.constants.map do |c|
-      RDoc::RI::Constant.new(c.name, c.value, markup(c.comment))
-    end
-
-    cls_desc.includes = cls.includes.map do |i|
-      RDoc::RI::IncludedModule.new(i.name)
-    end
-
-    class_methods, instance_methods = method_list(cls)
-
-    cls_desc.class_methods = class_methods.map do |m|
-      RDoc::RI::MethodSummary.new(m.name)
-    end
-
-    cls_desc.instance_methods = instance_methods.map do |m|
-      RDoc::RI::MethodSummary.new(m.name)
-    end
-
-    update_or_replace(cls_desc)
-
-    class_methods.each do |m|
-      generate_method_info(cls_desc, m)
-    end
-
-    instance_methods.each do |m|
-      generate_method_info(cls_desc, m)
-    end
-  end
-
-  def generate_method_info(cls_desc, method)
-    meth_desc = RDoc::RI::MethodDescription.new
-    meth_desc.name = method.name
-    meth_desc.full_name = cls_desc.full_name
-    if method.singleton
-      meth_desc.full_name += "::"
-    else
-      meth_desc.full_name += "#"
-    end
-    meth_desc.full_name << method.name
-
-    meth_desc.comment = markup(method.comment)
-    meth_desc.params = params_of(method)
-    meth_desc.visibility = method.visibility.to_s
-    meth_desc.is_singleton = method.singleton
-    meth_desc.block_params = method.block_params
-
-    meth_desc.aliases = method.aliases.map do |a|
-      RDoc::RI::AliasName.new(a.name)
-    end
-
-    @ri_writer.add_method(cls_desc, meth_desc)
-  end
-
-  private
-
-  ##
-  # Returns a list of class and instance methods that we'll be documenting
-
-  def method_list(cls)
-    list = cls.method_list
-    unless @options.show_all
-      list = list.find_all do |m|
-        m.visibility == :public || m.visibility == :protected || m.force_documentation
-      end
-    end
-
-    c = []
-    i = []
-    list.sort.each do |m|
-      if m.singleton
-        c << m
-      else
-        i << m
-      end
-    end
-    return c,i
-  end
-
-  def params_of(method)
-    if method.call_seq
-      method.call_seq
-    else
-      params = method.params || ""
-
-      p = params.gsub(/\s*\#.*/, '')
-      p = p.tr("\n", " ").squeeze(" ")
-      p = "(" + p + ")" unless p[0] == ?(
-
-      if (block = method.block_params)
-        block.gsub!(/\s*\#.*/, '')
-        block = block.tr("\n", " ").squeeze(" ")
-        if block[0] == ?(
-          block.sub!(/^\(/, '').sub!(/\)/, '')
-        end
-        p << " {|#{block.strip}| ...}"
-      end
-      p
-    end
-  end
-
-  def markup(comment)
-    return nil if !comment || comment.empty?
-
-    # Convert leading comment markers to spaces, but only
-    # if all non-blank lines have them
-
-    if comment =~ /^(?>\s*)[^\#]/
-      content = comment
-    else
-      content = comment.gsub(/^\s*(#+)/)  { $1.tr('#',' ') }
-    end
-    @markup.convert(content, @to_flow)
-  end
-
-  ##
-  # By default we replace existing classes with the same name. If the
-  # --merge option was given, we instead merge this definition into an
-  # existing class. We add our methods, aliases, etc to that class, but do
-  # not change the class's description.
-
-  def update_or_replace(cls_desc)
-    old_cls = nil
-
-    if @options.merge
-      rdr = RDoc::RI::Reader.new RDoc::RI::Cache.new(@options.op_dir)
-
-      namespace = rdr.top_level_namespace
-      namespace = rdr.lookup_namespace_in(cls_desc.name, namespace)
-      if namespace.empty?
-        $stderr.puts "You asked me to merge this source into existing "
-        $stderr.puts "documentation. This file references a class or "
-        $stderr.puts "module called #{cls_desc.name} which I don't"
-        $stderr.puts "have existing documentation for."
-        $stderr.puts
-        $stderr.puts "Perhaps you need to generate its documentation first"
-        exit 1
-      else
-        old_cls = namespace[0]
-      end
-    end
-
-    prev_cls = @generated[cls_desc.full_name]
-
-    if old_cls and not prev_cls then
-      old_desc = rdr.get_class old_cls
-      cls_desc.merge_in old_desc
-    end
-
-    if prev_cls then
-      cls_desc.merge_in prev_cls
-    end
-
-    @generated[cls_desc.full_name] = cls_desc
-
-    @ri_writer.remove_class cls_desc
-    @ri_writer.add_class cls_desc
-  end
-
-end
-
diff --git a/lib/rdoc/generators/xml.rb b/lib/rdoc/generators/xml.rb
deleted file mode 100644
index d84cecc05c..0000000000
--- a/lib/rdoc/generators/xml.rb
+++ /dev/null
@@ -1,120 +0,0 @@
-require 'rdoc/generators/html'
-
-##
-# Generate XML output as one big file
-
-class RDoc::Generators::XML < RDoc::Generators::HTML
-
-  ##
-  # Standard generator factory
-
-  def self.for(options)
-    new(options)
-  end
-
-  def initialize(*args)
-    super
-  end
-
-  ##
-  # Build the initial indices and output objects
-  # based on an array of TopLevel objects containing
-  # the extracted information.
-
-  def generate(info)
-    @info       = info
-    @files      = []
-    @classes    = []
-    @hyperlinks = {}
-
-    build_indices
-    generate_xml
-  end
-
-  ##
-  # Generate:
-  #
-  # * a list of HtmlFile objects for each TopLevel object.
-  # * a list of HtmlClass objects for each first level
-  #   class or module in the TopLevel objects
-  # * a complete list of all hyperlinkable terms (file,
-  #   class, module, and method names)
-
-  def build_indices
-    @info.each do |toplevel|
-      @files << RDoc::Generators::HtmlFile.new(toplevel, @options, RDoc::Generators::FILE_DIR)
-    end
-
-    RDoc::TopLevel.all_classes_and_modules.each do |cls|
-      build_class_list(cls, @files[0], RDoc::Generators::CLASS_DIR)
-    end
-  end
-
-  def build_class_list(from, html_file, class_dir)
-    @classes << RDoc::Generators::HtmlClass.new(from, html_file, class_dir, @options)
-    from.each_classmodule do |mod|
-      build_class_list(mod, html_file, class_dir)
-    end
-  end
-
-  ##
-  # Generate all the HTML. For the one-file case, we generate
-  # all the information in to one big hash
-
-  def generate_xml
-    values = {
-      'charset' => @options.charset,
-      'files'   => gen_into(@files),
-      'classes' => gen_into(@classes)
-    }
-
-    # this method is defined in the template file
-    write_extra_pages if defined? write_extra_pages
-
-    template = RDoc::TemplatePage.new @template::ONE_PAGE
-
-    if @options.op_name
-      opfile = File.open(@options.op_name, "w")
-    else
-      opfile = $stdout
-    end
-    template.write_html_on(opfile, values)
-  end
-
-  def gen_into(list)
-    res = []
-    list.each do |item|
-      res << item.value_hash
-    end
-    res
-  end
-
-  def gen_file_index
-    gen_an_index(@files, 'Files')
-  end
-
-  def gen_class_index
-    gen_an_index(@classes, 'Classes')
-  end
-
-  def gen_method_index
-    gen_an_index(RDoc::Generators::HtmlMethod.all_methods, 'Methods')
-  end
-
-  def gen_an_index(collection, title)
-    res = []
-    collection.sort.each do |f|
-      if f.document_self
-        res << { "href" => f.path, "name" => f.index_name }
-      end
-    end
-
-    return {
-      "entries" => res,
-      'list_title' => title,
-      'index_url'  => main_url,
-    }
-  end
-
-end
-
diff --git a/lib/rdoc/generators/xml/rdf.rb b/lib/rdoc/generators/xml/rdf.rb
deleted file mode 100644
index 3f6643e15b..0000000000
--- a/lib/rdoc/generators/xml/rdf.rb
+++ /dev/null
@@ -1,113 +0,0 @@
-require 'rdoc/generators/xml'
-
-module RDoc::Generators::XML::RDF
-
-  CONTENTS_RDF = <<-EOF
-<% if defined? classes and classes["description"] then %>
-    <description rd:parseType="Literal">
-<%= classes["description"] %>
-    </description>
-<% end %>
-
-<% if defined? files and files["requires"] then %>
-<% files["requires"].each do |requires| %>
-         <rd:required-file rd:name="<%= requires["name"] %>" />
-<% end # files["requires"] %>
-<% end %>
-
-<% if defined? classes and classes["includes"] then %>
-      <IncludedModuleList>
-<% classes["includes"].each do |includes| %>
-        <included-module rd:name="<%= includes["name"] %>"  />
-<% end # includes["includes"] %>
-      </IncludedModuleList>
-<% end %>
-
-<% if defined? classes and classes["sections"] then %>
-<% classes["sections"].each do |sections| %>
-<% if sections["attributes"] then %>
-<% sections["attributes"].each do |attributes| %>
-        <contents>
-        <Attribute rd:name="<%= attributes["name"] %>">
-<% if attributes["rw"] then %>
-          <attribute-rw><%= attributes["rw"] %></attribute-rw>
-<% end %>
-          <description rdf:parseType="Literal"><%= attributes["a_desc"] %></description>
-        </Attribute>
-        </contents>
-<% end # sections["attributes"] %>
-<% end %>
-
-<% if sections["method_list"] then %>
-<% sections["method_list"].each do |method_list| %>
-<% if method_list["methods"] then %>
-<% method_list["methods"].each do |methods| %>
-	<contents>
-        <Method rd:name="<%= methods["name"] %>" rd:visibility="<%= methods["type"] %>"
-                rd:category="<%= methods["category"] %>" rd:id="<%= methods["aref"] %>">
-          <parameters><%= methods["params"] %></parameters>
-<% if methods["m_desc"] then %>
-          <description rdf:parseType="Literal">
-<%= methods["m_desc"] %>
-          </description>
-<% end %>
-<% if methods["sourcecode"] then %>
-          <source-code-listing rdf:parseType="Literal">
-<%= methods["sourcecode"] %>
-          </source-code-listing>
-<% end %>
-        </Method>
-       </contents>
-<% end # method_list["methods"] %>
-<% end %>
-<% end # sections["method_list"] %>
-<% end %>
-     <!-- end method list -->
-<% end # classes["sections"] %>
-<% end %>
-  EOF
-
-########################################################################
-
-  ONE_PAGE = %{<?xml version="1.0" encoding="utf-8"?>
-<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-        xmlns="http://pragprog.com/rdoc/rdoc.rdf#"
-        xmlns:rd="http://pragprog.com/rdoc/rdoc.rdf#">
-
-<!-- RDoc -->
-<% values["files"].each do |files| %>
-  <rd:File rd:name="<%= files["short_name"] %>" rd:id="<%= files["href"] %>">
-      <path><%= files["full_path"] %></path>
-      <dtm-modified><%= files["dtm_modified"] %></dtm-modified>
-} + CONTENTS_RDF + %{
-  </rd:File>
-<% end # values["files"] %>
-<% values["classes"].each do |classes| %>
-  <<%= values["classmod"] %> rd:name="<%= classes["full_name"] %>" rd:id="<%= classes["full_name"] %>">
-    <classmod-info>
-<% if classes["infiles"] then %>
-      <InFiles>
-<% classes["infiles"].each do |infiles| %>
-        <infile>
-          <File rd:name="<%= infiles["full_path"] %>"
-<% if infiles["full_path_url"] then %>
-                rdf:about="<%= infiles["full_path_url"] %>"
-<% end %>
-           />
-         </infile>
-<% end # classes["infiles"] %>
-      </InFiles>
-<% end %>
-<% if classes["parent"] then %>
-     <superclass><%= href classes["par_url"], classes["parent"] %></superclass>
-<% end %>
-    </classmod-info>
-} + CONTENTS_RDF + %{
-  </<%= classes["classmod"] %>>
-<% end # values["classes"] %>
-<!-- /RDoc -->
-</rdf:RDF>
-}
-
-end
-
diff --git a/lib/rdoc/generators/xml/xml.rb b/lib/rdoc/generators/xml/xml.rb
deleted file mode 100644
index e711b514fa..0000000000
--- a/lib/rdoc/generators/xml/xml.rb
+++ /dev/null
@@ -1,111 +0,0 @@
-require 'rdoc/generators/xml'
-
-module RDoc::Generators::XML::XML
-
-  CONTENTS_XML = <<-EOF
-<% if defined? classes and classes["description"] then %>
-    <description>
-<%= classes["description"] %>
-    </description>
-<% end %>
-    <contents>
-<% if defined? files and files["requires"] then %>
-      <required-file-list>
-<% files["requires"].each do |requires| %>
-         <required-file name="<%= requires["name"] %>"
-<% if requires["aref"] then %>
-                        href="<%= requires["aref"] %>"
-<% end %>
-         />
-<% end # files["requires"] %>
-      </required-file-list>
-<% end %>
-<% if defined? classes and classes["sections"] then %>
-<% classes["sections"].each do |sections| %>
-<% if sections["attributes"] then %>
-      <attribute-list>
-<% sections["attributes"].each do |attributes| %>
-        <attribute name="<%= attributes["name"] %>">
-<% if attributes["rw"] then %>
-          <attribute-rw><%= attributes["rw"] %></attribute-rw>
-<% end %>
-          <description><%= attributes["a_desc"] %></description>
-        </attribute>
-<% end # sections["attributes"] %>
-      </attribute-list>
-<% end %>
-<% if sections["method_list"] then %>
-      <method-list>
-<% sections["method_list"].each do |method_list| %>
-<% if method_list["methods"] then %>
-<% method_list["methods"].each do |methods| %>
-        <method name="<%= methods["name"] %>" type="<%= methods["type"] %>" category="<%= methods["category"] %>" id="<%= methods["aref"] %>">
-          <parameters><%= methods["params"] %></parameters>
-<% if methods["m_desc"] then %>
-          <description>
-<%= methods["m_desc"] %>
-          </description>
-<% end %>
-<% if methods["sourcecode"] then %>
-          <source-code-listing>
-<%= methods["sourcecode"] %>
-          </source-code-listing>
-<% end %>
-        </method>
-<% end # method_list["methods"] %>
-<% end %>
-<% end # sections["method_list"] %>
-      </method-list>
-<% end %>
-<% end # classes["sections"] %>
-<% end %>
-<% if defined? classes and classes["includes"] then %>
-      <included-module-list>
-<% classes["includes"].each do |includes| %>
-        <included-module name="<%= includes["name"] %>"
-<% if includes["aref"] then %>
-                         href="<%= includes["aref"] %>"
-<% end %>
-        />
-<% end # classes["includes"] %>
-      </included-module-list>
-<% end %>
-    </contents>
-  EOF
-
-  ONE_PAGE = %{<?xml version="1.0" encoding="utf-8"?>
-<rdoc>
-<file-list>
-<% values["files"].each do |files| %>
-  <file name="<%= files["short_name"] %>" id="<%= files["href"] %>">
-    <file-info>
-      <path><%= files["full_path"] %></path>
-      <dtm-modified><%= files["dtm_modified"] %></dtm-modified>
-    </file-info>
-} + CONTENTS_XML + %{
-  </file>
-<% end # values["files"] %>
-</file-list>
-<class-module-list>
-<% values["classes"].each do |classes| %>
-  <<%= classes["classmod"] %> name="<%= classes["full_name"] %>" id="<%= classes["full_name"] %>">
-    <classmod-info>
-<% if classes["infiles"] then %>
-      <infiles>
-<% classes["infiles"].each do |infiles|  %>
-        <infile><%= href infiles["full_path_url"], infiles["full_path"] %></infile>
-<% end # classes["infiles"] %>
-      </infiles>
-<% end %>
-<% if classes["parent"] then %>
-     <superclass><%= href classes["par_url"], classes["parent"] %></superclass>
-<% end %>
-    </classmod-info>
-} + CONTENTS_XML + %{
-  </<%= classes["classmod"] %>>
-<% end # values["classes"] %>
-</class-module-list>
-</rdoc>
-}
-
-end