openvox 8.19.0

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

@@ -0,0 +1,902 @@
+# frozen_string_literal: true
+
+require 'rdoc/generators/html_generator'
+require_relative '../../../../puppet/util/rdoc/code_objects'
+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"
+
+  # We're monkey patching RDoc markup to allow
+  # lowercase class1::class2::class3 crossref hyperlinking
+  module MarkUp
+    alias :old_markup :markup
+
+    def new_markup(str, remove_para = false)
+      first = @markup.nil?
+      res = old_markup(str, remove_para)
+      if first and !@markup.nil?
+        @markup.add_special(/\b([a-z]\w+(::\w+)*)/, :CROSSREF)
+        # we need to call it again, since we added a rule
+        res = old_markup(str, remove_para)
+      end
+      res
+    end
+    alias :markup :new_markup
+  end
+
+  # This is a specialized HTMLGenerator tailored to Puppet manifests
+  class PuppetGenerator < HTMLGenerator
+    def self.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
+
+    # loads our own html template file
+    def load_html_template
+      require_relative '../../../../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
+
+    # 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 = {}
+
+      # remove unknown toplevels
+      # it can happen that RDoc triggers a different parser for some files (ie .c, .cc or .h)
+      # in this case RDoc generates a RDoc::TopLevel which we do not support in this generator
+      # So let's make sure we don't generate html for those.
+      @toplevels = @toplevels.select { |tl| tl.is_a? RDoc::PuppetTopLevel }
+
+      # 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 unless @allclasses.has_key?(k.index_name)
+        end
+
+        # generate nodes and plugins found
+        classes.each do |k|
+          next unless 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
+
+        @files << file
+        @allfiles << { "file" => file, "modules" => modules, "classes" => classes, "methods" => methods, "nodes" => nodes }
+      end
+
+      # scan all classes to create the child's references
+      @allclasses.values.each do |klass|
+        superklass = klass.context.superclass
+        next unless superklass
+
+        superklass = AllReferences[superklass]
+        if superklass && (superklass.is_a?(HTMLPuppetClass) || superklass.is_a?(HTMLPuppetNode))
+          superklass.context.add_child(klass.context)
+        end
+      end
+
+      @classes = @allclasses.values
+    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
+
+    # 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
+
+    # 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
+
+    # 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),
+      }
+
+      Puppet::FileSystem.open(filename, nil, "w:UTF-8") do |f|
+        template.write_html_on(f, values)
+      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|
+        next if 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
+    end
+
+    def gen_composite_index(collection, template, filename)
+      return if Puppet::FileSystem.exist?(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
+        next if f.plugins.nil?
+
+        f.plugins.each do |plugin|
+          res4 << { "href" => "../" + CGI.escapeHTML(AllReferences["PLUGIN(#{plugin.name})"].path), "name" => CGI.escapeHTML(plugin.name) }
+        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
+
+      Puppet::FileSystem.open(filename, nil, "w:UTF-8") do |f|
+        template.write_html_on(f, values)
+      end
+    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
+        @files.each do |file|
+          if file.document_self and file.context.global
+            ref = CGI.escapeHTML("#{CLASS_DIR}/#{file.context.module_name}.html")
+            break
+          end
+        end
+      end
+
+      unless ref
+        @files.each do |file|
+          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
+  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_summary_list(path_prefix = '')
+      collect_resources unless @resources
+      resources = @resources.sort
+      res = []
+      resources.each do |r|
+        res << {
+          "name" => CGI.escapeHTML(r.name),
+          "aref" => Puppet::Util.uri_encode(path_prefix) + "\#" + Puppet::Util.uri_query_encode(r.aref)
+        }
+      end
+      res
+    end
+
+    def build_resource_detail_list(section)
+      outer = []
+      resources = @resources.sort
+      resources.each do |r|
+        row = {}
+        next unless 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
+      outer
+    end
+  end
+
+  class HTMLPuppetClass < HtmlClass
+    include ResourceContainer, ReferencedListBuilder
+
+    def value_hash
+      super
+      rl = build_resource_summary_list
+      @values["resources"] = rl unless rl.empty?
+
+      @context.sections.each do |section|
+        secdata = @values["sections"].select { |s| s["secsequence"] == section.sequence }
+        next unless secdata.size == 1
+
+        secdata = secdata[0]
+
+        rdl = build_resource_detail_list(section)
+        secdata["resource_list"] = rdl unless rdl.empty?
+      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
+
+    def build_require_list(context)
+      build_referenced_list(context.requires)
+    end
+
+    def build_realize_list(context)
+      build_referenced_list(context.realizes)
+    end
+
+    def build_child_list(context)
+      build_referenced_list(context.childs)
+    end
+  end
+
+  class HTMLPuppetNode < ContextUser
+    include ResourceContainer, ReferencedListBuilder
+
+    attr_reader :path
+
+    def initialize(context, html_file, prefix, options)
+      super(context, options)
+
+      @html_file = html_file
+      @is_module = context.is_module?
+      @values    = {}
+
+      context.viewer = self
+
+      if options.all_one_file
+        @path = context.full_name
+      else
+        @path = http_url(context.full_name, prefix)
+      end
+
+      AllReferences.add("NODE(#{@context.full_name})", self)
+    end
+
+    def name
+      @context.name
+    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-#{::Regexp.last_match(1)}" } if path['<<']
+      File.join(prefix, path.split("::").collect { |p| Digest::MD5.hexdigest(p) }) + ".html"
+    end
+
+    def parent_name
+      @context.parent.full_name
+    end
+
+    def index_name
+      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
+
+    def value_hash
+      class_attribute_values
+      add_table_of_sections
+
+      @values["charset"] = @options.charset
+      @values["style_url"] = style_url(path, @options.css)
+
+      d = markup(@context.comment)
+      @values["description"] = d unless d.empty?
+
+      ml = build_method_summary_list
+      @values["methods"] = ml unless ml.empty?
+
+      rl = build_resource_summary_list
+      @values["resources"] = rl unless rl.empty?
+
+      il = build_include_list(@context)
+      @values["includes"] = il unless il.empty?
+
+      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["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?
+
+        rdl = build_resource_detail_list(section)
+        secdata["resource_list"] = rdl unless rdl.empty?
+
+        secdata
+      end
+
+      @values
+    end
+
+    def build_attribute_list(section)
+      atts = @context.attributes.sort
+      res = []
+      atts.each do |att|
+        next unless att.section == section
+
+        next unless 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
+      res
+    end
+
+    def class_attribute_values
+      h_name = CGI.escapeHTML(name)
+
+      @values["classmod"]  = "Node"
+      @values["title"]     = CGI.escapeHTML("#{@values['classmod']}: #{h_name}")
+
+      c = @context
+      c = c.parent while c and !c.diagram
+
+      @values["diagram"] = diagram_reference(c.diagram) if c && c.diagram
+
+      @values["full_name"] = h_name
+
+      parent_class = @context.superclass
+
+      if parent_class
+        @values["parent"] = CGI.escapeHTML(parent_class)
+
+        if parent_name
+          lookup = parent_name + "::#{parent_class}"
+        else
+          lookup = parent_class
+        end
+        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
+
+    def build_require_list(context)
+      build_referenced_list(context.requires)
+    end
+
+    def build_realize_list(context)
+      build_referenced_list(context.realizes)
+    end
+
+    def build_child_list(context)
+      build_referenced_list(context.childs)
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+  end
+
+  class HTMLPuppetModule < HtmlClass
+    def value_hash
+      @values = super
+
+      fl = build_facts_summary_list
+      @values["facts"] = fl unless fl.empty?
+
+      pl = build_plugins_summary_list
+      @values["plugins"] = pl unless pl.empty?
+
+      nl = build_nodes_list(0, @context)
+      @values["nodelist"] = nl unless nl.empty?
+
+      @values
+    end
+
+    def build_nodes_list(level, context)
+      res = ""
+      prefix = "&nbsp;&nbsp;::" * level;
+
+      context.nodes.sort.each do |node|
+        next unless node.document_self
+
+        res <<
+          prefix <<
+          "Node " <<
+          href(url(node.viewer.path), "link", node.full_name) <<
+          "<br />\n"
+      end
+      res
+    end
+
+    def build_facts_summary_list
+      potentially_referenced_list(context.facts) { |fn| ["PLUGIN(#{fn})"] }
+    end
+
+    def build_plugins_summary_list
+      potentially_referenced_list(context.plugins) { |fn| ["PLUGIN(#{fn})"] }
+    end
+
+    def facts
+      @context.facts
+    end
+
+    def plugins
+      @context.plugins
+    end
+  end
+
+  class HTMLPuppetPlugin < ContextUser
+    attr_reader :path
+
+    def initialize(context, html_file, prefix, options)
+      super(context, options)
+
+      @html_file = html_file
+      @is_module = false
+      @values    = {}
+
+      context.viewer = self
+
+      if options.all_one_file
+        @path = context.full_name
+      else
+        @path = http_url(context.full_name, prefix)
+      end
+
+      AllReferences.add("PLUGIN(#{@context.full_name})", self)
+    end
+
+    def name
+      @context.name
+    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-#{::Regexp.last_match(1)}" } if path['<<']
+      File.join(prefix, path.split("::")) + ".html"
+    end
+
+    def parent_name
+      @context.parent.full_name
+    end
+
+    def index_name
+      name
+    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 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
+
+    def attribute_values
+      h_name = CGI.escapeHTML(name)
+
+      if @context.is_fact?
+        @values["classmod"]  = "Fact"
+      else
+        @values["classmod"]  = "Plugin"
+      end
+      @values["title"]     = "#{@values['classmod']}: #{h_name}"
+
+      @values["full_name"] = h_name
+
+      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
+
+    def <=>(other)
+      name <=> other.name
+    end
+  end
+
+  class HTMLPuppetResource
+    include MarkUp
+
+    attr_reader :context
+
+    @@seq = "R000000"
+
+    def initialize(context, html_class, options)
+      @context    = context
+      @html_class = html_class
+      @options    = options
+      @@seq       = @@seq.succ
+      @seq        = @@seq
+
+      context.viewer = self
+
+      AllReferences.add(name, self)
+    end
+
+    def as_href(from_path)
+      if @options.all_one_file
+        "##{path}"
+      else
+        HTMLGenerator.gen_url(from_path, path)
+      end
+    end
+
+    def name
+      @context.name
+    end
+
+    def section
+      @context.section
+    end
+
+    def index_name
+      @context.name.to_s
+    end
+
+    def params
+      @context.params
+    end
+
+    def parent_name
+      if @context.parent.parent
+        @context.parent.parent.full_name
+      else
+        nil
+      end
+    end
+
+    def aref
+      @seq
+    end
+
+    def path
+      if @options.all_one_file
+        aref
+      else
+        @html_class.path + "##{aref}"
+      end
+    end
+
+    def description
+      markup(@context.comment)
+    end
+
+    def <=>(other)
+      @context <=> other.context
+    end
+
+    def document_self
+      @context.document_self
+    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