rango 0.1.pre → 0.1.0

data/benchmarks/stubs/merb-core/config/environments/development.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-
-Merb.logger.info("Loaded DEVELOPMENT Environment...")
-Merb::Config.use { |c|
-  c[:exception_details] = true
-  c[:reload_templates] = true
-  c[:reload_classes] = true
-  c[:reload_time] = 0.5
-  c[:ignore_tampered_cookies] = true
-  c[:log_auto_flush ] = true
-  c[:log_level] = :debug
-
-  c[:log_stream] = STDOUT
-  c[:log_file]   = nil
-  # Or redirect logging into a file:
-  # c[:log_file]  = Merb.root / "log" / "development.log"
-}

data/benchmarks/stubs/merb-core/config/environments/production.rb

@@ -1,12 +0,0 @@
-# encoding: utf-8
-
-Merb.logger.info("Loaded PRODUCTION Environment...")
-Merb::Config.use { |c|
-  c[:exception_details] = false
-  c[:reload_classes] = false
-  c[:log_level] = :error
-
-  c[:log_file]  = Merb.root / "log" / "production.log"
-  # or redirect logger using IO handle
-  # c[:log_stream] = STDOUT
-}

data/benchmarks/stubs/merb-core/config/environments/rake.rb

@@ -1,13 +0,0 @@
-# encoding: utf-8
-
-Merb.logger.info("Loaded RAKE Environment...")
-Merb::Config.use { |c|
-  c[:exception_details] = true
-  c[:reload_classes]  = false
-  c[:log_auto_flush ] = true
-
-  c[:log_stream] = STDOUT
-  c[:log_file]   = nil
-  # Or redirect logging into a file:
-  # c[:log_file]  = Merb.root / "log" / "development.log"
-}

data/benchmarks/stubs/merb-core/config/environments/staging.rb

@@ -1,12 +0,0 @@
-# encoding: utf-8
-
-Merb.logger.info("Loaded STAGING Environment...")
-Merb::Config.use { |c|
-  c[:exception_details] = false
-  c[:reload_classes]    = false
-  c[:log_level]         = :error
-
-  c[:log_file]  = Merb.root / "log" / "staging.log"
-  # or redirect logger using IO handle
-  # c[:log_stream] = STDOUT
-}

data/benchmarks/stubs/merb-core/config/environments/test.rb

@@ -1,14 +0,0 @@
-# encoding: utf-8
-
-Merb.logger.info("Loaded TEST Environment...")
-Merb::Config.use { |c|
-  c[:testing]           = true
-  c[:exception_details] = true
-  c[:log_auto_flush ]   = true
-  # log less in testing environment
-  c[:log_level]         = :error
-
-  #c[:log_file]  = Merb.root / "log" / "test.log"
-  # or redirect logger using IO handle
-  c[:log_stream] = STDOUT
-}

data/benchmarks/stubs/merb-core/config/init.rb

@@ -1,27 +0,0 @@
-# encoding: utf-8
-
-# Go to http://wiki.merbivore.com/pages/init-rb
-
-# Specify a specific version of a dependency
-# dependency "RedCloth", "> 3.0"
-
-#  use_orm :none
-use_test :rspec
-use_template_engine :erb
-
-Merb::Config.use do |c|
-  c[:use_mutex] = false
-  c[:session_store] = 'cookie'  # can also be 'memory', 'memcache', 'container', 'datamapper
-
-  # cookie session store configuration
-  c[:session_secret_key]  = 'a33c4ed5bb32371b37e81a07bd943b2b933d4a00'  # required for cookie session store
-  c[:session_id_key] = '_merb-core_session_id' # cookie session id key, defaults to "_session_id"
-end
-
-Merb::BootLoader.before_app_loads do
-  # This will get executed after dependencies have been loaded but before your app's classes have loaded.
-end
-
-Merb::BootLoader.after_app_loads do
-  # This will get executed after your app's classes have been loaded.
-end

data/benchmarks/stubs/merb-core/config/rack.rb

@@ -1,13 +0,0 @@
-# encoding: utf-8
-
-# use PathPrefix Middleware if :path_prefix is set in Merb::Config
-if prefix = ::Merb::Config[:path_prefix]
-  use Merb::Rack::PathPrefix, prefix
-end
-
-# comment this out if you are running merb behind a load balancer
-# that serves static files
-use Merb::Rack::Static, Merb.dir_for(:public)
-
-# this is our main merb application
-run Merb::Rack::Application.new

