puppet 0.25.5 → 2.6.0

data/lib/puppet/util/rdoc/generators/puppet_generator.rb

@@ -4,828 +4,884 @@ require 'digest/md5'
 
 module Generators
 
-    # This module holds all the classes needed to generate the HTML documentation
-    # of a bunch of puppet manifests.
-    #
-    # It works by traversing all the code objects defined by the Puppet RDoc::Parser
-    # and produces HTML counterparts objects that in turns are used by RDoc template engine
-    # to produce the final HTML.
-    #
-    # It is also responsible of creating the whole directory hierarchy, and various index
-    # files.
-    #
-    # It is to be noted that the whole system is built on top of ruby RDoc. As such there
-    # is an implicit mapping of puppet entities to ruby entitites:
-    #
-    #         Puppet    =>    Ruby
-    #         ------------------------
-    #         Module          Module
-    #         Class           Class
-    #         Definition      Method
-    #         Resource
-    #         Node
-    #         Plugin
-    #         Fact
-
-    MODULE_DIR = "modules"
-    NODE_DIR = "nodes"
-    PLUGIN_DIR = "plugins"
-
-    # This is a specialized HTMLGenerator tailored to Puppet manifests
-    class PuppetGenerator < HTMLGenerator
-
-        def PuppetGenerator.for(options)
-            AllReferences::reset
-            HtmlMethod::reset
-
-            if options.all_one_file
-                PuppetGeneratorInOne.new(options)
-            else
-                PuppetGenerator.new(options)
-            end
-        end
+  # This module holds all the classes needed to generate the HTML documentation
+  # of a bunch of puppet manifests.
+  #
+  # It works by traversing all the code objects defined by the Puppet RDoc::Parser
+  # and produces HTML counterparts objects that in turns are used by RDoc template engine
+  # to produce the final HTML.
+  #
+  # It is also responsible of creating the whole directory hierarchy, and various index
+  # files.
+  #
+  # It is to be noted that the whole system is built on top of ruby RDoc. As such there
+  # is an implicit mapping of puppet entities to ruby entitites:
+  #
+  #         Puppet    =>    Ruby
+  #         ------------------------
+  #         Module          Module
+  #         Class           Class
+  #         Definition      Method
+  #         Resource
+  #         Node
+  #         Plugin
+  #         Fact
+
+  MODULE_DIR = "modules"
+  NODE_DIR = "nodes"
+  PLUGIN_DIR = "plugins"
+
+  # This is a specialized HTMLGenerator tailored to Puppet manifests
+  class PuppetGenerator < HTMLGenerator
+
+    def PuppetGenerator.for(options)
+      AllReferences::reset
+      HtmlMethod::reset
+
+      if options.all_one_file
+        PuppetGeneratorInOne.new(options)
+      else
+        PuppetGenerator.new(options)
+      end
+    end
 
-        def initialize(options) #:not-new:
-            @options    = options
-            load_html_template
-        end
+    def initialize(options) #:not-new:
+      @options    = options
+      load_html_template
+    end
 
-        # loads our own html template file
-        def load_html_template
-            begin
-                require 'puppet/util/rdoc/generators/template/puppet/puppet'
-                extend RDoc::Page
-            rescue LoadError
-                $stderr.puts "Could not find Puppet template '#{template}'"
-                exit 99
-            end
-        end
+    # loads our own html template file
+    def load_html_template
+        require 'puppet/util/rdoc/generators/template/puppet/puppet'
+        extend RDoc::Page
+    rescue LoadError
+        $stderr.puts "Could not find Puppet template '#{template}'"
+        exit 99
+    end
 
-        def gen_method_index
-            # we don't generate an all define index
-            # as the presentation is per module/per class
-        end
+    def gen_method_index
+      # we don't generate an all define index
+      # as the presentation is per module/per class
+    end
 
-        # This is the central method, it generates the whole structures
-        # along with all the indices.
-        def generate_html
-            super
-            gen_into(@nodes)
-            gen_into(@plugins)
-        end
+    # This is the central method, it generates the whole structures
+    # along with all the indices.
+    def generate_html
+      super
+      gen_into(@nodes)
+      gen_into(@plugins)
+    end
 
-        ##
-        # Generate:
-        #  the list of modules
-        #  the list of classes and definitions of a specific module
-        #  the list of all classes
-        #  the list of nodes
-        #  the list of resources
-        def build_indices
-            @allfiles = []
-            @nodes = []
-            @plugins = []
-
-            # contains all the seen modules
-            @modules = {}
-            @allclasses = {}
-
-            # build the modules, classes and per modules classes and define list
-            @toplevels.each do |toplevel|
-                next unless toplevel.document_self
-                file = HtmlFile.new(toplevel, @options, FILE_DIR)
-                classes = []
-                methods = []
-                modules = []
-                nodes = []
-
-                # find all classes of this toplevel
-                # store modules if we find one
-                toplevel.each_classmodule do |k|
-                    generate_class_list(classes, modules, k, toplevel, CLASS_DIR)
-                end
-
-                # find all defines belonging to this toplevel
-                HtmlMethod.all_methods.each do |m|
-                    # find parent module, check this method is not already
-                    # defined.
-                    if m.context.parent.toplevel === toplevel
-                        methods << m
-                    end
-                end
-
-                classes.each do |k|
-                    @allclasses[k.index_name] = k if !@allclasses.has_key?(k.index_name)
-                end
-
-                # generate nodes and plugins found
-                classes.each do |k|
-                    if k.context.is_module?
-                        k.context.each_node do |name,node|
-                            nodes << HTMLPuppetNode.new(node, toplevel, NODE_DIR, @options)
-                            @nodes << nodes.last
-                        end
-                        k.context.each_plugin do |plugin|
-                            @plugins << HTMLPuppetPlugin.new(plugin, toplevel, PLUGIN_DIR, @options)
-                        end
-                        k.context.each_fact do |fact|
-                            @plugins << HTMLPuppetPlugin.new(fact, toplevel, PLUGIN_DIR, @options)
-                        end
-                    end
-                end
-
-                @files << file
-                @allfiles << { "file" => file, "modules" => modules, "classes" => classes, "methods" => methods, "nodes" => nodes }
-            end
+    ##
+    # Generate:
+    #  the list of modules
+    #  the list of classes and definitions of a specific module
+    #  the list of all classes
+    #  the list of nodes
+    #  the list of resources
+    def build_indices
+      @allfiles = []
+      @nodes = []
+      @plugins = []
 
