diff --git a/lib/puppet/util/rdoc/parser.rb b/lib/puppet/util/rdoc/parser.rb
index 573d1766f..63df38ab9 100644
--- a/lib/puppet/util/rdoc/parser.rb
+++ b/lib/puppet/util/rdoc/parser.rb
@@ -1,475 +1,477 @@
 # Puppet "parser" for the rdoc system
 # The parser uses puppet parser and traverse the AST to instruct RDoc about
 # our current structures. It also parses ruby files that could contain
 # either custom facts or puppet plugins (functions, types...)
 
 # rdoc mandatory includes
 require "rdoc/code_objects"
 require "puppet/util/rdoc/code_objects"
 require "rdoc/tokenstream"
 require "rdoc/markup/simple_markup/preprocess"
 require "rdoc/parsers/parserfactory"
 
 module RDoc
 
 class Parser
   extend ParserFactory
 
+  SITE = "__site__"
+
   attr_accessor :ast, :input_file_name, :top_level
 
   # parser registration into RDoc
   parse_files_matching(/\.(rb|pp)$/)
 
   # called with the top level file
   def initialize(top_level, file_name, content, options, stats)
     @options = options
     @stats   = stats
     @input_file_name = file_name
     @top_level = PuppetTopLevel.new(top_level)
     @progress = $stderr unless options.quiet
   end
 
   # main entry point
   def scan
     Puppet.info "rdoc: scanning #{@input_file_name}"
     if @input_file_name =~ /\.pp$/
       @parser = Puppet::Parser::Parser.new(Puppet[:environment])
       @parser.file = @input_file_name
       @ast = @parser.parse
     end
     scan_top_level(@top_level)
     @top_level
   end
 
   # Due to a bug in RDoc, we need to roll our own find_module_named
   # The issue is that RDoc tries harder by asking the parent for a class/module
   # of the name. But by doing so, it can mistakenly use a module of same name
   # but from which we are not descendant.
   def find_object_named(container, name)
     return container if container.name == name
     container.each_classmodule do |m|
       return m if m.name == name
     end
     nil
   end
 
   # walk down the namespace and lookup/create container as needed
   def get_class_or_module(container, name)
 
     # class ::A -> A is in the top level
     if name =~ /^::/
       container = @top_level
     end
 
     names = name.split('::')
 
     final_name = names.pop
     names.each do |name|
       prev_container = container
       container = find_object_named(container, name)
       container ||= prev_container.add_class(PuppetClass, name, nil)
     end
     [container, final_name]
   end
 
   # split_module tries to find if +path+ belongs to the module path
   # if it does, it returns the module name, otherwise if we are sure
-  # it is part of the global manifest path, "<site>" is returned.
+  # it is part of the global manifest path, "__site__" is returned.
   # And finally if this path couldn't be mapped anywhere, nil is returned.
   def split_module(path)
     # find a module
     fullpath = File.expand_path(path)
     Puppet.debug "rdoc: testing #{fullpath}"
     if fullpath =~ /(.*)\/([^\/]+)\/(?:manifests|plugins|lib)\/.+\.(pp|rb)$/
       modpath = $1
       name = $2
       Puppet.debug "rdoc: module #{name} into #{modpath} ?"
       Puppet::Module.modulepath.each do |mp|
         if File.identical?(modpath,mp)
           Puppet.debug "rdoc: found module #{name}"
           return name
         end
       end
     end
     if fullpath =~ /\.(pp|rb)$/
       # there can be paths we don't want to scan under modules
       # imagine a ruby or manifest that would be distributed as part as a module
       # but we don't want those to be hosted under <site>
       Puppet::Module.modulepath.each do |mp|
         # check that fullpath is a descendant of mp
         dirname = fullpath
         while (dirname = File.dirname(dirname)) != '/'
           return nil if File.identical?(dirname,mp)
         end
       end
     end
     # we are under a global manifests
     Puppet.debug "rdoc: global manifests"
-    "<site>"
+    SITE
   end
 
   # create documentation for the top level +container+
   def scan_top_level(container)
     # use the module README as documentation for the module
     comment = ""
     readme = File.join(File.dirname(File.dirname(@input_file_name)), "README")
     comment = File.open(readme,"r") { |f| f.read } if FileTest.readable?(readme)
     look_for_directives_in(container, comment) unless comment.empty?
 
     # infer module name from directory
     name = split_module(@input_file_name)
     if name.nil?
       # skip .pp files that are not in manifests directories as we can't guarantee they're part
       # of a module or the global configuration.
       container.document_self = false
       return
     end
 
     Puppet.debug "rdoc: scanning for #{name}"
 
     container.module_name = name