data/benchmarks/stubs/merb-core/config/router.rb

@@ -1,43 +0,0 @@
-# encoding: utf-8
-
-# Merb::Router is the request routing mapper for the merb framework.
-#
-# You can route a specific URL to a controller / action pair:
-#
-#   match("/contact").
-#     to(:controller => "info", :action => "contact")
-#
-# You can define placeholder parts of the url with the :symbol notation. These
-# placeholders will be available in the params hash of your controllers. For example:
-#
-#   match("/books/:book_id/:action").
-#     to(:controller => "books")
-#
-# Or, use placeholders in the "to" results for more complicated routing, e.g.:
-#
-#   match("/admin/:module/:controller/:action/:id").
-#     to(:controller => ":module/:controller")
-#
-# You can specify conditions on the placeholder by passing a hash as the second
-# argument of "match"
-#
-#   match("/registration/:course_name", :course_name => /^[a-z]{3,5}-\d{5}$/).
-#     to(:controller => "registration")
-#
-# You can also use regular expressions, deferred routes, and many other options.
-# See merb/specs/merb/router.rb for a fairly complete usage sample.
-
-Merb.logger.info("Compiling routes...")
-Merb::Router.prepare do
-  # RESTful routes
-  # resources :posts
-
-  # This is the default route for /:controller/:action/:id
-  # This is fine for most cases.  If you're heavily using resource-based
-  # routes, you may want to comment/remove this line to prevent
-  # clients from calling your create or destroy actions with a GET
-  default_routes
-
-  # Change this for your home page to be available at /
-  # match('/').to(:controller => 'whatever', :action =>'index')
-end

data/benchmarks/stubs/merb-core/doc/rdoc/generators/merb_generator.rb