-            @classes = @allclasses.values
-        end
+      # contains all the seen modules
+      @modules = {}
+      @allclasses = {}
 
-        # produce a class/module list of HTMLPuppetModule/HTMLPuppetClass
-        # based on the code object traversal.
-        def generate_class_list(classes, modules, from, html_file, class_dir)
-            if from.is_module? and !@modules.has_key?(from.name)
-                k = HTMLPuppetModule.new(from, html_file, class_dir, @options)
-                classes << k
-                @modules[from.name] = k
-                modules << @modules[from.name]
-            elsif from.is_module?
-                modules << @modules[from.name]
-            elsif !from.is_module?
-                k = HTMLPuppetClass.new(from, html_file, class_dir, @options)
-                classes << k
-            end
-            from.each_classmodule do |mod|
-                generate_class_list(classes, modules, mod, html_file, class_dir)
-            end
+      # build the modules, classes and per modules classes and define list
+      @toplevels.each do |toplevel|
+        next unless toplevel.document_self
+        file = HtmlFile.new(toplevel, @options, FILE_DIR)
+        classes = []
+        methods = []
+        modules = []
+        nodes = []
+
+        # find all classes of this toplevel
+        # store modules if we find one
+        toplevel.each_classmodule do |k|
+          generate_class_list(classes, modules, k, toplevel, CLASS_DIR)
         end
 
-        # generate all the subdirectories, modules, classes and files
-        def gen_sub_directories
-            begin
-                super
-                File.makedirs(MODULE_DIR)
-                File.makedirs(NODE_DIR)
-                File.makedirs(PLUGIN_DIR)
-            rescue
-                $stderr.puts $!.message
-                exit 1
-            end
+        # find all defines belonging to this toplevel
+        HtmlMethod.all_methods.each do |m|
+          # find parent module, check this method is not already
+          # defined.
+          if m.context.parent.toplevel === toplevel
+            methods << m
+          end
         end
 
-        # generate the index of modules
-        def gen_file_index
-            gen_top_index(@modules.values, 'All Modules', RDoc::Page::TOP_INDEX, "fr_modules_index.html")
+        classes.each do |k|
+          @allclasses[k.index_name] = k if !@allclasses.has_key?(k.index_name)
         end
 
-        # generate a top index
-        def gen_top_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 << { "classlist" => CGI.escapeHTML("#{MODULE_DIR}/fr_#{f.index_name}.html"), "module" => CGI.escapeHTML("#{CLASS_DIR}/#{f.index_name}.html"),"name" => CGI.escapeHTML(f.index_name) }
-                end
+        # generate nodes and plugins found
+        classes.each do |k|
+          if k.context.is_module?
+            k.context.each_node do |name,node|
+              nodes << HTMLPuppetNode.new(node, toplevel, NODE_DIR, @options)
+              @nodes << nodes.last
             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)
+            k.context.each_plugin do |plugin|
+              @plugins << HTMLPuppetPlugin.new(plugin, toplevel, PLUGIN_DIR, @options)
             end
-        end
-
-        # generate the all classes index file and the combo index
-        def gen_class_index
-            gen_an_index(@classes, 'All Classes', RDoc::Page::CLASS_INDEX, "fr_class_index.html")
-            @allfiles.each do |file|
-                unless file['file'].context.file_relative_name =~ /\.rb$/
-                    gen_composite_index(file,
-                                        RDoc::Page::COMBO_INDEX,
-                                        "#{MODULE_DIR}/fr_#{file["file"].context.module_name}.html")
-                end
+            k.context.each_fact do |fact|
+              @plugins << HTMLPuppetPlugin.new(fact, toplevel, PLUGIN_DIR, @options)
             end
+          end
         end
 
-        def gen_composite_index(collection, template, filename)\
-            return if FileTest.exists?(filename)
-
-            template = TemplatePage.new(RDoc::Page::FR_INDEX_BODY, template)
-            res1 = []
-            collection['classes'].sort.each do |f|
-                if f.document_self
-                    unless f.context.is_module?
-                        res1 << { "href" => "../"+CGI.escapeHTML(f.path), "name" => CGI.escapeHTML(f.index_name) }
-                    end
-                end
-            end
+        @files << file
+        @allfiles << { "file" => file, "modules" => modules, "classes" => classes, "methods" => methods, "nodes" => nodes }
+      end
 