-    container.global=true if name == "<site>"
+    container.global=true if name == SITE
 
     @stats.num_modules += 1
     container, name  = get_class_or_module(container,name)
     mod = container.add_module(PuppetModule, name)
     mod.record_location(@top_level)
     mod.comment = comment
 
     if @input_file_name =~ /\.pp$/
       parse_elements(mod)
     elsif @input_file_name =~ /\.rb$/
       parse_plugins(mod)
     end
   end
 
   # create documentation for include statements we can find in +code+
   # and associate it with +container+
   def scan_for_include_or_require(container, code)
     code = [code] unless code.is_a?(Array)
     code.each do |stmt|
       scan_for_include_or_require(container,stmt.children) if stmt.is_a?(Puppet::Parser::AST::ASTArray)
 
       if stmt.is_a?(Puppet::Parser::AST::Function) and ['include','require'].include?(stmt.name)
         stmt.arguments.each do |included|
           Puppet.debug "found #{stmt.name}: #{included.value}"
           container.send("add_#{stmt.name}",Include.new(included.value, stmt.doc))
         end
       end
     end
   end
 
   # create documentation for realize statements we can find in +code+
   # and associate it with +container+
   def scan_for_realize(container, code)
     code = [code] unless code.is_a?(Array)
     code.each do |stmt|
       scan_for_realize(container,stmt.children) if stmt.is_a?(Puppet::Parser::AST::ASTArray)
 
       if stmt.is_a?(Puppet::Parser::AST::Function) and stmt.name == 'realize'
         stmt.arguments.each do |realized|
           Puppet.debug "found #{stmt.name}: #{realized}"
           container.add_realize(Include.new(realized.to_s, stmt.doc))
         end
       end
     end
   end
 
   # create documentation for global variables assignements we can find in +code+
   # and associate it with +container+
   def scan_for_vardef(container, code)
     code = [code] unless code.is_a?(Array)
     code.each do |stmt|
       scan_for_vardef(container,stmt.children) if stmt.is_a?(Puppet::Parser::AST::ASTArray)
 
       if stmt.is_a?(Puppet::Parser::AST::VarDef)
         Puppet.debug "rdoc: found constant: #{stmt.name} = #{stmt.value}"
         container.add_constant(Constant.new(stmt.name.to_s, stmt.value.to_s, stmt.doc))
       end
     end
   end
 
   # create documentation for resources we can find in +code+
   # and associate it with +container+
   def scan_for_resource(container, code)
     code = [code] unless code.is_a?(Array)
     code.each do |stmt|
       scan_for_resource(container,stmt.children) if stmt.is_a?(Puppet::Parser::AST::ASTArray)
 
       if stmt.is_a?(Puppet::Parser::AST::Resource) and !stmt.type.nil?
         begin
           type = stmt.type.split("::").collect { |s| s.capitalize }.join("::")
           title = stmt.title.is_a?(Puppet::Parser::AST::ASTArray) ? stmt.title.to_s.gsub(/\[(.*)\]/,'\1') : stmt.title.to_s
           Puppet.debug "rdoc: found resource: #{type}[#{title}]"
 
           param = []
           stmt.params.children.each do |p|
             res = {}
             res["name"] = p.param
             res["value"] = "#{p.value.to_s}" unless p.value.nil?
 
             param << res
           end
 
           container.add_resource(PuppetResource.new(type, title, stmt.doc, param))
         rescue => detail
           raise Puppet::ParseError, "impossible to parse resource in #{stmt.file} at line #{stmt.line}: #{detail}"
         end
       end
     end
   end
 
   def resource_stmt_to_ref(stmt)
     type = stmt.type.split("::").collect { |s| s.capitalize }.join("::")
     title = stmt.title.is_a?(Puppet::Parser::AST::ASTArray) ? stmt.title.to_s.gsub(/\[(.*)\]/,'\1') : stmt.title.to_s
 
     param = stmt.params.children.collect do |p|
       {"name" => p.param, "value" => p.value.to_s}
     end
     PuppetResource.new(type, title, stmt.doc, param)
   end
 
   # create documentation for a class named +name+
   def document_class(name, klass, container)
     Puppet.debug "rdoc: found new class #{name}"
     container, name = get_class_or_module(container, name)
 
     superclass = klass.parent
     superclass = "" if superclass.nil? or superclass.empty?
 
     @stats.num_classes += 1
     comment = klass.doc
     look_for_directives_in(container, comment) unless comment.empty?
     cls = container.add_class(PuppetClass, name, superclass)
     # it is possible we already encountered this class, while parsing some namespaces
     # from other classes of other files. But at that time we couldn't know this class superclass
     # so, now we know it and force it.
     cls.superclass = superclass
     cls.record_location(@top_level)
 
     # scan class code for include
     code = klass.code.children if klass.code.is_a?(Puppet::Parser::AST::ASTArray)
     code ||= klass.code
     unless code.nil?
       scan_for_include_or_require(cls, code)
       scan_for_realize(cls, code)
       scan_for_resource(cls, code) if Puppet.settings[:document_all]
     end
 
     cls.comment = comment
   rescue => detail
     raise Puppet::ParseError, "impossible to parse class '#{name}' in #{klass.file} at line #{klass.line}: #{detail}"
   end
 
   # create documentation for a node
   def document_node(name, node, container)
     Puppet.debug "rdoc: found new node #{name}"
     superclass = node.parent
     superclass = "" if superclass.nil? or superclass.empty?
 
     comment = node.doc
     look_for_directives_in(container, comment) unless comment.empty?
     n = container.add_node(name, superclass)
     n.record_location(@top_level)
 
     code = node.code.children if node.code.is_a?(Puppet::Parser::AST::ASTArray)
     code ||= node.code
     unless code.nil?
       scan_for_include_or_require(n, code)
       scan_for_realize(n, code)
       scan_for_vardef(n, code)
       scan_for_resource(n, code) if Puppet.settings[:document_all]
     end
 
     n.comment = comment
   rescue => detail
     raise Puppet::ParseError, "impossible to parse node '#{name}' in #{node.file} at line #{node.line}: #{detail}"
   end
 
   # create documentation for a define
   def document_define(name, define, container)
     Puppet.debug "rdoc: found new definition #{name}"
     # find superclas if any
     @stats.num_methods += 1
 
     # find the parent
     # split define name by :: to find the complete module hierarchy
     container, name = get_class_or_module(container,name)
 
     # build up declaration
     declaration = ""
     define.arguments.each do |arg,value|
       declaration << "\$#{arg}"
       unless value.nil?
         declaration << " => "
         case value
         when Puppet::Parser::AST::Leaf
           declaration << "'#{value.value}'"
         when Puppet::Parser::AST::ASTArray
           declaration << "[#{value.children.collect { |v| "'#{v}'" }.join(", ")}]"
         else
           declaration << "#{value.to_s}"
         end
       end
       declaration << ", "
     end
     declaration.chop!.chop! if declaration.size > 1
 
     # register method into the container
     meth =  AnyMethod.new(declaration, name)
     meth.comment = define.doc
     container.add_method(meth)
     look_for_directives_in(container, meth.comment) unless meth.comment.empty?
     meth.params = "( #{declaration} )"
     meth.visibility = :public
     meth.document_self = true
     meth.singleton = false
   rescue => detail
     raise Puppet::ParseError, "impossible to parse definition '#{name}' in #{define.file} at line #{define.line}: #{detail}"
   end
 
   # Traverse the AST tree and produce code-objects node
   # that contains the documentation
   def parse_elements(container)
     Puppet.debug "rdoc: scanning manifest"
     @ast.hostclasses.values.sort { |a,b| a.name <=> b.name }.each do |klass|
       name = klass.name
       if klass.file == @input_file_name
         unless name.empty?
           document_class(name,klass,container)
         else # on main class document vardefs
           code = klass.code.children if klass.code.is_a?(Puppet::Parser::AST::ASTArray)
           code ||= klass.code
           scan_for_vardef(container, code) unless code.nil?
         end
       end
     end
 
     @ast.definitions.each do |name, define|
       if define.file == @input_file_name
         document_define(name,define,container)
       end
     end
 
     @ast.nodes.each do |name, node|
       if node.file == @input_file_name
         document_node(name.to_s,node,container)
       end
     end
   end
 
   # create documentation for plugins
   def parse_plugins(container)
     Puppet.debug "rdoc: scanning plugin or fact"
     if @input_file_name =~ /\/facter\/[^\/]+\.rb$/
       parse_fact(container)
     else
       parse_puppet_plugin(container)
     end
   end
 
   # this is a poor man custom fact parser :-)
   def parse_fact(container)
     comments = ""
     current_fact = nil
     File.open(@input_file_name) do |of|
       of.each do |line|
         # fetch comments
         if line =~ /^[ \t]*# ?(.*)$/
           comments += $1 + "\n"
         elsif line =~ /^[ \t]*Facter.add\(['"](.*?)['"]\)/
           current_fact = Fact.new($1,{})
           look_for_directives_in(container, comments) unless comments.empty?
           current_fact.comment = comments
           container.add_fact(current_fact)
           current_fact.record_location(@top_level)
           comments = ""
           Puppet.debug "rdoc: found custom fact #{current_fact.name}"
         elsif line =~ /^[ \t]*confine[ \t]*:(.*?)[ \t]*=>[ \t]*(.*)$/
           current_fact.confine = { :type => $1, :value => $2 } unless current_fact.nil?
         else # unknown line type
           comments =""
         end
       end
     end
   end
 
   # this is a poor man puppet plugin parser :-)
   # it doesn't extract doc nor desc :-(
   def parse_puppet_plugin(container)
     comments = ""
     current_plugin = nil
 
     File.open(@input_file_name) do |of|
       of.each do |line|
         # fetch comments
         if line =~ /^[ \t]*# ?(.*)$/
           comments += $1 + "\n"
         elsif line =~ /^[ \t]*newfunction[ \t]*\([ \t]*:(.*?)[ \t]*,[ \t]*:type[ \t]*=>[ \t]*(:rvalue|:lvalue)\)/
           current_plugin = Plugin.new($1, "function")
           container.add_plugin(current_plugin)
           look_for_directives_in(container, comments) unless comments.empty?
           current_plugin.comment = comments
           current_plugin.record_location(@top_level)
           comments = ""
           Puppet.debug "rdoc: found new function plugins #{current_plugin.name}"
         elsif line =~ /^[ \t]*Puppet::Type.newtype[ \t]*\([ \t]*:(.*?)\)/
           current_plugin = Plugin.new($1, "type")
           container.add_plugin(current_plugin)
           look_for_directives_in(container, comments) unless comments.empty?
           current_plugin.comment = comments
           current_plugin.record_location(@top_level)
           comments = ""
           Puppet.debug "rdoc: found new type plugins #{current_plugin.name}"
         elsif line =~ /module Puppet::Parser::Functions/
           # skip
         else # unknown line type
           comments =""
         end
       end
     end
   end
 
   # look_for_directives_in scans the current +comment+ for RDoc directives
   def look_for_directives_in(context, comment)
     preprocess = SM::PreProcess.new(@input_file_name, @options.rdoc_include)
 
     preprocess.handle(comment) do |directive, param|
       case directive
       when "stopdoc"
         context.stop_doc
         ""
       when "startdoc"
         context.start_doc
         context.force_documentation = true
         ""
       when "enddoc"
         #context.done_documenting = true
         #""
         throw :enddoc
       when "main"
         options = Options.instance
         options.main_page = param
         ""
       when "title"
         options = Options.instance
         options.title = param
         ""
       when "section"
         context.set_current_section(param, comment)
         comment.replace("") # 1.8 doesn't support #clear
         break
       else
         warn "Unrecognized directive '#{directive}'"
         break
       end
     end
     remove_private_comments(comment)
   end
 
   def remove_private_comments(comment)
     comment.gsub!(/^#--.*?^#\+\+/m, '')
     comment.sub!(/^#--.*/m, '')
   end
 end
 end
diff --git a/spec/unit/util/rdoc/parser_spec.rb b/spec/unit/util/rdoc/parser_spec.rb
index a9c8190a6..79195e657 100755
--- a/spec/unit/util/rdoc/parser_spec.rb
+++ b/spec/unit/util/rdoc/parser_spec.rb
@@ -1,540 +1,540 @@
 #!/usr/bin/env ruby
 
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
 require 'puppet/resource/type_collection'
 require 'puppet/util/rdoc/parser'
 require 'puppet/util/rdoc/code_objects'
 require 'rdoc/options'
 require 'rdoc/rdoc'
 
 describe RDoc::Parser do
   before :each do
     File.stubs(:stat).with("init.pp")
     @top_level = stub_everything 'toplevel', :file_relative_name => "init.pp"
     @parser = RDoc::Parser.new(@top_level, "module/manifests/init.pp", nil, Options.instance, RDoc::Stats.new)
   end
 
   describe "when scanning files" do
     it "should parse puppet files with the puppet parser" do
       @parser.stubs(:scan_top_level)
       parser = stub 'parser'
       Puppet::Parser::Parser.expects(:new).returns(parser)
       parser.expects(:parse)
       parser.expects(:file=).with("module/manifests/init.pp")
 
       @parser.scan
     end
 
     it "should scan the ast for Puppet files" do
       parser = stub_everything 'parser'
       Puppet::Parser::Parser.stubs(:new).returns(parser)
 
       @parser.expects(:scan_top_level)
 
       @parser.scan
     end
 
     it "should return a PuppetTopLevel to RDoc" do
       parser = stub_everything 'parser'
       Puppet::Parser::Parser.stubs(:new).returns(parser)
 
       @parser.expects(:scan_top_level)
 
       @parser.scan.should be_a(RDoc::PuppetTopLevel)
     end
   end
 
   describe "when scanning top level entities" do
     before :each do
       @resource_type_collection = stub_everything 'resource_type_collection'
       @parser.ast = @resource_type_collection
       @parser.stubs(:split_module).returns("module")
 
       @topcontainer = stub_everything 'topcontainer'
       @container = stub_everything 'container'
       @module = stub_everything 'module'
       @container.stubs(:add_module).returns(@module)
       @parser.stubs(:get_class_or_module).returns([@container, "module"])
     end
 
     it "should read any present README as module documentation" do
       FileTest.stubs(:readable?).returns(true)
       File.stubs(:open).returns("readme")
       @parser.stubs(:parse_elements)
 
       @module.expects(:comment=).with("readme")
 
       @parser.scan_top_level(@topcontainer)
     end
 
     it "should tell the container its module name" do
       @parser.stubs(:parse_elements)
 
       @topcontainer.expects(:module_name=).with("module")
 
       @parser.scan_top_level(@topcontainer)
     end
 
     it "should not document our toplevel if it isn't a valid module" do
       @parser.stubs(:split_module).returns(nil)
 
       @topcontainer.expects(:document_self=).with(false)
       @parser.expects(:parse_elements).never
 
       @parser.scan_top_level(@topcontainer)
     end
 
-    it "should set the module as global if we parse the global manifests (ie <site> module)" do
-      @parser.stubs(:split_module).returns("<site>")
+    it "should set the module as global if we parse the global manifests (ie __site__ module)" do
+      @parser.stubs(:split_module).returns(RDoc::Parser::SITE)
       @parser.stubs(:parse_elements)
 
       @topcontainer.expects(:global=).with(true)
 
       @parser.scan_top_level(@topcontainer)
     end
 
     it "should attach this module container to the toplevel container" do
       @parser.stubs(:parse_elements)
 
       @container.expects(:add_module).with(RDoc::PuppetModule, "module").returns(@module)
 
       @parser.scan_top_level(@topcontainer)
     end
 
     it "should defer ast parsing to parse_elements for this module" do
       @parser.expects(:parse_elements).with(@module)
 
       @parser.scan_top_level(@topcontainer)
     end
 
     it "should defer plugins parsing to parse_plugins for this module" do
       @parser.input_file_name = "module/lib/puppet/parser/function.rb"
 
       @parser.expects(:parse_plugins).with(@module)
 
       @parser.scan_top_level(@topcontainer)
     end
   end
 
   describe "when finding modules from filepath" do
     before :each do
       Puppet::Module.stubs(:modulepath).returns("/path/to/modules")
     end
 
     it "should return the module name for modulized puppet manifests" do
       File.stubs(:expand_path).returns("/path/to/module/manifests/init.pp")
       File.stubs(:identical?).with("/path/to", "/path/to/modules").returns(true)
       @parser.split_module("/path/to/modules/mymodule/manifests/init.pp").should == "module"
     end
 
     it "should return <site> for manifests not under module path" do
       File.stubs(:expand_path).returns("/path/to/manifests/init.pp")
       File.stubs(:identical?).returns(false)
-      @parser.split_module("/path/to/manifests/init.pp").should == "<site>"
+      @parser.split_module("/path/to/manifests/init.pp").should == RDoc::Parser::SITE
     end
   end
 
   describe "when parsing AST elements" do
     before :each do
       @klass = stub_everything 'klass', :file => "module/manifests/init.pp", :name => "myclass", :type => :hostclass
       @definition = stub_everything 'definition', :file => "module/manifests/init.pp", :type => :definition, :name => "mydef"
       @node = stub_everything 'node', :file => "module/manifests/init.pp", :type => :node, :name => "mynode"
 
       @resource_type_collection = Puppet::Resource::TypeCollection.new("env")
       @parser.ast = @resource_type_collection
 
       @container = stub_everything 'container'
     end
 
     it "should document classes in the parsed file" do
       @resource_type_collection.add_hostclass(@klass)
 
       @parser.expects(:document_class).with("myclass", @klass, @container)
 
       @parser.parse_elements(@container)
     end
 
     it "should not document class parsed in an other file" do
       @klass.stubs(:file).returns("/not/same/path/file.pp")
       @resource_type_collection.add_hostclass(@klass)
 
       @parser.expects(:document_class).with("myclass", @klass, @container).never
 
       @parser.parse_elements(@container)
     end
 
     it "should document vardefs for the main class" do
       @klass.stubs(:name).returns :main
       @resource_type_collection.add_hostclass(@klass)
 
       code = stub 'code', :is_a? => false
       @klass.stubs(:name).returns("")
       @klass.stubs(:code).returns(code)
 
       @parser.expects(:scan_for_vardef).with(@container, code)
 
       @parser.parse_elements(@container)
     end
 
     it "should document definitions in the parsed file" do
       @resource_type_collection.add_definition(@definition)
 
       @parser.expects(:document_define).with("mydef", @definition, @container)
 
       @parser.parse_elements(@container)
     end
 
     it "should not document definitions parsed in an other file" do
       @definition.stubs(:file).returns("/not/same/path/file.pp")
       @resource_type_collection.add_definition(@definition)
 
       @parser.expects(:document_define).with("mydef", @definition, @container).never
 
       @parser.parse_elements(@container)
     end
 
     it "should document nodes in the parsed file" do
       @resource_type_collection.add_node(@node)
 
       @parser.expects(:document_node).with("mynode", @node, @container)
 
       @parser.parse_elements(@container)
     end
 
     it "should not document node parsed in an other file" do
       @node.stubs(:file).returns("/not/same/path/file.pp")
       @resource_type_collection.add_node(@node)
 
       @parser.expects(:document_node).with("mynode", @node, @container).never
 
       @parser.parse_elements(@container)
     end
   end
 
   describe "when documenting definition" do
     before(:each) do
       @define = stub_everything 'define', :arguments => [], :doc => "mydoc", :file => "file", :line => 42
       @class = stub_everything 'class'
       @parser.stubs(:get_class_or_module).returns([@class, "mydef"])
     end
 
     it "should register a RDoc method to the current container" do
       @class.expects(:add_method).with { |m| m.name == "mydef"}
       @parser.document_define("mydef", @define, @class)
     end
 
     it "should attach the documentation to this method" do
       @class.expects(:add_method).with { |m| m.comment = "mydoc" }
 
       @parser.document_define("mydef", @define, @class)
     end
 
     it "should produce a better error message on unhandled exception" do
       @class.expects(:add_method).raises(ArgumentError)
 
       lambda { @parser.document_define("mydef", @define, @class) }.should raise_error(Puppet::ParseError, /in file at line 42/)
     end
 
     it "should convert all definition parameter to string" do
       arg = stub 'arg'
       val = stub 'val'
 
       @define.stubs(:arguments).returns({arg => val})
 
       arg.expects(:to_s).returns("arg")
       val.expects(:to_s).returns("val")
 
       @parser.document_define("mydef", @define, @class)
     end
   end
 
   describe "when documenting nodes" do
     before :each do
       @code = stub_everything 'code'
       @node = stub_everything 'node', :doc => "mydoc", :parent => "parent", :code => @code, :file => "file", :line => 42
       @rdoc_node = stub_everything 'rdocnode'
 
       @class = stub_everything 'class'
       @class.stubs(:add_node).returns(@rdoc_node)
     end
 
     it "should add a node to the current container" do
       @class.expects(:add_node).with("mynode", "parent").returns(@rdoc_node)
       @parser.document_node("mynode", @node, @class)
     end
 
     it "should associate the node documentation to the rdoc node" do
       @rdoc_node.expects(:comment=).with("mydoc")
       @parser.document_node("mynode", @node, @class)
     end
 
     it "should scan for include and require" do
       @parser.expects(:scan_for_include_or_require).with(@rdoc_node, @code)
       @parser.document_node("mynode", @node, @class)
     end
 
     it "should scan for variable definition" do
       @parser.expects(:scan_for_vardef).with(@rdoc_node, @code)
       @parser.document_node("mynode", @node, @class)
     end
 
     it "should scan for resources if needed" do
       Puppet.settings.stubs(:[]).with(:document_all).returns(true)
       @parser.expects(:scan_for_resource).with(@rdoc_node, @code)
       @parser.document_node("mynode", @node, @class)
     end
 
     it "should produce a better error message on unhandled exception" do
       @class.stubs(:add_node).raises(ArgumentError)
 
       lambda { @parser.document_node("mynode", @node, @class) }.should raise_error(Puppet::ParseError, /in file at line 42/)
     end
   end
 
   describe "when documenting classes" do
     before :each do
       @code = stub_everything 'code'
       @class = stub_everything 'class', :doc => "mydoc", :parent => "parent", :code => @code, :file => "file", :line => 42
       @rdoc_class = stub_everything 'rdoc-class'
 
       @module = stub_everything 'class'
       @module.stubs(:add_class).returns(@rdoc_class)
       @parser.stubs(:get_class_or_module).returns([@module, "myclass"])
     end
 
     it "should add a class to the current container" do
       @module.expects(:add_class).with(RDoc::PuppetClass, "myclass", "parent").returns(@rdoc_class)
       @parser.document_class("mynode", @class, @module)
     end
 
     it "should set the superclass" do
       @rdoc_class.expects(:superclass=).with("parent")
       @parser.document_class("mynode", @class, @module)
     end
 
     it "should associate the node documentation to the rdoc class" do
       @rdoc_class.expects(:comment=).with("mydoc")
       @parser.document_class("mynode", @class, @module)
     end
 
     it "should scan for include and require" do
       @parser.expects(:scan_for_include_or_require).with(@rdoc_class, @code)
       @parser.document_class("mynode", @class, @module)
     end
 
     it "should scan for resources if needed" do
       Puppet.settings.stubs(:[]).with(:document_all).returns(true)
       @parser.expects(:scan_for_resource).with(@rdoc_class, @code)
       @parser.document_class("mynode", @class, @module)
     end
 
     it "should produce a better error message on unhandled exception" do
       @module.stubs(:add_class).raises(ArgumentError)
 
       lambda { @parser.document_class("mynode", @class, @module) }.should raise_error(Puppet::ParseError, /in file at line 42/)
     end
   end
 
   describe "when scanning for includes and requires" do
 
     def create_stmt(name)
       stmt_value = stub "#{name}_value", :value => "myclass"
       stmt = stub_everything 'stmt', :name => name, :arguments => [stmt_value], :doc => "mydoc"
       stmt.stubs(:is_a?).with(Puppet::Parser::AST::ASTArray).returns(false)
       stmt.stubs(:is_a?).with(Puppet::Parser::AST::Function).returns(true)
       stmt
     end
 
     before(:each) do
       @class = stub_everything 'class'
       @code = stub_everything 'code'
       @code.stubs(:is_a?).with(Puppet::Parser::AST::ASTArray).returns(true)
     end
 
     it "should also scan mono-instruction code" do
       @class.expects(:add_include).with { |i| i.is_a?(RDoc::Include) and i.name == "myclass" and i.comment == "mydoc" }
 
       @parser.scan_for_include_or_require(@class,create_stmt("include"))
     end
 
     it "should register recursively includes to the current container" do
       @code.stubs(:children).returns([ create_stmt("include") ])
 
       @class.expects(:add_include).with { |i| i.is_a?(RDoc::Include) and i.name == "myclass" and i.comment == "mydoc" }
       @parser.scan_for_include_or_require(@class, [@code])
     end
 
     it "should register requires to the current container" do
       @code.stubs(:children).returns([ create_stmt("require") ])
 
       @class.expects(:add_require).with { |i| i.is_a?(RDoc::Include) and i.name == "myclass" and i.comment == "mydoc" }
       @parser.scan_for_include_or_require(@class, [@code])
     end
   end
 
   describe "when scanning for realized virtual resources" do
 
     def create_stmt
       stmt_value = stub "resource_ref", :to_s => "File[\"/tmp/a\"]"
       stmt = stub_everything 'stmt', :name => "realize", :arguments => [stmt_value], :doc => "mydoc"
       stmt.stubs(:is_a?).with(Puppet::Parser::AST::ASTArray).returns(false)
       stmt.stubs(:is_a?).with(Puppet::Parser::AST::Function).returns(true)
       stmt
     end
 
     before(:each) do
       @class = stub_everything 'class'
       @code = stub_everything 'code'
       @code.stubs(:is_a?).with(Puppet::Parser::AST::ASTArray).returns(true)
     end
 
     it "should also scan mono-instruction code" do
       @class.expects(:add_realize).with { |i| i.is_a?(RDoc::Include) and i.name == "File[\"/tmp/a\"]" and i.comment == "mydoc" }
 
       @parser.scan_for_realize(@class,create_stmt)
     end
 
     it "should register recursively includes to the current container" do
       @code.stubs(:children).returns([ create_stmt ])
 
       @class.expects(:add_realize).with { |i| i.is_a?(RDoc::Include) and i.name == "File[\"/tmp/a\"]" and i.comment == "mydoc" }
       @parser.scan_for_realize(@class, [@code])
     end
   end
 
   describe "when scanning for variable definition" do
     before :each do
       @class = stub_everything 'class'
 
       @stmt = stub_everything 'stmt', :name => "myvar", :value => "myvalue", :doc => "mydoc"
       @stmt.stubs(:is_a?).with(Puppet::Parser::AST::ASTArray).returns(false)
       @stmt.stubs(:is_a?).with(Puppet::Parser::AST::VarDef).returns(true)
 
       @code = stub_everything 'code'
       @code.stubs(:is_a?).with(Puppet::Parser::AST::ASTArray).returns(true)
     end
 
     it "should recursively register variables to the current container" do
       @code.stubs(:children).returns([ @stmt ])
 
       @class.expects(:add_constant).with { |i| i.is_a?(RDoc::Constant) and i.name == "myvar" and i.comment == "mydoc" }
       @parser.scan_for_vardef(@class, [ @code ])
     end
 
     it "should also scan mono-instruction code" do
       @class.expects(:add_constant).with { |i| i.is_a?(RDoc::Constant) and i.name == "myvar" and i.comment == "mydoc" }
 
       @parser.scan_for_vardef(@class, @stmt)
     end
   end
 
   describe "when scanning for resources" do
     before :each do
       @class = stub_everything 'class'
 
       param = stub 'params', :children => []
       @stmt = stub_everything 'stmt', :type => "File", :title => "myfile", :doc => "mydoc", :params => param
       @stmt.stubs(:is_a?).with(Puppet::Parser::AST::ASTArray).returns(false)
       @stmt.stubs(:is_a?).with(Puppet::Parser::AST::Resource).returns(true)
 
       @code = stub_everything 'code'
       @code.stubs(:is_a?).with(Puppet::Parser::AST::ASTArray).returns(true)
     end
 
     it "should register a PuppetResource to the current container" do
       @code.stubs(:children).returns([ @stmt ])
 
       @class.expects(:add_resource).with { |i| i.is_a?(RDoc::PuppetResource) and i.title == "myfile" and i.comment == "mydoc" }
       @parser.scan_for_resource(@class, [ @code ])
     end
 
     it "should also scan mono-instruction code" do
       @class.expects(:add_resource).with { |i| i.is_a?(RDoc::PuppetResource) and i.title == "myfile" and i.comment == "mydoc" }
 
       @parser.scan_for_resource(@class, @stmt)
     end
   end
 
   describe "when parsing plugins" do
     before :each do
       @container = stub 'container'
     end
 
     it "should delegate parsing custom facts to parse_facts" do
       @parser = RDoc::Parser.new(@top_level, "module/manifests/lib/puppet/facter/test.rb", nil, Options.instance, RDoc::Stats.new)
 
       @parser.expects(:parse_fact).with(@container)
       @parser.parse_plugins(@container)
     end
 
     it "should delegate parsing plugins to parse_plugins" do
       @parser = RDoc::Parser.new(@top_level, "module/manifests/lib/puppet/functions/test.rb", nil, Options.instance, RDoc::Stats.new)
 
       @parser.expects(:parse_puppet_plugin).with(@container)
       @parser.parse_plugins(@container)
     end
   end
 
   describe "when parsing plugins" do
     before :each do
       @container = stub_everything 'container'
     end
 
     it "should add custom functions to the container" do
       File.stubs(:open).yields("# documentation
       module Puppet::Parser::Functions
       	newfunction(:myfunc, :type => :rvalue) do |args|
       		File.dirname(args[0])
       	end
       end".split("\n"))
 
       @container.expects(:add_plugin).with do |plugin|
         plugin.comment == "documentation\n" #and
         plugin.name == "myfunc"
       end
 
       @parser.parse_puppet_plugin(@container)
     end
 
     it "should add custom types to the container" do
       File.stubs(:open).yields("# documentation
       Puppet::Type.newtype(:mytype) do
       end".split("\n"))
 
       @container.expects(:add_plugin).with do |plugin|
         plugin.comment == "documentation\n" #and
         plugin.name == "mytype"
       end
 
       @parser.parse_puppet_plugin(@container)
     end
   end
 
   describe "when parsing facts" do
     before :each do
       @container = stub_everything 'container'
       File.stubs(:open).yields(["# documentation", "Facter.add('myfact') do", "confine :kernel => :linux", "end"])
     end
 
     it "should add facts to the container" do
       @container.expects(:add_fact).with do |fact|
         fact.comment == "documentation\n" and
         fact.name == "myfact"
       end
 
       @parser.parse_fact(@container)
     end
 
     it "should add confine to the parsed facts" do
       ourfact = nil
       @container.expects(:add_fact).with do |fact|
         ourfact = fact
         true
       end
 
       @parser.parse_fact(@container)
       ourfact.confine.should == { :type => "kernel", :value => ":linux" }
     end
   end
 end