@@ -1,1364 +0,0 @@
-# encoding: utf-8
-
-
-# # 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.
-#
-# 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.
-#
-
-require 'ftools'
-
-require 'rdoc/options'
-require 'rdoc/template'
-require 'rdoc/markup/simple_markup'
-require 'rdoc/markup/simple_markup/to_html'
-require 'cgi'
-
-module Generators
-
-    # Name of sub-direcories that hold file and class/module descriptions
-
-    FILE_DIR  = "files"
-    CLASS_DIR = "classes"
-    CSS_NAME  = "stylesheet.css"
-
-
-    ##
-    # 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)
-            super()
-            @from_path = from_path
-
-            @parent_name = context.parent_name
-            @parent_name += "::" if @parent_name
-            @context = context
-        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.instance.show_hash
-            else
-                lookup = name
-            end
-
-            if /([A-Z].*)[.\#](.*)/ =~ 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=\"index.html?a=#{ref.aref}&name=#{name}\">#{name}</a>"
-            else
-                name #it does not need to be a link
-            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"
-                url = path
-            end
-
-            if (type == "http" || type == "link") && url =~ /\.(gif|png|jpg|jpeg|bmp)$/
-                "<img src=\"#{url}\">"
-            elsif (type == "http" || type == "link")
-                "<a href=\"#{url}\" target=\"_blank\">#{text}</a>"
-            else
-                "<a href=\"#\" onclick=\"jsHref('#{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, file names, or instance variables
-                @markup.add_special(/(
-                \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)
-            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
-
-
-        def style_url(path, css_name=nil)
-            css_name ||= CSS_NAME
-        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
-
-        end
-
-        # convenience method to build a hyperlink # Where's the DRY in this?? Put this in the template where it belongs
-       def href(link, cls, name)
-         %{"<a href=\"#\" onclick=\"jsHref('#{link}');\" class=\"#{cls}\">#{name}</a>"}
-       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" => meth.aref,
-                    "href" => meth.path
-                }
-            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 = ref.path
-                    res << { "name" => h_name, "href" => path }
-                else
-                    res << { "name" => h_name, "href" => "" }
-                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["href"]        = m.path
-                            row["m_seq"]       = m.seq
-                            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,
-                                        'href' => other.viewer.path,
-                                        'aref'  => other.viewer.aref
-                                    }
-                                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(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(cls.viewer.path, "link", cls.full_name) <<
-                    "<br />\n" <<
-                    build_class_list(level + 1, cls, section, infile)
-                end
-            end
-
-            res
-        end
-
-        def document_self
-            @context.document_self
-        end
-
-        def diagram_reference(diagram)
-            res = diagram.gsub(/((?:src|href)=")(.*?)"/) {
-                $1 + $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
-
-        @@c_seq = "C00000000"
-
-        attr_reader :path
-
-        def initialize(context, html_file, prefix, options)
-            super(context, options)
-            @@c_seq  = @@c_seq.succ
-            @c_seq   = @@c_seq
-            @html_file = html_file
-            @is_module = context.is_module?
-            @values    = {}
-
-            context.viewer = self
-
-            @path = http_url(context.full_name, prefix)
-
-            collect_methods
-
-            AllReferences.add(name, self)
-        end
-
-        # return 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 seq
-            @c_seq
-        end
-
-        def aref
-            @c_seq
-        end
-
-        def scope
-            a = @context.full_name.split("::")
-            if a.length > 1
-                a.pop
-                a.join("::")
-            else
-                ""
-            end
-        end
-
-        def name
-            @context.full_name.gsub("#{scope}::", '')
-        end
-
-        def full_name
-            @context.full_name
-        end
-
-        def parent_name
-            @context.parent.full_name
-        end
-
-        def write_on(f)
-            value_hash
-            template = TemplatePage.new(RDoc::Page::BODY,
-            RDoc::Page::CLASS_PAGE,
-            RDoc::Page::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)
-
-            # Convert README to html
-            unless File.exist?('files/README.html')
-              File.open('files/README.html', 'w') do |file|
-                file << markup(File.read(File.expand_path(@options.main_page)))
-              end
-            end
-
-            d = markup(@context.comment)
-            @values["description"] = d unless d.empty?
-
-            ml = build_method_summary_list
-            @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["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
-            @values["class_seq"] = seq
-            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"] = 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"] = 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
-
-        @@f_seq = "F00000000"
-
-        attr_reader :path
-        attr_reader :name
-
-        def initialize(context, options, file_dir)
-            super(context, options)
-            @@f_seq  = @@f_seq.succ
-            @f_seq   = @@f_seq
-            @values = {}
-
-            @path = http_url(file_dir)
-            @source_file_path = File.expand_path(@context.file_relative_name).gsub("\/doc\/", "/")
-            @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(/%|\/|\?|\#/) {|s| '%' + ("%x" % s[0]) }
-        end
-
-        def seq
-            @f_seq
-        end
-
-        def aref
-            @f_seq
-        end
-
-        def name
-            full_path = @context.file_absolute_name
-            short_name = File.basename(full_path)
-        end
-
-        def full_name
-            @context.file_absolute_name
-        end
-
-        def scope
-            @context.file_relative_name.gsub(/\/#{name}$/, '')
-        end
-
-        def parent_name
-            nil
-        end
-
-        def full_file_source
-            ret_str = ""
-            File.open(@source_file_path, 'r') do |f|
-                while(!f.eof?) do
-                    ret_str += f.readline()
-                end
-            end
-            ret_str
-        rescue
-            "file not found -#{@source_file_path}-"
-            #@source_file_path
-        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)
-            @values["file_seq"] =  seq
-
-            #pulling in the source for this file
-            #@values["source_code"] = @context.token_stream
-
-            @values["file_source_code"] = CGI.escapeHTML(full_file_source)
-
-            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?
-
-
-            file_context = @context
-
-            @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 = TemplatePage.new(RDoc::Page::SRC_BODY,RDoc::Page::FILE_PAGE, RDoc::Page::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
-
-        @@m_seq = "M000000"
-
-        @@all_methods = []
-
-        def HtmlMethod::reset
-            @@all_methods = []
-        end
-
-        def initialize(context, html_class, options)
-            @context    = context
-            @html_class = html_class
-            @options    = options
-            @@m_seq       = @@m_seq.succ
-            @m_seq        = @@m_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 = MERBGenerator.gen_url(path, 'source.png')
-                #end
-            end
-            AllReferences.add(name, self)
-        end
-
-        def seq
-            @m_seq
-        end
-
-        def aref
-            @m_seq
-        end
-
-        def scope
-            @html_class.full_name
-        end
-
-        # return 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 name
-            @context.name
-        end
-
-        def section
-            @context.section
-        end
-
-        def parent_name
-            if @context.parent.parent
-                @context.parent.parent.full_name
-            else
-                nil
-            end
-        end
-
-        def path
-            @html_class.path
-        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
-            p = @context.params
-            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')
-            File.makedirs(meth_path)
-            file_path = File.join(meth_path, seq) + ".html"
-
-            template = TemplatePage.new(RDoc::Page::SRC_PAGE)
-            File.open(file_path, "w") do |f|
-                values = {
-                    'title'     => CGI.escapeHTML(name),
-                    'code'      => code_body,
-                    'style_url' => style_url(file_path, @options.css),
-                    'charset'   => @options.charset
-                }
-                template.write_html_on(f, values)
-            end
-            file_path
-        end
-
-        def HtmlMethod.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)
-            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
-
-    #####################################################################
-
-    class MERBGenerator
-
-        include MarkUp
-
-        # Generators may need to return specific subclasses depending
-        # on the options they are passed. Because of this
-        # we create them using a factory
-
-        def MERBGenerator.for(options)
-            AllReferences::reset
-            HtmlMethod::reset
-
-            MERBGenerator.new(options)
-
-        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
-            write_javascript
-            gen_sub_directories()
-            build_indices
-            generate_html
-        end
-
-        private
-
-        ##
-        # Load up the AJAX 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{/|\\}
-                template = File.join("rdoc/generators/template", @options.generator.key, template)
-            end
-            require template
-            extend RDoc::Page
-        rescue LoadError
-            $stderr.puts "Could not find AJAX template '#{template}'"
-            exit 99
-        end
-
-        ##
-        # Write out the style sheet used by the main frames
-        #
-
-        def write_style_sheet
-            template = TemplatePage.new(RDoc::Page::STYLE)
-            File.open(CSS_NAME, "w") do |f|
-                values = { "font" => "helvetica"} #this is not used anywhere but the template function demands a hash of values
-                template.write_html_on(f, values)
-            end
-        end
-
-        def write_javascript
-            #Argh... I couldn't figure out how to copy these from the template dir so they were copied into
-            # the template file "ajax.rb" and processed similarlly to the style sheets. Not exactly a good thing to do with
-            # external library code. Not very DRY.
-
-            File.open("api_grease.js", "w") do |f|
-                f << RDoc::Page::API_GREASE_JS
-            end
-
-            File.open("prototype.js", "w") do |f|
-                f << RDoc::Page::PROTOTYPE_JS
-            end
-
-        rescue LoadError
-            $stderr.puts "Could not find AJAX template"
-            exit 99
-        end
-
-        ##
-        # See the comments at the top for a description of the
-        # directory structure
-
-        def gen_sub_directories
-            File.makedirs(FILE_DIR, 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
-                    File.makedirs(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',
-            RDoc::Page::FILE_INDEX,
-            "fr_file_index.html")
-        end
-
-        def gen_class_index
-            gen_an_index(@classes, 'Classes',
-            RDoc::Page::CLASS_INDEX,
-            "fr_class_index.html")
-        end
-
-        def gen_method_index
-            gen_an_index(HtmlMethod.all_methods, 'Methods',
-            RDoc::Page::METHOD_INDEX,
-            "fr_method_index.html")
-        end
-
-
-        def gen_an_index(collection, title, template, filename)
-            template = TemplatePage.new(RDoc::Page::FR_INDEX_BODY, template)
-            res = []
-            collection.sort.each do |f|
-                if f.document_self
-                    res << { "href" => f.path, "name" => f.name, "scope" => f.scope, "seq_id" => f.seq }
-                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 = TemplatePage.new(RDoc::Page::INDEX)
-            File.open("index.html", "w") do |f|
-                tStr = ""
-                #File.open(main_url, 'r') do |g|
-                #    tStr = markup(g)
-                #end
-                values = {
-                    "initial_page" => tStr,
-                    'title'        => CGI.escapeHTML(@options.title),
-                    'charset'      => @options.charset,
-                    'content'      => File.read('files/README.html')
-                }
-
-                values['inline_source'] = true
-                template.write_html_on(f, values)
-            end
-        end
-
-        # return the url of the main page
-        def main_url
-            "files/README.html"
-        end
-
-
-    end
-
-end