-            res2 = []
-            collection['methods'].sort.each do |f|
-                if f.document_self
-                    res2 << { "href" => "../"+f.path, "name" => f.index_name.sub(/\(.*\)$/,'') }
-                end
-            end
+      # scan all classes to create the childs references
+      @allclasses.values.each do |klass|
+        if superklass = klass.context.superclass
+          if superklass = AllReferences[superklass] and (superklass.is_a?(HTMLPuppetClass) or superklass.is_a?(HTMLPuppetNode))
+            superklass.context.add_child(klass.context)
+          end
+        end
+      end
 
-            module_name = []
-            res3 = []
-            res4 = []
-            collection['modules'].sort.each do |f|
-                module_name << { "href" => "../"+CGI.escapeHTML(f.path), "name" => CGI.escapeHTML(f.index_name) }
-                unless f.facts.nil?
-                    f.facts.each do |fact|
-                        res3 << {"href" => "../"+CGI.escapeHTML(AllReferences["PLUGIN(#{fact.name})"].path), "name" => CGI.escapeHTML(fact.name)}
-                    end
-                end
-                unless f.plugins.nil?
-                    f.plugins.each do |plugin|
-                        res4 << {"href" => "../"+CGI.escapeHTML(AllReferences["PLUGIN(#{plugin.name})"].path), "name" => CGI.escapeHTML(plugin.name)}
-                    end
-                end
-            end
+      @classes = @allclasses.values
+    end
 
-            res5 = []
-            collection['nodes'].sort.each do |f|
-                if f.document_self
-                    res5 << { "href" => "../"+CGI.escapeHTML(f.path), "name" => CGI.escapeHTML(f.name) }
-                end
-            end
+    # produce a class/module list of HTMLPuppetModule/HTMLPuppetClass
+    # based on the code object traversal.
+    def generate_class_list(classes, modules, from, html_file, class_dir)
+      if from.is_module? and !@modules.has_key?(from.name)
+        k = HTMLPuppetModule.new(from, html_file, class_dir, @options)
+        classes << k
+        @modules[from.name] = k
+        modules << @modules[from.name]
+      elsif from.is_module?
+        modules << @modules[from.name]
+      elsif !from.is_module?
+        k = HTMLPuppetClass.new(from, html_file, class_dir, @options)
+        classes << k
+      end
+      from.each_classmodule do |mod|
+        generate_class_list(classes, modules, mod, html_file, class_dir)
+      end
+    end
 
-            values = {
-                "module" => module_name,
-                "classes"    => res1,
-                'classes_title' => CGI.escapeHTML("Classes"),
-                'defines_title' => CGI.escapeHTML("Defines"),
-                'facts_title' => CGI.escapeHTML("Custom Facts"),
-                'plugins_title' => CGI.escapeHTML("Plugins"),
-                'nodes_title' => CGI.escapeHTML("Nodes"),
-                'index_url'  => main_url,
-                'charset'    => @options.charset,
-                'style_url'  => style_url('', @options.css),
-            }
-
-            values["defines"] = res2 if res2.size>0
-            values["facts"] = res3 if res3.size>0
-            values["plugins"] = res4 if res4.size>0
-            values["nodes"] = res5 if res5.size>0
-
-            File.open(filename, "w") do |f|
-                template.write_html_on(f, values)
-            end
-        end
+    # generate all the subdirectories, modules, classes and files
+    def gen_sub_directories
+        super
+        File.makedirs(MODULE_DIR)
+        File.makedirs(NODE_DIR)
+        File.makedirs(PLUGIN_DIR)
+    rescue
+        $stderr.puts $ERROR_INFO.message
+        exit 1
+    end
 
-        # returns the initial_page url
-        def main_url
-            main_page = @options.main_page
-            ref = nil
-            if main_page
-                ref = AllReferences[main_page]
-                if ref
-                    ref = ref.path
-                else
-                    $stderr.puts "Could not find main page #{main_page}"
-                end
-            end
+    # generate the index of modules
+    def gen_file_index
+      gen_top_index(@modules.values, 'All Modules', RDoc::Page::TOP_INDEX, "fr_modules_index.html")
+    end
 
