Parent

Generators::ContextUser

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


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

Attributes

context[R]

Public Class Methods

new(context, options) click to toggle source
# File lib/generators/templates/application/merb_stack/doc/rdoc/generators/merb_generator.rb, line 270
def initialize(context, options)
    @context = context
    @options = options

end

Public Instance Methods

add_table_of_sections() click to toggle source

create table of contents if we contain sections

# File lib/generators/templates/application/merb_stack/doc/rdoc/generators/merb_generator.rb, line 522
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
build_alias_summary_list(section) click to toggle source

Build a list of aliases for which we couldn’t find a corresponding method

# File lib/generators/templates/application/merb_stack/doc/rdoc/generators/merb_generator.rb, line 312
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_class_list(level, from, section, infile=nil) click to toggle source

Build the structured list of classes and modules contained in this context.

# File lib/generators/templates/application/merb_stack/doc/rdoc/generators/merb_generator.rb, line 466
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
build_constants_summary_list(section) click to toggle source

Build a list of constants

# File lib/generators/templates/application/merb_stack/doc/rdoc/generators/merb_generator.rb, line 329
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
build_include_list(context) click to toggle source
# File lib/generators/templates/application/merb_stack/doc/rdoc/generators/merb_generator.rb, line 347
def build_include_list(context)
    potentially_referenced_list(context.includes)
end
build_method_detail_list(section) click to toggle source

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

# File lib/generators/templates/application/merb_stack/doc/rdoc/generators/merb_generator.rb, line 398
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_method_summary_list(path_prefix="") click to toggle source

Build a summary list of all the methods in this context

# File lib/generators/templates/application/merb_stack/doc/rdoc/generators/merb_generator.rb, line 295
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_requires_list(context) click to toggle source
# File lib/generators/templates/application/merb_stack/doc/rdoc/generators/merb_generator.rb, line 343
def build_requires_list(context)
    potentially_referenced_list(context.requires) {|fn| [fn + ".rb"] }
end
collect_methods() click to toggle source

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 --all option, we include all methods, otherwise just the public ones.

# File lib/generators/templates/application/merb_stack/doc/rdoc/generators/merb_generator.rb, line 286
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
diagram_reference(diagram) click to toggle source
# File lib/generators/templates/application/merb_stack/doc/rdoc/generators/merb_generator.rb, line 503
def diagram_reference(diagram)
    res = diagram.gsub(/((?:src|href)=")(.*?)"/) {
        $1 + $2 + '"'
    }
    res
end
document_self() click to toggle source
# File lib/generators/templates/application/merb_stack/doc/rdoc/generators/merb_generator.rb, line 499
def document_self
    @context.document_self
end
find_symbol(symbol, method=nil) click to toggle source

Find a symbol in ourselves or our parent

# File lib/generators/templates/application/merb_stack/doc/rdoc/generators/merb_generator.rb, line 512
def find_symbol(symbol, method=nil)
    res = @context.find_symbol(symbol, method)
    if res
        res = res.viewer
    end
    res
end
href(link, cls, name) click to toggle source

convenience method to build a hyperlink # Where’s the DRY in this?? Put this in the template where it belongs

# File lib/generators/templates/application/merb_stack/doc/rdoc/generators/merb_generator.rb, line 277
def href(link, cls, name)
  %{"<a href=\"#\" onclick=\"jsHref('#{link}');\" class=\"#{cls}\">#{name}</a>"}
end
potentially_referenced_list(array) click to toggle source

Build a list from an array of Htmlxxx 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

# File lib/generators/templates/application/merb_stack/doc/rdoc/generators/merb_generator.rb, line 360
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

[Validate]

Generated with the Darkfish Rdoc Generator 2.