diff --git a/LICENSE b/LICENSE
index 57d96f83e..a43a24352 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,17 +1,17 @@
-Puppet - Automating Configuration Management. Copyright (C) 2005 Reductive Labs LLC
+Puppet - Automating Configuration Management. Copyright (C) 2005 Puppet Labs LLC
 
-Reductive Labs can be contacted at: info@reductivelabs.com
+Puppet Labs can be contacted at: info@puppetlabs.com
 
 This program and entire repository is free software; you can
 redistribute it and/or modify it under the terms of the GNU
 General Public License as published by the Free Software
 Foundation; either version 2 of the License, or any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
diff --git a/lib/puppet/parser/functions/versioncmp.rb b/lib/puppet/parser/functions/versioncmp.rb
index 94ba3886f..6091e0923 100644
--- a/lib/puppet/parser/functions/versioncmp.rb
+++ b/lib/puppet/parser/functions/versioncmp.rb
@@ -1,34 +1,34 @@
 require 'puppet/util/package'
 
 
       Puppet::Parser::Functions::newfunction(
         :versioncmp, :type => :rvalue,
 
   :doc => "Compares two versions
 
 Prototype:
 
     \$result = versioncmp(a, b)
 
 Where a and b are arbitrary version strings
 
 This functions returns a number:
 
-* > 0 if version a is greater than version b
-* == 0 if both version are equals
-* < 0 if version a is less than version b
+* Greater than 0 if version a is greater than version b
+* Equal to 0 if both version are equals
+* Less than 0 if version a is less than version b
 
 Example:
 
     if versioncmp('2.6-1', '2.4.5') > 0 {
         notice('2.6-1 is > than 2.4.5')
     }
 
 ") do |args|
 
   unless args.length == 2
     raise Puppet::ParseError, "versioncmp should have 2 arguments"
   end
 
   return Puppet::Util::Package.versioncmp(args[0], args[1])
 end
diff --git a/lib/puppet/parser/resource.rb b/lib/puppet/parser/resource.rb
index 8a5ae886c..e34f284fc 100644
--- a/lib/puppet/parser/resource.rb
+++ b/lib/puppet/parser/resource.rb
@@ -1,318 +1,325 @@
 require 'puppet/resource'
 
 # The primary difference between this class and its
 # parent is that this class has rules on who can set
 # parameters
 class Puppet::Parser::Resource < Puppet::Resource
   require 'puppet/parser/resource/param'
   require 'puppet/util/tagging'
   require 'puppet/file_collection/lookup'
   require 'puppet/parser/yaml_trimmer'
   require 'puppet/resource/type_collection_helper'
 
   include Puppet::FileCollection::Lookup
   include Puppet::Resource::TypeCollectionHelper
 
   include Puppet::Util
   include Puppet::Util::MethodHelper
   include Puppet::Util::Errors
   include Puppet::Util::Logging
   include Puppet::Util::Tagging
   include Puppet::Parser::YamlTrimmer
 
   attr_accessor :source, :scope, :rails_id
   attr_accessor :virtual, :override, :translated, :catalog, :evaluated
 
   attr_reader :exported, :parameters
 
   # Determine whether the provided parameter name is a relationship parameter.
   def self.relationship_parameter?(name)
     @relationship_names ||= Puppet::Type.relationship_params.collect { |p| p.name }
     @relationship_names.include?(name)
   end
 
   # Set up some boolean test methods
   def translated?; !!@translated; end
   def override?;   !!@override;   end
   def evaluated?;  !!@evaluated;  end
 
   def [](param)
     param = symbolize(param)
     if param == :title
       return self.title
     end
     if @parameters.has_key?(param)
       @parameters[param].value
     else
       nil
     end
   end
 
   def []=(param, value)
     set_parameter(param, value)
   end
 
   def eachparam
     @parameters.each do |name, param|
       yield param
     end
   end
 
   def environment
     scope.environment
   end
 
   # Retrieve the associated definition and evaluate it.
   def evaluate
     @evaluated = true
     if klass = resource_type and ! builtin_type?
       finish
       return klass.evaluate_code(self)
     elsif builtin?
       devfail "Cannot evaluate a builtin type (#{type})"
     else
       self.fail "Cannot find definition #{type}"
     end
   end
 
   # Mark this resource as both exported and virtual,
   # or remove the exported mark.
   def exported=(value)
     if value
       @virtual = true
       @exported = value
     else
       @exported = value
     end
   end
 
   # Do any finishing work on this object, called before evaluation or
   # before storage/translation.
   def finish
     return if finished?
     @finished = true
     add_defaults
     add_metaparams
+    add_scope_tags
     validate
   end
 
   # Has this resource already been finished?
   def finished?
     @finished
   end
 
   def initialize(*args)
     raise ArgumentError, "Resources require a scope" unless args.last[:scope]
     super
 
     @source ||= scope.source
   end
 
   # Is this resource modeling an isomorphic resource type?
   def isomorphic?
     if builtin_type?
       return resource_type.isomorphic?
     else
       return true
     end
   end
 
   # Merge an override resource in.  This will throw exceptions if
   # any overrides aren't allowed.
   def merge(resource)
     # Test the resource scope, to make sure the resource is even allowed
     # to override.
     unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
       raise Puppet::ParseError.new("Only subclasses can override parameters", resource.line, resource.file)
     end
     # Some of these might fail, but they'll fail in the way we want.
     resource.parameters.each do |name, param|
       override_parameter(param)
     end
   end
 
   # Unless we're running >= 0.25, we're in compat mode.
   def metaparam_compatibility_mode?
     ! (catalog and ver = (catalog.client_version||'0.0.0').split(".") and (ver[0] > "0" or ver[1].to_i >= 25))
   end
 
   def name
     self[:name] || self.title
   end
 
   # A temporary occasion, until I get paths in the scopes figured out.
   def path
     to_s
   end
 
   # Define a parameter in our resource.
   # if we ever receive a parameter named 'tag', set
   # the resource tags with its value.
   def set_parameter(param, value = nil)
     if ! value.nil?
       param = Puppet::Parser::Resource::Param.new(
         :name => param, :value => value, :source => self.source
       )
     elsif ! param.is_a?(Puppet::Parser::Resource::Param)
       raise ArgumentError, "Must pass a parameter or all necessary values"
     end
 
     tag(*param.value) if param.name == :tag
 
     # And store it in our parameter hash.
     @parameters[param.name] = param
   end
 
   def to_hash
     @parameters.inject({}) do |hash, ary|
       param = ary[1]
       # Skip "undef" values.
       hash[param.name] = param.value if param.value != :undef
       hash
     end
   end
 
 
   # Create a Puppet::Resource instance from this parser resource.
   # We plan, at some point, on not needing to do this conversion, but
   # it's sufficient for now.
   def to_resource
     result = Puppet::Resource.new(type, title)
 
     to_hash.each do |p, v|
       if v.is_a?(Puppet::Resource)
         v = Puppet::Resource.new(v.type, v.title)
       elsif v.is_a?(Array)
         # flatten resource references arrays
         v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
         v = v.collect do |av|
           av = Puppet::Resource.new(av.type, av.title) if av.is_a?(Puppet::Resource)
           av
         end
       end
 
       # If the value is an array with only one value, then
       # convert it to a single value.  This is largely so that
       # the database interaction doesn't have to worry about
       # whether it returns an array or a string.
       result[p] = if v.is_a?(Array) and v.length == 1
         v[0]
           else
             v
               end
     end
 
     result.file = self.file
     result.line = self.line
     result.exported = self.exported
     result.virtual = self.virtual
     result.tag(*self.tags)
 
     result
   end
 
   # Translate our object to a transportable object.
   def to_trans
     return nil if virtual?
 
     to_resource.to_trans
   end
 
   # Convert this resource to a RAL resource.  We hackishly go via the
   # transportable stuff.
   def to_ral
     to_resource.to_ral
   end
 
   private
 
   # Add default values from our definition.
   def add_defaults
     scope.lookupdefaults(self.type).each do |name, param|
       unless @parameters.include?(name)
         self.debug "Adding default for #{name}"
 
         @parameters[name] = param.dup
       end
     end
   end
 
   def add_backward_compatible_relationship_param(name)
     # Skip metaparams for which we get no value.
     return unless val = scope.lookupvar(name.to_s, false) and val != :undefined
 
     # The default case: just set the value
     set_parameter(name, val) and return unless @parameters[name]
 
     # For relationship params, though, join the values (a la #446).
     @parameters[name].value = [@parameters[name].value, val].flatten
   end
 
   # Add any metaparams defined in our scope. This actually adds any metaparams
   # from any parent scope, and there's currently no way to turn that off.
   def add_metaparams
     compat_mode = metaparam_compatibility_mode?
 
     Puppet::Type.eachmetaparam do |name|
       next unless self.class.relationship_parameter?(name)
       add_backward_compatible_relationship_param(name) if compat_mode
     end
   end
 
+  def add_scope_tags
+    if scope_resource = scope.resource
+      tag(*scope_resource.tags)
+    end
+  end
+
   # Accept a parameter from an override.
   def override_parameter(param)
     # This can happen if the override is defining a new parameter, rather
     # than replacing an existing one.
     (set_parameter(param) and return) unless current = @parameters[param.name]
 
     # The parameter is already set.  Fail if they're not allowed to override it.
     unless param.source.child_of?(current.source)
       puts caller if Puppet[:trace]
       msg = "Parameter '#{param.name}' is already set on #{self}"
       msg += " by #{current.source}" if current.source.to_s != ""
       if current.file or current.line
         fields = []
         fields << current.file if current.file
         fields << current.line.to_s if current.line
         msg += " at #{fields.join(":")}"
       end
       msg += "; cannot redefine"
       raise Puppet::ParseError.new(msg, param.line, param.file)
     end
 
     # If we've gotten this far, we're allowed to override.
 
     # Merge with previous value, if the parameter was generated with the +>
     # syntax.  It's important that we use a copy of the new param instance
     # here, not the old one, and not the original new one, so that the source
     # is registered correctly for later overrides but the values aren't
     # implcitly shared when multiple resources are overrriden at once (see
     # ticket #3556).
     if param.add
       param = param.dup
       param.value = [current.value, param.value].flatten
     end
 
     set_parameter(param)
   end
 
   # Make sure the resource's parameters are all valid for the type.
   def validate
     @parameters.each do |name, param|
       validate_parameter(name)
     end
   rescue => detail
     fail Puppet::ParseError, detail.to_s
   end
 
   private
 
   def extract_parameters(params)
     params.each do |param|
       # Don't set the same parameter twice
       self.fail Puppet::ParseError, "Duplicate parameter '#{param.name}' for on #{self}" if @parameters[param.name]
 
       set_parameter(param)
     end
   end
 end
diff --git a/lib/puppet/provider/package/rpm.rb b/lib/puppet/provider/package/rpm.rb
index 72dc260a4..ec6121743 100755
--- a/lib/puppet/provider/package/rpm.rb
+++ b/lib/puppet/provider/package/rpm.rb
@@ -1,132 +1,133 @@
 require 'puppet/provider/package'
 # RPM packaging.  Should work anywhere that has rpm installed.
 Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Provider::Package do
   desc "RPM packaging support; should work anywhere with a working `rpm`
     binary."
 
   has_feature :versionable
 
   # The query format by which we identify installed packages
   NEVRAFORMAT = "%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}"
   NEVRA_FIELDS = [:name, :epoch, :version, :release, :arch]
 
   commands :rpm => "rpm"
 
   if command('rpm')
     confine :true => begin
       rpm('--version')
       rescue Puppet::ExecutionFailure
         false
       else
         true
       end
   end
 
   def self.instances
     packages = []
 
     # rpm < 4.1 don't support --nosignature
     output = rpm "--version"
     sig = "--nosignature"
     if output =~ /RPM version (([123].*)|(4\.0.*))/
       sig = ""
     end
 
     # list out all of the packages
     begin
       execpipe("#{command(:rpm)} -qa #{sig} --nodigest --qf '#{NEVRAFORMAT}\n'") { |process|
         # now turn each returned line into a package object
         process.each { |line|
           hash = nevra_to_hash(line)
           packages << new(hash)
         }
       }
     rescue Puppet::ExecutionFailure
       raise Puppet::Error, "Failed to list packages"
     end
 
     packages
   end
 
   # Find the fully versioned package name and the version alone. Returns
   # a hash with entries :instance => fully versioned package name, and
   # :ensure => version-release
   def query
     #NOTE: Prior to a fix for issue 1243, this method potentially returned a cached value
     #IF YOU CALL THIS METHOD, IT WILL CALL RPM
     #Use get(:property) to check if cached values are available
     cmd = ["-q", @resource[:name], "--nosignature", "--nodigest", "--qf", "#{NEVRAFORMAT}\n"]
 
     begin
       output = rpm(*cmd)
     rescue Puppet::ExecutionFailure
-      return nil
+      # rpm exits 1 if the package is not found.
+      return {:ensure => :purged, :status => 'missing', :name => @resource[:name], :error => 'ok'}    
     end
 
     # FIXME: We could actually be getting back multiple packages
     # for multilib
     @property_hash.update(self.class.nevra_to_hash(output))
 
     @property_hash.dup
   end
 
   # Here we just retrieve the version from the file specified in the source.
   def latest
     unless source = @resource[:source]
       @resource.fail "RPMs must specify a package source"
     end
 
     cmd = [command(:rpm), "-q", "--qf", "#{NEVRAFORMAT}\n", "-p", "#{@resource[:source]}"]
     h = self.class.nevra_to_hash(execfail(cmd, Puppet::Error))
     h[:ensure]
   end
 
   def install
     source = nil
     unless source = @resource[:source]
       @resource.fail "RPMs must specify a package source"
     end
     # RPM gets pissy if you try to install an already
     # installed package
     if @resource.should(:ensure) == @property_hash[:ensure] or
       @resource.should(:ensure) == :latest && @property_hash[:ensure] == latest
       return
     end
 
     flag = "-i"
     flag = "-U" if @property_hash[:ensure] and @property_hash[:ensure] != :absent
 
     rpm flag, "--oldpackage", source
   end
 
   def uninstall
     query unless get(:arch)
     nvr = "#{get(:name)}-#{get(:version)}-#{get(:release)}"
     arch = ".#{get(:arch)}"
     # If they specified an arch in the manifest, erase that Otherwise,
     # erase the arch we got back from the query. If multiple arches are
     # installed and only the package name is specified (without the
     # arch), this will uninstall all of them on successive runs of the
     # client, one after the other
     if @resource[:name][-arch.size, arch.size] == arch
       nvr += arch
     else
       nvr += ".#{get(:arch)}"
     end
     rpm "-e", nvr
   end
 
   def update
     self.install
   end
 
   def self.nevra_to_hash(line)
     line.chomp!
     hash = {}
     NEVRA_FIELDS.zip(line.split) { |f, v| hash[f] = v }
     hash[:provider] = self.name
     hash[:ensure] = "#{hash[:version]}-#{hash[:release]}"
     hash
   end
 end
 
diff --git a/lib/puppet/reference/configuration.rb b/lib/puppet/reference/configuration.rb
index fadd1a423..e6a8dc20f 100644
--- a/lib/puppet/reference/configuration.rb
+++ b/lib/puppet/reference/configuration.rb
@@ -1,149 +1,144 @@
 config = Puppet::Util::Reference.newreference(:configuration, :depth => 1, :doc => "A reference for all configuration parameters") do
   docs = {}
   Puppet.settings.each do |name, object|
     docs[name] = object
   end
 
   str = ""
   docs.sort { |a, b|
     a[0].to_s <=> b[0].to_s
   }.each do |name, object|
     # Make each name an anchor
     header = name.to_s
     str += h(header, 3)
 
     # Print the doc string itself
     begin
       str += object.desc.gsub(/\n/, " ")
     rescue => detail
       puts detail.backtrace
       puts detail
     end
     str += "\n\n"
 
     # Now print the data about the item.
     str += ""
     val = object.default
     if name.to_s == "vardir"
       val = "/var/lib/puppet"
     elsif name.to_s == "confdir"
       val = "/etc/puppet"
     end
 
     # Leave out the section information; it was apparently confusing people.
     #str += "- **Section**: #{object.section}\n"
     unless val == ""
       str += "- *Default*: #{val}\n"
     end
     str += "\n"
   end
 
   return str
 end
 
 config.header = "
-Specifying Configuration Parameters
------------------------------------
+## Specifying Configuration Parameters
+
+### On The Command-Line
 
-On The Command-Line
-+++++++++++++++++++
 Every Puppet executable (with the exception of `puppetdoc`) accepts all of
 the parameters below, but not all of the arguments make sense for every executable.
 
 I have tried to be as thorough as possible in the descriptions of the
 arguments, so it should be obvious whether an argument is appropriate or not.
 
 These parameters can be supplied to the executables either as command-line
 options or in the configuration file.  For instance, the command-line
 invocation below would set the configuration directory to `/private/puppet`:
 
     $ puppet agent --confdir=/private/puppet
 
 Note that boolean options are turned on and off with a slightly different
 syntax on the command line:
 
     $ puppet agent --storeconfigs
 
     $ puppet agent --no-storeconfigs
 
 The invocations above will enable and disable, respectively, the storage of
 the client configuration.
 
-Configuration Files
-+++++++++++++++++++
+### Configuration Files
 
 As mentioned above, the configuration parameters can also be stored in a
 configuration file, located in the configuration directory.  As root, the
 default configuration directory is `/etc/puppet`, and as a regular user, the
 default configuration directory is `~user/.puppet`.  As of 0.23.0, all
 executables look for `puppet.conf` in their configuration directory
 (although they previously looked for separate files).  For example,
 `puppet.conf` is located at `/etc/puppet/puppet.conf` as `root` and
 `~user/.puppet/puppet.conf` as a regular user by default.
 
 All executables will set any parameters set within the `[main]` section,
 and each executable will also use one of the `[master]`, `[agent]`.
 
-File Format
-'''''''''''
+#### File Format
 
 The file follows INI-style formatting.  Here is an example of a very simple
 `puppet.conf` file:
 
     [main]
       confdir = /private/puppet
       storeconfigs = true
 
 Note that boolean parameters must be explicitly specified as `true` or
 `false` as seen above.
 
 If you need to change file parameters (e.g., reset the mode or owner), do
 so within curly braces on the same line:
 
     [main]
       myfile = /tmp/whatever {owner = root, mode = 644}
 
 If you're starting out with a fresh configuration, you may wish to let
 the executable generate a template configuration file for you by invoking
 the executable in question with the `--genconfig` command.  The executable
 will print a template configuration to standard output, which can be
 redirected to a file like so:
 
     $ puppet agent --genconfig > /etc/puppet/puppet.conf
 
 Note that this invocation will replace the contents of any pre-existing
 `puppet.conf` file, so make a backup of your present config if it contains
 valuable information.
 
 Like the `--genconfig` argument, the executables also accept a `--genmanifest`
 argument, which will generate a manifest that can be used to manage all of
 Puppet's directories and files and prints it to standard output.  This can
 likewise be redirected to a file:
 
     $ puppet agent --genmanifest > /etc/puppet/manifests/site.pp
 
 Puppet can also create user and group accounts for itself (one `puppet` group
 and one `puppet` user) if it is invoked as `root` with the `--mkusers` argument:
 
     $ puppet agent --mkusers
 
-Signals
--------
+## Signals
 
 The `puppet agent` and `puppet master` executables catch some signals for special
 handling.  Both daemons catch (`SIGHUP`), which forces the server to restart
 tself.  Predictably, interrupt and terminate (`SIGINT` and `SIGTERM`) will shut
 down the server, whether it be an instance of `puppet agent` or `puppet master`.
 
 Sending the `SIGUSR1` signal to an instance of `puppet agent` will cause it to
 immediately begin a new configuration transaction with the server.  This
 signal has no effect on `puppet master`.
 
-Configuration Parameter Reference
----------------------------------
+## Configuration Parameter Reference
 
 Below is a list of all documented parameters.  Not all of them are valid with all
 Puppet executables, but the executables will ignore any inappropriate values.
 
 "
 
diff --git a/lib/puppet/reference/indirection.rb b/lib/puppet/reference/indirection.rb
index 0cdbb2510..e5b076508 100644
--- a/lib/puppet/reference/indirection.rb
+++ b/lib/puppet/reference/indirection.rb
@@ -1,33 +1,33 @@
 require 'puppet/indirector/indirection'
 require 'puppet/util/checksums'
 require 'puppet/file_serving/content'
 require 'puppet/file_serving/metadata'
 
 reference = Puppet::Util::Reference.newreference :indirection, :doc => "Indirection types and their terminus classes" do
   text = ""
   Puppet::Indirector::Indirection.instances.sort { |a,b| a.to_s <=> b.to_s }.each do |indirection|
     ind = Puppet::Indirector::Indirection.instance(indirection)
     name = indirection.to_s.capitalize
-    text += indirection.to_s + "\n" + ("-" * name.length) + "\n\n"
+    text += "## " + indirection.to_s + "\n\n"
 
     text += ind.doc + "\n\n"
 
     Puppet::Indirector::Terminus.terminus_classes(ind.name).sort { |a,b| a.to_s <=> b.to_s }.each do |terminus|
-      text += terminus.to_s + "\n" + ("+" * terminus.to_s.length) + "\n\n"
+      text += "### " + terminus.to_s + "\n\n"
 
       term_class = Puppet::Indirector::Terminus.terminus_class(ind.name, terminus)
 
       text += Puppet::Util::Docs.scrub(term_class.doc) + "\n\n"
     end
   end
 
   text
 end
 
 reference.header = "This is the list of all indirections, their associated terminus classes, and how you select between them.
 
 In general, the appropriate terminus class is selected by the application for you (e.g., `puppet agent` would always use the `rest`
 terminus for most of its indirected classes), but some classes are tunable via normal settings.  These will have `terminus setting` documentation listed with them.
 
 
 "
diff --git a/lib/puppet/reference/metaparameter.rb b/lib/puppet/reference/metaparameter.rb
index 39c4b7f5f..c16a1d33a 100644
--- a/lib/puppet/reference/metaparameter.rb
+++ b/lib/puppet/reference/metaparameter.rb
@@ -1,40 +1,41 @@
 metaparameter = Puppet::Util::Reference.newreference :metaparameter, :doc => "All Puppet metaparameters and all their details" do
   types = {}
   Puppet::Type.loadall
 
   Puppet::Type.eachtype { |type|
     next if type.name == :puppet
     next if type.name == :component
     types[type.name] = type
   }
 
   str = %{
-    Metaparameters
-    --------------
-    Metaparameters are parameters that work with any resource type; they are part of the
-    Puppet framework itself rather than being part of the implementation of any
-    given instance.  Thus, any defined metaparameter can be used with any instance
-    in your manifest, including defined components.
 
-    Available Metaparameters
-    ++++++++++++++++++++++++
-    }
+# Metaparameters
+    
+Metaparameters are parameters that work with any resource type; they are part of the 
+Puppet framework itself rather than being part of the implementation of any
+given instance.  Thus, any defined metaparameter can be used with any instance
+in your manifest, including defined components.
+
+## Available Metaparameters
+
+}
   begin
     params = []
     Puppet::Type.eachmetaparam { |param|
       params << param
     }
 
     params.sort { |a,b|
       a.to_s <=> b.to_s
     }.each { |param|
       str += paramwrap(param.to_s, scrub(Puppet::Type.metaparamdoc(param)), :level => 4)
     }
   rescue => detail
     puts detail.backtrace
     puts "incorrect metaparams: #{detail}"
     exit(1)
   end
 
   str
 end
diff --git a/lib/puppet/reference/type.rb b/lib/puppet/reference/type.rb
index 2378bb83a..847bbc223 100644
--- a/lib/puppet/reference/type.rb
+++ b/lib/puppet/reference/type.rb
@@ -1,113 +1,112 @@
 type = Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types and all their details" do
   types = {}
   Puppet::Type.loadall
 
   Puppet::Type.eachtype { |type|
     next if type.name == :puppet
     next if type.name == :component
     types[type.name] = type
   }
 
   str = %{
 
-    Resource Types
-    --------------
+## Resource Types
 
-    - The *namevar* is the parameter used to uniquely identify a type instance.
+- The *namevar* is the parameter used to uniquely identify a type instance.
   This is the parameter that gets assigned when a string is provided before
   the colon in a type declaration.  In general, only developers will need to
   worry about which parameter is the `namevar`.
 
   In the following code:
 
       file { "/etc/passwd":
         owner => root,
         group => root,
         mode => 644
       }
 
   `/etc/passwd` is considered the title of the file object (used for things like
   dependency handling), and because `path` is the namevar for `file`, that
   string is assigned to the `path` parameter.
 
-  - *Parameters* determine the specific configuration of the instance.  They either
+- *Parameters* determine the specific configuration of the instance.  They either
   directly modify the system (internally, these are called properties) or they affect
   how the instance behaves (e.g., adding a search path for `exec` instances or determining recursion on `file` instances).
 
-  - *Providers* provide low-level functionality for a given resource type.  This is
+- *Providers* provide low-level functionality for a given resource type.  This is
   usually in the form of calling out to external commands.
 
   When required binaries are specified for providers, fully qualifed paths
   indicate that the binary must exist at that specific path and unqualified
   binaries indicate that Puppet will search for the binary using the shell
   path.
 
-  - *Features* are abilities that some providers might not support.  You can use the list
+- *Features* are abilities that some providers might not support.  You can use the list
   of supported features to determine how a given provider can be used.
 
   Resource types define features they can use, and providers can be tested to see
   which features they provide.
 
     }
 
     types.sort { |a,b|
       a.to_s <=> b.to_s
     }.each { |name,type|
 
       str += "
 
 ----------------
 
 "
 
   str += h(name, 3)
   str += scrub(type.doc) + "\n\n"
 
   # Handle the feature docs.
   if featuredocs = type.featuredocs
     str += h("Features", 4)
     str += featuredocs
     end
 
     docs = {}
     type.validproperties.sort { |a,b|
       a.to_s <=> b.to_s
     }.reject { |sname|
       property = type.propertybyname(sname)
       property.nodoc
     }.each { |sname|
       property = type.propertybyname(sname)
 
       raise "Could not retrieve property #{sname} on type #{type.name}" unless property
 
       doc = nil
       unless doc = property.doc
         $stderr.puts "No docs for #{type}[#{sname}]"
         next
       end
       doc = doc.dup
       tmp = doc
       tmp = scrub(tmp)
 
       docs[sname]  = tmp
     }
 
     str += h("Parameters", 4) + "\n"
     type.parameters.sort { |a,b|
       a.to_s <=> b.to_s
     }.each { |name,param|
       #docs[name] = indent(scrub(type.paramdoc(name)), $tab)
       docs[name] = scrub(type.paramdoc(name))
     }
 
     additional_key_attributes = type.key_attributes - [:name]
     docs.sort { |a, b|
       a[0].to_s <=> b[0].to_s
     }.each { |name, doc|
       str += paramwrap(name, doc, :namevar => additional_key_attributes.include?(name))
     }
     str += "\n"
   }
 
   str
 end
diff --git a/lib/puppet/reports/tagmail.rb b/lib/puppet/reports/tagmail.rb
index 71bafb2da..e17143e2f 100644
--- a/lib/puppet/reports/tagmail.rb
+++ b/lib/puppet/reports/tagmail.rb
@@ -1,168 +1,168 @@
 require 'puppet'
 require 'pp'
 
 require 'net/smtp'
 require 'time'
 
 Puppet::Reports.register_report(:tagmail) do
   desc "This report sends specific log messages to specific email addresses
     based on the tags in the log messages.  
 
     See the [UsingTags tag documentation](http://projects.puppetlabs.com/projects/puppet/wiki/Using_Tags) for more information on tags.
 
     To use this report, you must create a `tagmail.conf` (in the location
     specified by `tagmap`).  This is a simple file that maps tags to
     email addresses:  Any log messages in the report that match the specified
     tags will be sent to the specified email addresses.
 
     Tags must be comma-separated, and they can be negated so that messages
     only match when they do not have that tag.  The tags are separated from
     the email addresses by a colon, and the email addresses should also
     be comma-separated.
 
     Lastly, there is an `all` tag that will always match all log messages.
 
     Here is an example `tagmail.conf`:
 
         all: me@domain.com
         webserver, !mailserver: httpadmins@domain.com
 
     This will send all messages to `me@domain.com`, and all messages from
     webservers that are not also from mailservers to `httpadmins@domain.com`.
 
     If you are using anti-spam controls, such as grey-listing, on your mail
     server you should whitelist the sending email (controlled by `reportform` configuration option) to ensure your email is not discarded as spam.
     "
 
   # Find all matching messages.
   def match(taglists)
     matching_logs = []
     taglists.each do |emails, pos, neg|
       # First find all of the messages matched by our positive tags
       messages = nil
       if pos.include?("all")
         messages = self.logs
       else
         # Find all of the messages that are tagged with any of our
         # tags.
         messages = self.logs.find_all do |log|
           pos.detect { |tag| log.tagged?(tag) }
         end
       end
 
       # Now go through and remove any messages that match our negative tags
       messages = messages.reject do |log|
         true if neg.detect do |tag| log.tagged?(tag) end
       end
 
       if messages.empty?
         Puppet.info "No messages to report to #{emails.join(",")}"
         next
       else
         matching_logs << [emails, messages.collect { |m| m.to_report }.join("\n")]
       end
     end
 
     matching_logs
   end
 
   # Load the config file
   def parse(text)
     taglists = []
     text.split("\n").each do |line|
       taglist = emails = nil
       case line.chomp
       when /^\s*#/; next
       when /^\s*$/; next
       when /^\s*(.+)\s*:\s*(.+)\s*$/
         taglist = $1
         emails = $2.sub(/#.*$/,'')
       else
         raise ArgumentError, "Invalid tagmail config file"
       end
 
       pos = []
       neg = []
       taglist.sub(/\s+$/,'').split(/\s*,\s*/).each do |tag|
-        unless tag =~ /^!?[-\w]+$/
+        unless tag =~ /^!?[-\w\.]+$/
           raise ArgumentError, "Invalid tag #{tag.inspect}"
         end
         case tag
         when /^\w+/; pos << tag
         when /^!\w+/; neg << tag.sub("!", '')
         else
           raise Puppet::Error, "Invalid tag '#{tag}'"
         end
       end
 
       # Now split the emails
       emails = emails.sub(/\s+$/,'').split(/\s*,\s*/)
       taglists << [emails, pos, neg]
     end
     taglists
   end
 
   # Process the report.  This just calls the other associated messages.
   def process
     unless FileTest.exists?(Puppet[:tagmap])
       Puppet.notice "Cannot send tagmail report; no tagmap file #{Puppet[:tagmap]}"
       return
     end
 
     taglists = parse(File.read(Puppet[:tagmap]))
 
     # Now find any appropriately tagged messages.
     reports = match(taglists)
 
     send(reports)
   end
 
   # Send the email reports.
   def send(reports)
     pid = fork do
       if Puppet[:smtpserver] != "none"
         begin
           Net::SMTP.start(Puppet[:smtpserver]) do |smtp|
             reports.each do |emails, messages|
               smtp.open_message_stream(Puppet[:reportfrom], *emails) do |p|
                 p.puts "From: #{Puppet[:reportfrom]}"
                 p.puts "Subject: Puppet Report for #{self.host}"
                 p.puts "To: " + emails.join(", ")
                 p.puts "Date: #{Time.now.rfc2822}"
                 p.puts
                 p.puts messages
               end
             end
           end
         rescue => detail
           puts detail.backtrace if Puppet[:debug]
           raise Puppet::Error,
             "Could not send report emails through smtp: #{detail}"
         end
       elsif Puppet[:sendmail] != ""
         begin
           reports.each do |emails, messages|
             # We need to open a separate process for every set of email addresses
             IO.popen(Puppet[:sendmail] + " " + emails.join(" "), "w") do |p|
               p.puts "From: #{Puppet[:reportfrom]}"
               p.puts "Subject: Puppet Report for #{self.host}"
               p.puts "To: " + emails.join(", ")
 
               p.puts messages
             end
           end
         rescue => detail
           puts detail.backtrace if Puppet[:debug]
           raise Puppet::Error,
             "Could not send report emails via sendmail: #{detail}"
         end
       else
         raise Puppet::Error, "SMTP server is unset and could not find sendmail"
       end
     end
 
     # Don't bother waiting for the pid to return.
     Process.detach(pid)
   end
 end
 
diff --git a/lib/puppet/util/reference.rb b/lib/puppet/util/reference.rb
index 4f2058e69..99458aa57 100644
--- a/lib/puppet/util/reference.rb
+++ b/lib/puppet/util/reference.rb
@@ -1,158 +1,158 @@
 require 'puppet/util/instance_loader'
 require 'fileutils'
 
 # Manage Reference Documentation.
 class Puppet::Util::Reference
   include Puppet::Util
   include Puppet::Util::Docs
 
   extend Puppet::Util::InstanceLoader
 
   instance_load(:reference, 'puppet/reference')
 
   def self.footer
     "\n\n----------------\n\n*This page autogenerated on #{Time.now}*\n"
   end
 
   def self.modes
     %w{pdf text}
   end
 
   def self.newreference(name, options = {}, &block)
     ref = self.new(name, options, &block)
     instance_hash(:reference)[symbolize(name)] = ref
 
     ref
   end
 
   def self.page(*sections)
     depth = 4
     # Use the minimum depth
     sections.each do |name|
       section = reference(name) or raise "Could not find section #{name}"
       depth = section.depth if section.depth < depth
     end
-    text = "{:toc}\n\n"
+    text = "* TOC text.\n{:toc}\n\n"
   end
 
   def self.pdf(text)
     puts "creating pdf"
     Puppet::Util.secure_open("/tmp/puppetdoc.txt", "w") do |f|
       f.puts text
     end
     rst2latex = %x{which rst2latex}
     if $CHILD_STATUS != 0 or rst2latex =~ /no /
       rst2latex = %x{which rst2latex.py}
     end
     if $CHILD_STATUS != 0 or rst2latex =~ /no /
       raise "Could not find rst2latex"
     end
     rst2latex.chomp!
     cmd = %{#{rst2latex} /tmp/puppetdoc.txt > /tmp/puppetdoc.tex}
     Puppet::Util.secure_open("/tmp/puppetdoc.tex","w") do |f|
       # If we get here without an error, /tmp/puppetdoc.tex isn't a tricky cracker's symlink
     end
     output = %x{#{cmd}}
     unless $CHILD_STATUS == 0
       $stderr.puts "rst2latex failed"
       $stderr.puts output
       exit(1)
     end
     $stderr.puts output
 
     # Now convert to pdf
     Dir.chdir("/tmp") do
       %x{texi2pdf puppetdoc.tex >/dev/null 2>/dev/null}
     end
 
   end
 
   def self.references
     instance_loader(:reference).loadall
     loaded_instances(:reference).sort { |a,b| a.to_s <=> b.to_s }
   end
 
-  HEADER_LEVELS = [nil, "=", "-", "+", "'", "~"]
+  HEADER_LEVELS = [nil, "#", "##", "###", "####", "#####"]
 
   attr_accessor :page, :depth, :header, :title, :dynamic
   attr_writer :doc
 
   def doc
     if defined?(@doc)
       return "#{@name} - #{@doc}"
     else
       return @title
     end
   end
 
   def dynamic?
     self.dynamic
   end
 
   def h(name, level)
-    "#{name}\n#{HEADER_LEVELS[level] * name.to_s.length}\n\n"
+    "#{HEADER_LEVELS[level]} #{name}\n\n"
   end
 
   def initialize(name, options = {}, &block)
     @name = name
     options.each do |option, value|
       send(option.to_s + "=", value)
     end
 
     meta_def(:generate, &block)
 
     # Now handle the defaults
     @title ||= "#{@name.to_s.capitalize} Reference"
     @page ||= @title.gsub(/\s+/, '')
     @depth ||= 2
     @header ||= ""
   end
 
   # Indent every line in the chunk except those which begin with '..'.
   def indent(text, tab)
     text.gsub(/(^|\A)/, tab).gsub(/^ +\.\./, "..")
   end
 
   def option(name, value)
     ":#{name.to_s.capitalize}: #{value}\n"
   end
 
   def paramwrap(name, text, options = {})
     options[:level] ||= 5
     #str = "#{name} : "
     str = h(name, options[:level])
     str += "- **namevar**\n\n" if options[:namevar]
     str += text
     #str += text.gsub(/\n/, "\n    ")
 
     str += "\n\n"
   end
 
   # Remove all trac links.
   def strip_trac(text)
     text.gsub(/`\w+\s+([^`]+)`:trac:/) { |m| $1 }
   end
 
   def text
     puts output
   end
 
   def to_rest(withcontents = true)
     # First the header
     text = h(@title, 1)
     text += "\n\n**This page is autogenerated; any changes will get overwritten** *(last generated on #{Time.now.to_s})*\n\n"
-    text +=  "{:toc}\n\n" if withcontents
+    text +=  "* TOC Text.\n{:toc}\n\n" if withcontents
 
     text += @header
 
     text += generate
 
     text += self.class.footer if withcontents
 
     text
   end
 
   def to_text(withcontents = true)
     strip_trac(to_rest(withcontents))
   end
 end
diff --git a/spec/unit/reports/tagmail_spec.rb b/spec/unit/reports/tagmail_spec.rb
index 59cb5b2b8..bdb16600e 100755
--- a/spec/unit/reports/tagmail_spec.rb
+++ b/spec/unit/reports/tagmail_spec.rb
@@ -1,94 +1,95 @@
 #!/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/reports'
 require 'puppettest/support/utils'
 
 tagmail = Puppet::Reports.report(:tagmail)
 
 describe tagmail do
   extend PuppetTest::Support::Utils
 
   before do
     @processor = Puppet::Transaction::Report.new
     @processor.extend(Puppet::Reports.report(:tagmail))
   end
 
   passers = File.join(datadir, "reports", "tagmail_passers.conf")
   File.readlines(passers).each do |line|
     it "should be able to parse '#{line.inspect}'" do
       @processor.parse(line)
     end
   end
 
   failers = File.join(datadir, "reports", "tagmail_failers.conf")
   File.readlines(failers).each do |line|
     it "should not be able to parse '#{line.inspect}'" do
       lambda { @processor.parse(line) }.should raise_error(ArgumentError)
     end
   end
 
   {
     "tag: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag}, []],
+    "tag.localhost: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag.localhost}, []],
     "tag, other: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag other}, []],
     "tag-other: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag-other}, []],
     "tag, !other: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag}, %w{other}],
     "tag, !other, one, !two: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag one}, %w{other two}],
     "tag: abuse@domain.com, other@domain.com" => [%w{abuse@domain.com other@domain.com}, %w{tag}, []]
 
   }.each do |line, results|
     it "should parse '#{line}' as #{results.inspect}" do
       @processor.parse(line).shift.should == results
     end
   end
 
   describe "when matching logs" do
     before do
       @processor << Puppet::Util::Log.new(:level => :notice, :message => "first", :tags => %w{one})
       @processor << Puppet::Util::Log.new(:level => :notice, :message => "second", :tags => %w{one two})
       @processor << Puppet::Util::Log.new(:level => :notice, :message => "third", :tags => %w{one two three})
     end
 
     def match(pos = [], neg = [])
       pos = Array(pos)
       neg = Array(neg)
       result = @processor.match([[%w{abuse@domain.com}, pos, neg]])
       actual_result = result.shift
       if actual_result
         actual_result[1]
       else
         nil
       end
     end
 
     it "should match all messages when provided the 'all' tag as a positive matcher" do
       results = match("all")
       %w{first second third}.each do |str|
         results.should be_include(str)
       end
     end
 
     it "should remove messages that match a negated tag" do
       match("all", "three").should_not be_include("third")
     end
 
     it "should find any messages tagged with a provided tag" do
       results = match("two")
       results.should be_include("second")
       results.should be_include("third")
       results.should_not be_include("first")
     end
 
     it "should allow negation of specific tags from a specific tag list" do
       results = match("two", "three")
       results.should be_include("second")
       results.should_not be_include("third")
     end
 
     it "should allow a tag to negate all matches" do
       results = match([], "one")
       results.should be_nil
     end
   end
 end