-            unless ref
-                for file in @files
-                    if file.document_self and file.context.global
-                        ref = CGI.escapeHTML("#{CLASS_DIR}/#{file.context.module_name}.html")
-                        break
-                    end
-                end
-            end
+    # generate a top index
+    def gen_top_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 << { "classlist" => CGI.escapeHTML("#{MODULE_DIR}/fr_#{f.index_name}.html"), "module" => CGI.escapeHTML("#{CLASS_DIR}/#{f.index_name}.html"),"name" => CGI.escapeHTML(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
 
-            unless ref
-                for file in @files
-                    if file.document_self and !file.context.global
-                        ref = CGI.escapeHTML("#{CLASS_DIR}/#{file.context.module_name}.html")
-                        break
-                    end
-                end
-            end
+    # generate the all classes index file and the combo index
+    def gen_class_index
+      gen_an_index(@classes, 'All Classes', RDoc::Page::CLASS_INDEX, "fr_class_index.html")
+      @allfiles.each do |file|
+        unless file['file'].context.file_relative_name =~ /\.rb$/
 
-            unless ref
-                $stderr.puts "Couldn't find anything to document"
-                $stderr.puts "Perhaps you've used :stopdoc: in all classes"
-                exit(1)
-            end
+          gen_composite_index(
+            file,
+              RDoc::Page::COMBO_INDEX,
 
-            ref
+              "#{MODULE_DIR}/fr_#{file["file"].context.module_name}.html")
         end
+      end
+    end
 
+    def gen_composite_index(collection, template, filename)\
+      return if FileTest.exists?(filename)
+
+      template = TemplatePage.new(RDoc::Page::FR_INDEX_BODY, template)
+      res1 = []
+      collection['classes'].sort.each do |f|
+        if f.document_self
+          res1 << { "href" => "../"+CGI.escapeHTML(f.path), "name" => CGI.escapeHTML(f.index_name) } unless f.context.is_module?
+        end
+      end
+
+      res2 = []
+      collection['methods'].sort.each do |f|
+        res2 << { "href" => "../#{f.path}", "name" => f.index_name.sub(/\(.*\)$/,'') } if f.document_self
+      end
+
+      module_name = []
+      res3 = []
+      res4 = []
+      collection['modules'].sort.each do |f|
+        module_name << { "href" => "../"+CGI.escapeHTML(f.path), "name" => CGI.escapeHTML(f.index_name) }
+        unless f.facts.nil?
+          f.facts.each do |fact|
+            res3 << {"href" => "../"+CGI.escapeHTML(AllReferences["PLUGIN(#{fact.name})"].path), "name" => CGI.escapeHTML(fact.name)}
+          end
+        end
+        unless f.plugins.nil?
+          f.plugins.each do |plugin|
+            res4 << {"href" => "../"+CGI.escapeHTML(AllReferences["PLUGIN(#{plugin.name})"].path), "name" => CGI.escapeHTML(plugin.name)}
+          end
+        end
+      end
+
+      res5 = []
+      collection['nodes'].sort.each do |f|
+        res5 << { "href" => "../"+CGI.escapeHTML(f.path), "name" => CGI.escapeHTML(f.name) } if f.document_self
+      end
+
+      values = {
+        "module" => module_name,
+        "classes"    => res1,
+        'classes_title' => CGI.escapeHTML("Classes"),
+        'defines_title' => CGI.escapeHTML("Defines"),
+        'facts_title' => CGI.escapeHTML("Custom Facts"),
+        'plugins_title' => CGI.escapeHTML("Plugins"),
+        'nodes_title' => CGI.escapeHTML("Nodes"),
+        'index_url'  => main_url,
+        'charset'    => @options.charset,
+        'style_url'  => style_url('', @options.css),
+      }
+
+      values["defines"] = res2 if res2.size>0
+      values["facts"] = res3 if res3.size>0
+      values["plugins"] = res4 if res4.size>0
+      values["nodes"] = res5 if res5.size>0
+
+      File.open(filename, "w") do |f|
+        template.write_html_on(f, values)
+      end
     end
 
-    # This module is used to hold/generate a list of puppet resources
-    # this is used in HTMLPuppetClass and HTMLPuppetNode
-    module ResourceContainer
-        def collect_resources
-            list = @context.resource_list
-            @resources = list.collect {|m| HTMLPuppetResource.new(m, self, @options) }
-        end
+    # returns the initial_page url
+    def main_url
+      main_page = @options.main_page
+      ref = nil
+      if main_page
+        ref = AllReferences[main_page]
+        if ref
+          ref = ref.path
+        else
+          $stderr.puts "Could not find main page #{main_page}"
+        end
+      end
+
+      unless ref
+        for file in @files
+          if file.document_self and file.context.global
+            ref = CGI.escapeHTML("#{CLASS_DIR}/#{file.context.module_name}.html")
+            break
+          end
+        end
+      end
+
+      unless ref
+        for file in @files
+          if file.document_self and !file.context.global
+            ref = CGI.escapeHTML("#{CLASS_DIR}/#{file.context.module_name}.html")
+            break
+          end
+        end
+      end
+
+      unless ref
+        $stderr.puts "Couldn't find anything to document"
+        $stderr.puts "Perhaps you've used :stopdoc: in all classes"
+        exit(1)
+      end
+
+      ref
+    end
 
-        def build_resource_summary_list(path_prefix='')
-            collect_resources unless @resources
-            resources = @resources.sort
-            res = []
-            resources.each do |r|
-                res << {
-                  "name" => CGI.escapeHTML(r.name),
-                  "aref" => CGI.escape(path_prefix)+"\#"+CGI.escape(r.aref)
-                }
-            end
-            res
-        end
+  end
+
+  # This module is used to generate a referenced full name list of ContextUser
+  module ReferencedListBuilder
+    def build_referenced_list(list)
+      res = []
+      list.each do |i|
+        ref = AllReferences[i.name] || @context.find_symbol(i.name)
+        ref = ref.viewer if ref and ref.respond_to?(:viewer)
+        name = i.respond_to?(:full_name) ? i.full_name : i.name
+        h_name = CGI.escapeHTML(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
+  end
+
+  # This module is used to hold/generate a list of puppet resources
+  # this is used in HTMLPuppetClass and HTMLPuppetNode
+  module ResourceContainer
+    def collect_resources
+      list = @context.resource_list
+      @resources = list.collect {|m| HTMLPuppetResource.new(m, self, @options) }
+    end
 
-        def build_resource_detail_list(section)
-            outer = []
-            resources = @resources.sort
-            resources.each do |r|
-                row = {}
-                if r.section == section and r.document_self
-                    row["name"]        = CGI.escapeHTML(r.name)
-                    desc = r.description.strip
-                    row["m_desc"]      = desc unless desc.empty?
-                    row["aref"]        = r.aref
-                    row["params"]      = r.params
-                    outer << row
-                end
-            end
-            outer
-        end
+    def build_resource_summary_list(path_prefix='')
+      collect_resources unless @resources
+      resources = @resources.sort
+      res = []
+      resources.each do |r|
+        res << {
+          "name" => CGI.escapeHTML(r.name),
+          "aref" => CGI.escape(path_prefix)+"\#"+CGI.escape(r.aref)
+        }
+      end
+      res
     end
 
-    class HTMLPuppetClass < HtmlClass
-        include ResourceContainer
+    def build_resource_detail_list(section)
+      outer = []
+      resources = @resources.sort
+      resources.each do |r|
+        row = {}
+        if r.section == section and r.document_self
+          row["name"]        = CGI.escapeHTML(r.name)
+          desc = r.description.strip
+          row["m_desc"]      = desc unless desc.empty?
+          row["aref"]        = r.aref
+          row["params"]      = r.params
+          outer << row
+        end
+      end
+      outer
+    end
+  end
 
-        def value_hash
-            super
-            rl = build_resource_summary_list
-            @values["resources"] = rl unless rl.empty?
+  class HTMLPuppetClass < HtmlClass
+    include ResourceContainer, ReferencedListBuilder
 
-            @context.sections.each do |section|
-                secdata = @values["sections"].select { |secdata| secdata["secsequence"] == section.sequence }
-                if secdata.size == 1
-                    secdata = secdata[0]
+    def value_hash
+      super
+      rl = build_resource_summary_list
+      @values["resources"] = rl unless rl.empty?
 
-                    rdl = build_resource_detail_list(section)
-                    secdata["resource_list"] = rdl unless rdl.empty?
-                end
-            end
-            @values
+      @context.sections.each do |section|
+        secdata = @values["sections"].select { |secdata| secdata["secsequence"] == section.sequence }
+        if secdata.size == 1
+          secdata = secdata[0]
+
+          rdl = build_resource_detail_list(section)
+          secdata["resource_list"] = rdl unless rdl.empty?
         end
+      end
+
+      rl = build_require_list(@context)
+      @values["requires"] = rl unless rl.empty?
+
+      rl = build_realize_list(@context)
+      @values["realizes"] = rl unless rl.empty?
+
+      cl = build_child_list(@context)
+      @values["childs"] = cl unless cl.empty?
+
+      @values
     end
 
-    class HTMLPuppetNode < ContextUser
-        include ResourceContainer
+    def build_require_list(context)
+      build_referenced_list(context.requires)
+    end
 
-        attr_reader :path
+    def build_realize_list(context)
+      build_referenced_list(context.realizes)
+    end
 
-        def initialize(context, html_file, prefix, options)
-            super(context, options)
+    def build_child_list(context)
+      build_referenced_list(context.childs)
+    end
+  end
 
-            @html_file = html_file
-            @is_module = context.is_module?
-            @values    = {}
+  class HTMLPuppetNode < ContextUser
+    include ResourceContainer, ReferencedListBuilder
 
-            context.viewer = self
+    attr_reader :path
 
-            if options.all_one_file
-                @path = context.full_name
-            else
-                @path = http_url(context.full_name, prefix)
-            end
+    def initialize(context, html_file, prefix, options)
+      super(context, options)
 
-            AllReferences.add("NODE(#{@context.full_name})", self)
-        end
+      @html_file = html_file
+      @is_module = context.is_module?
+      @values    = {}
 
-        def name
-            @context.name
-        end
+      context.viewer = self
 
-        # 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("::").collect { |p| Digest::MD5.hexdigest(p) }) + ".html"
-        end
+      if options.all_one_file
+        @path = context.full_name
+      else
+        @path = http_url(context.full_name, prefix)
+      end
 
-        def parent_name
-            @context.parent.full_name
-        end
+      AllReferences.add("NODE(#{@context.full_name})", self)
+    end
 
-        def index_name
-            name
-        end
+    def name
+      @context.name
+    end
 
-        def write_on(f)
-            value_hash
-            template = TemplatePage.new(RDoc::Page::BODYINC,
-                                        RDoc::Page::NODE_PAGE,
-                                        RDoc::Page::METHOD_LIST)
-            template.write_html_on(f, @values)
-        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
+      path.gsub!(/<<\s*(\w*)/) { "from-#$1" } if path['<<']
+      File.join(prefix, path.split("::").collect { |p| Digest::MD5.hexdigest(p) }) + ".html"
+    end
 
-        def value_hash
-            class_attribute_values
-            add_table_of_sections
+    def parent_name
+      @context.parent.full_name
+    end
 
-            @values["charset"] = @options.charset
-            @values["style_url"] = style_url(path, @options.css)
+    def index_name
+      name
+    end
 
-            d = markup(@context.comment)
-            @values["description"] = d unless d.empty?
+    def write_on(f)
+      value_hash
 
-            ml = build_method_summary_list
-            @values["methods"] = ml unless ml.empty?
+        template = TemplatePage.new(
+          RDoc::Page::BODYINC,
+            RDoc::Page::NODE_PAGE,
 
-            rl = build_resource_summary_list
-            @values["resources"] = rl unless rl.empty?
+            RDoc::Page::METHOD_LIST)
+      template.write_html_on(f, @values)
+    end
 
-            il = build_include_list(@context)
-            @values["includes"] = il unless il.empty?
+    def value_hash
+      class_attribute_values
+      add_table_of_sections
 
-            @values["sections"] = @context.sections.map do |section|
+      @values["charset"] = @options.charset
+      @values["style_url"] = style_url(path, @options.css)
 
-                secdata = {
-                    "sectitle" => section.title,
-                    "secsequence" => section.sequence,
-                    "seccomment" => markup(section.comment)
-                }
+      d = markup(@context.comment)
+      @values["description"] = d unless d.empty?
 
-                al = build_alias_summary_list(section)
-                secdata["aliases"] = al unless al.empty?
+      ml = build_method_summary_list
+      @values["methods"] = ml unless ml.empty?
 
-                co = build_constants_summary_list(section)
-                secdata["constants"] = co unless co.empty?
+      rl = build_resource_summary_list
+      @values["resources"] = rl unless rl.empty?
 
-                al = build_attribute_list(section)
-                secdata["attributes"] = al unless al.empty?
+      il = build_include_list(@context)
+      @values["includes"] = il unless il.empty?
 
-                cl = build_class_list(0, @context, section)
-                secdata["classlist"] = cl unless cl.empty?
+      rl = build_require_list(@context)
+      @values["requires"] = rl unless rl.empty?
 
-                mdl = build_method_detail_list(section)
-                secdata["method_list"] = mdl unless mdl.empty?
+      rl = build_realize_list(@context)
+      @values["realizes"] = rl unless rl.empty?
 
-                rdl = build_resource_detail_list(section)
-                secdata["resource_list"] = rdl unless rdl.empty?
+      cl = build_child_list(@context)
+      @values["childs"] = cl unless cl.empty?
 
-                secdata
-            end
+      @values["sections"] = @context.sections.map do |section|
 
-            @values
-        end
+        secdata = {
+          "sectitle" => section.title,
+          "secsequence" => section.sequence,
+          "seccomment" => markup(section.comment)
+        }
 
-        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
+        al = build_alias_summary_list(section)
+        secdata["aliases"] = al unless al.empty?
 
-        def class_attribute_values
-            h_name = CGI.escapeHTML(name)
+        co = build_constants_summary_list(section)
+        secdata["constants"] = co unless co.empty?
 
-            @values["classmod"]  = "Node"
-            @values["title"]     = CGI.escapeHTML("#{@values['classmod']}: #{h_name}")
+        al = build_attribute_list(section)
+        secdata["attributes"] = al unless al.empty?
 
-            c = @context
-            c = c.parent while c and !c.diagram
+        cl = build_class_list(0, @context, section)
+        secdata["classlist"] = cl unless cl.empty?
 
-            if c && c.diagram
-                @values["diagram"] = diagram_reference(c.diagram)
-            end
+        mdl = build_method_detail_list(section)
+        secdata["method_list"] = mdl unless mdl.empty?
+
+        rdl = build_resource_detail_list(section)
+        secdata["resource_list"] = rdl unless rdl.empty?
 
-            @values["full_name"] = h_name
+        secdata
+      end
 
-            parent_class = @context.superclass
+      @values
+    end
 
-            if parent_class
-                @values["parent"] = CGI.escapeHTML(parent_class)
+    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
 
-                if parent_name
-                    lookup = parent_name + "::" + parent_class
-                else
-                    lookup = parent_class
-                end
-                lookup = "NODE(#{lookup})"
-                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
+    def class_attribute_values
+      h_name = CGI.escapeHTML(name)
 
-            files = []
-            @context.in_files.each do |f|
-                res = {}
-                full_path = CGI.escapeHTML(f.file_absolute_name)
+      @values["classmod"]  = "Node"
+      @values["title"]     = CGI.escapeHTML("#{@values['classmod']}: #{h_name}")
 
-                res["full_path"]     = full_path
-                res["full_path_url"] = aref_to(f.viewer.path) if f.document_self
+      c = @context
+      c = c.parent while c and !c.diagram
 
-                if @options.webcvs
-                    res["cvsurl"] = cvs_url( @options.webcvs, full_path )
-                end
+      @values["diagram"] = diagram_reference(c.diagram) if c && c.diagram
 
-                files << res
-            end
+      @values["full_name"] = h_name
 
-            @values['infiles'] = files
-        end
+      parent_class = @context.superclass
 
-        def <=>(other)
-            self.name <=> other.name
+      if parent_class
+        @values["parent"] = CGI.escapeHTML(parent_class)
+
+        if parent_name
+          lookup = parent_name + "::#{parent_class}"
+        else
+          lookup = parent_class
         end
+        lookup = "NODE(#{lookup})"
+        parent_url = AllReferences[lookup] || AllReferences[parent_class]
+        @values["par_url"] = aref_to(parent_url.path) if parent_url and parent_url.document_self
+      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
+
+        res["cvsurl"] = cvs_url( @options.webcvs, full_path ) if @options.webcvs
+
+        files << res
+      end
+
+      @values['infiles'] = files
     end
 
-    class HTMLPuppetModule < HtmlClass
+    def build_require_list(context)
+      build_referenced_list(context.requires)
+    end
 
-        def initialize(context, html_file, prefix, options)
-            super(context, html_file, prefix, options)
-        end
+    def build_realize_list(context)
+      build_referenced_list(context.realizes)
+    end
 
-        def value_hash
-            @values = super
+    def build_child_list(context)
+      build_referenced_list(context.childs)
+    end
 
-            fl = build_facts_summary_list
-            @values["facts"] = fl unless fl.empty?
+    def <=>(other)
+      self.name <=> other.name
+    end
+  end
 
-            pl = build_plugins_summary_list
-            @values["plugins"] = pl unless pl.empty?
+  class HTMLPuppetModule < HtmlClass
 
-            nl = build_nodes_list(0, @context)
-            @values["nodelist"] = nl unless nl.empty?
+    def initialize(context, html_file, prefix, options)
+      super(context, html_file, prefix, options)
+    end
 
-            @values
-        end
+    def value_hash
+      @values = super
 
-        def build_nodes_list(level, context)
-            res = ""
-            prefix = "&nbsp;&nbsp;::" * level;
-
-            context.nodes.sort.each do |node|
-                if node.document_self
-                    res <<
-                    prefix <<
-                    "Node " <<
-                    href(url(node.viewer.path), "link", node.full_name) <<
-                    "<br />\n"
-                end
-            end
-            res
-        end
+      fl = build_facts_summary_list
+      @values["facts"] = fl unless fl.empty?
 
-        def build_facts_summary_list
-            potentially_referenced_list(context.facts) {|fn| ["PLUGIN(#{fn})"] }
-        end
+      pl = build_plugins_summary_list
+      @values["plugins"] = pl unless pl.empty?
 
-        def build_plugins_summary_list
-            potentially_referenced_list(context.plugins) {|fn| ["PLUGIN(#{fn})"] }
-        end
+      nl = build_nodes_list(0, @context)
+      @values["nodelist"] = nl unless nl.empty?
 
-        def facts
-            @context.facts
-        end
+      @values
+    end
 
-        def plugins
-            @context.plugins
+    def build_nodes_list(level, context)
+      res = ""
+      prefix = "&nbsp;&nbsp;::" * level;
+
+      context.nodes.sort.each do |node|
+        if node.document_self
+          res <<
+          prefix <<
+          "Node " <<
+          href(url(node.viewer.path), "link", node.full_name) <<
+          "<br />\n"
         end
+      end
+      res
+    end
 
+    def build_facts_summary_list
+      potentially_referenced_list(context.facts) {|fn| ["PLUGIN(#{fn})"] }
     end
 
-    class HTMLPuppetPlugin < ContextUser
-        attr_reader :path
+    def build_plugins_summary_list
+      potentially_referenced_list(context.plugins) {|fn| ["PLUGIN(#{fn})"] }
+    end
 
-        def initialize(context, html_file, prefix, options)
-            super(context, options)
+    def facts
+      @context.facts
+    end
 
-            @html_file = html_file
-            @is_module = false
-            @values    = {}
+    def plugins
+      @context.plugins
+    end
 
-            context.viewer = self
+  end
 
-            if options.all_one_file
-                @path = context.full_name
-            else
-                @path = http_url(context.full_name, prefix)
-            end
+  class HTMLPuppetPlugin < ContextUser
+    attr_reader :path
 
-            AllReferences.add("PLUGIN(#{@context.full_name})", self)
-        end
+    def initialize(context, html_file, prefix, options)
+      super(context, options)
 
-        def name
-            @context.name
-        end
+      @html_file = html_file
+      @is_module = false
+      @values    = {}
 
-        # 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
+      context.viewer = self
 
-        def parent_name
-            @context.parent.full_name
-        end
+      if options.all_one_file
+        @path = context.full_name
+      else
+        @path = http_url(context.full_name, prefix)
+      end
 
-        def index_name
-            name
-        end
+      AllReferences.add("PLUGIN(#{@context.full_name})", self)
+    end
 
-        def write_on(f)
-            value_hash
-            template = TemplatePage.new(RDoc::Page::BODYINC,
-                                        RDoc::Page::PLUGIN_PAGE,
-                                        RDoc::Page::PLUGIN_LIST)
-            template.write_html_on(f, @values)
-        end
+    def name
+      @context.name
+    end
 
-        def value_hash
-            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?
-
-            if context.is_fact?
-                unless context.confine.empty?
-                    res = {}
-                    res["type"] = context.confine[:type]
-                    res["value"] = context.confine[:value]
-                    @values["confine"] = [res]
-                end
-            else
-                @values["type"] = context.type
-            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
+      path.gsub!(/<<\s*(\w*)/) { "from-#$1" } if path['<<']
+      File.join(prefix, path.split("::")) + ".html"
+    end
 
-            @values["sections"] = @context.sections.map do |section|
-                secdata = {
-                    "sectitle" => section.title,
-                    "secsequence" => section.sequence,
-                    "seccomment" => markup(section.comment)
-                }
-                secdata
-            end
+    def parent_name
+      @context.parent.full_name
+    end
 
-            @values
-        end
+    def index_name
+      name
+    end
 
-        def attribute_values
-            h_name = CGI.escapeHTML(name)
+    def write_on(f)
+      value_hash
 
-            if @context.is_fact?
-                @values["classmod"]  = "Fact"
-            else
-                @values["classmod"]  = "Plugin"
-            end
-            @values["title"]     = "#{@values['classmod']}: #{h_name}"
+        template = TemplatePage.new(
+          RDoc::Page::BODYINC,
+            RDoc::Page::PLUGIN_PAGE,
 
-            c = @context
-            @values["full_name"] = h_name
+            RDoc::Page::PLUGIN_LIST)
+      template.write_html_on(f, @values)
+    end
 
-            files = []
-            @context.in_files.each do |f|
-                res = {}
-                full_path = CGI.escapeHTML(f.file_absolute_name)
+    def value_hash
+      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?
+
+      if context.is_fact?
+        unless context.confine.empty?
+          res = {}
+          res["type"] = context.confine[:type]
+          res["value"] = context.confine[:value]
+          @values["confine"] = [res]
+        end
+      else
+        @values["type"] = context.type
+      end
+
+      @values["sections"] = @context.sections.map do |section|
+        secdata = {
+          "sectitle" => section.title,
+          "secsequence" => section.sequence,
+          "seccomment" => markup(section.comment)
+        }
+        secdata
+      end
+
+      @values
+    end
 
-                res["full_path"]     = full_path
-                res["full_path_url"] = aref_to(f.viewer.path) if f.document_self
+    def attribute_values
+      h_name = CGI.escapeHTML(name)
 
-                if @options.webcvs
-                    res["cvsurl"] = cvs_url( @options.webcvs, full_path )
-                end
+      if @context.is_fact?
+        @values["classmod"]  = "Fact"
+      else
+        @values["classmod"]  = "Plugin"
+      end
+      @values["title"]     = "#{@values['classmod']}: #{h_name}"
 
-                files << res
-            end
+      c = @context
+      @values["full_name"] = h_name
 
-            @values['infiles'] = files
-        end
+      files = []
+      @context.in_files.each do |f|
+        res = {}
+        full_path = CGI.escapeHTML(f.file_absolute_name)
 
-        def <=>(other)
-            self.name <=> other.name
-        end
+        res["full_path"]     = full_path
+        res["full_path_url"] = aref_to(f.viewer.path) if f.document_self
 
+        res["cvsurl"] = cvs_url( @options.webcvs, full_path ) if @options.webcvs
+
+        files << res
+      end
+
+      @values['infiles'] = files
     end
 
-    class HTMLPuppetResource
-        include MarkUp
+    def <=>(other)
+      self.name <=> other.name
+    end
 
-        attr_reader :context
+  end
 
-        @@seq = "R000000"
+  class HTMLPuppetResource
+    include MarkUp
 
-        def initialize(context, html_class, options)
-            @context    = context
-            @html_class = html_class
-            @options    = options
-            @@seq       = @@seq.succ
-            @seq        = @@seq
+    attr_reader :context
 
-            context.viewer = self
+    @@seq = "R000000"
 
-            AllReferences.add(name, self)
-        end
+    def initialize(context, html_class, options)
+      @context    = context
+      @html_class = html_class
+      @options    = options
+      @@seq       = @@seq.succ
+      @seq        = @@seq
 
-        def as_href(from_path)
-            if @options.all_one_file
-                "#" + path
-            else
-                HTMLGenerator.gen_url(from_path, path)
-            end
-        end
+      context.viewer = self
 
-        def name
-            @context.name
-        end
+      AllReferences.add(name, self)
+    end
 
-        def section
-            @context.section
-        end
+    def as_href(from_path)
+      if @options.all_one_file
+        "##{path}"
+      else
+        HTMLGenerator.gen_url(from_path, path)
+      end
+    end
 
-        def index_name
-            "#{@context.name}"
-        end
+    def name
+      @context.name
+    end
 
-        def params
-            @context.params
-        end
+    def section
+      @context.section
+    end
 
-        def parent_name
-            if @context.parent.parent
-                @context.parent.parent.full_name
-            else
-                nil
-            end
-        end
+    def index_name
+      "#{@context.name}"
+    end
 
-        def aref
-            @seq
-        end
+    def params
+      @context.params
+    end
 
-        def path
-            if @options.all_one_file
-                aref
-            else
-                @html_class.path + "#" + aref
-            end
-        end
+    def parent_name
+      if @context.parent.parent
+        @context.parent.parent.full_name
+      else
+        nil
+      end
+    end
 
-        def description
-            markup(@context.comment)
-        end
+    def aref
+      @seq
+    end
 
-        def <=>(other)
-            @context <=> other.context
-        end
+    def path
+      if @options.all_one_file
+        aref
+      else
+        @html_class.path + "##{aref}"
+      end
+    end
 
-        def document_self
-            @context.document_self
-        end
+    def description
+      markup(@context.comment)
+    end
 
-        def find_symbol(symbol, method=nil)
-            res = @context.parent.find_symbol(symbol, method)
-            if res
-                res = res.viewer
-            end
-            res
-        end
+    def <=>(other)
+      @context <=> other.context
+    end
 
+    def document_self
+      @context.document_self
     end
 
-    class PuppetGeneratorInOne < HTMLGeneratorInOne
-        def gen_method_index
-            gen_an_index(HtmlMethod.all_methods, 'Defines')
-        end
+    def find_symbol(symbol, method=nil)
+      res = @context.parent.find_symbol(symbol, method)
+      res &&= res.viewer
+    end
+
+  end
+
+  class PuppetGeneratorInOne < HTMLGeneratorInOne
+    def gen_method_index
+      gen_an_index(HtmlMethod.all_methods, 'Defines')
     end
+  end
 
 end