diff --git a/lib/puppet/provider.rb b/lib/puppet/provider.rb
index 4456feb4e..452f5196a 100644
--- a/lib/puppet/provider.rb
+++ b/lib/puppet/provider.rb
@@ -1,281 +1,281 @@
 # The container class for implementations.
 class Puppet::Provider
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Util::Warnings
   extend Puppet::Util::Warnings
 
   require 'puppet/provider/confiner'
 
   extend Puppet::Provider::Confiner
 
   Puppet::Util.logmethods(self, true)
 
   class << self
     # Include the util module so we have access to things like 'which'
     include Puppet::Util, Puppet::Util::Docs
     include Puppet::Util::Logging
     attr_accessor :name
 
     # The source parameter exists so that providers using the same
     # source can specify this, so reading doesn't attempt to read the
     # same package multiple times.
     attr_writer :source
 
     # LAK 2007-05-09: Keep the model stuff around for backward compatibility
     attr_reader :model
     attr_accessor :resource_type
     attr_writer :doc
   end
 
   # LAK 2007-05-09: Keep the model stuff around for backward compatibility
   attr_reader :model
   attr_accessor :resource
 
   def self.command(name)
     name = symbolize(name)
 
     if defined?(@commands) and command = @commands[name]
       # nothing
     elsif superclass.respond_to? :command and command = superclass.command(name)
       # nothing
     else
       raise Puppet::DevError, "No command #{name} defined for provider #{self.name}"
     end
 
     which(command)
   end
 
   # Define commands that are not optional.
   def self.commands(hash)
     optional_commands(hash) do |name, path|
       confine :exists => path, :for_binary => true
     end
   end
 
   # Is the provided feature a declared feature?
   def self.declared_feature?(name)
     defined?(@declared_features) and @declared_features.include?(name)
   end
 
   # Does this implementation match all of the default requirements?  If
   # defaults are empty, we return false.
   def self.default?
     return false if @defaults.empty?
     if @defaults.find do |fact, values|
         values = [values] unless values.is_a? Array
         if fval = Facter.value(fact).to_s and fval != ""
           fval = fval.to_s.downcase.intern
         else
           return false
         end
 
         # If any of the values match, we're a default.
         if values.find do |value| fval == value.to_s.downcase.intern end
           false
         else
           true
         end
       end
       return false
     else
       return true
     end
   end
 
   # Store how to determine defaults.
   def self.defaultfor(hash)
     hash.each do |d,v|
       @defaults[d] = v
     end
   end
 
   def self.specificity
     (@defaults.length * 100) + ancestors.select { |a| a.is_a? Class }.length
   end
 
   def self.initvars
     @defaults = {}
     @commands = {}
   end
 
   # The method for returning a list of provider instances.  Note that it returns providers, preferably with values already
   # filled in, not resources.
   def self.instances
     raise Puppet::DevError, "Provider #{self.name} has not defined the 'instances' class method"
   end
 
   # Create the methods for a given command.
   def self.make_command_methods(name)
     # Now define a method for that command
     unless singleton_class.method_defined?(name)
       meta_def(name) do |*args|
         raise Puppet::Error, "Command #{name} is missing" unless command(name)
         if args.empty?
           cmd = [command(name)]
         else
           cmd = [command(name)] + args
         end
         # This might throw an ExecutionFailure, but the system above
         # will catch it, if so.
         return execute(cmd)
       end
 
       # And then define an instance method that just calls the class method.
       # We need both, so both instances and classes can easily run the commands.
       unless method_defined?(name)
         define_method(name) do |*args|
           self.class.send(name, *args)
         end
       end
     end
   end
 
   # Create getter/setter methods for each property our resource type supports.
   # They all get stored in @property_hash.  This method is useful
   # for those providers that use prefetch and flush.
   def self.mkmodelmethods
     warnonce "Provider.mkmodelmethods is deprecated; use Provider.mk_resource_methods"
     mk_resource_methods
   end
 
   # Create getter/setter methods for each property our resource type supports.
   # They all get stored in @property_hash.  This method is useful
   # for those providers that use prefetch and flush.
   def self.mk_resource_methods
     [resource_type.validproperties, resource_type.parameters].flatten.each do |attr|
       attr = symbolize(attr)
       next if attr == :name
       define_method(attr) do
         @property_hash[attr] || :absent
       end
 
       define_method(attr.to_s + "=") do |val|
         @property_hash[attr] = val
       end
     end
   end
 
   self.initvars
 
   # Define one or more binaries we'll be using.  If a block is passed, yield the name
   # and path to the block (really only used by 'commands').
   def self.optional_commands(hash)
     hash.each do |name, path|
       name = symbolize(name)
       @commands[name] = path
 
       yield(name, path) if block_given?
 
       # Now define the class and instance methods.
       make_command_methods(name)
     end
   end
 
   # Retrieve the data source.  Defaults to the provider name.
   def self.source
     @source ||= self.name
   end
 
   # Does this provider support the specified parameter?
   def self.supports_parameter?(param)
     if param.is_a?(Class)
       klass = param
     else
       unless klass = resource_type.attrclass(param)
         raise Puppet::DevError, "'#{param}' is not a valid parameter for #{resource_type.name}"
       end
     end
     return true unless features = klass.required_features
 
     !!satisfies?(*features)
   end
 
 #    def self.to_s
 #        unless defined?(@str)
 #            if self.resource_type
 #                @str = "#{resource_type.name} provider #{self.name}"
 #            else
 #                @str = "unattached provider #{self.name}"
 #            end
 #        end
 #        @str
 #    end
 
   dochook(:defaults) do
     if @defaults.length > 0
-      return "  Default for " + @defaults.collect do |f, v|
+      return "Default for " + @defaults.collect do |f, v|
         "`#{f}` == `#{v}`"
       end.join(" and ") + "."
     end
   end
 
   dochook(:commands) do
     if @commands.length > 0
-      return "  Required binaries: " + @commands.collect do |n, c|
+      return "Required binaries: " + @commands.collect do |n, c|
         "`#{c}`"
       end.join(", ") + "."
     end
   end
 
   dochook(:features) do
     if features.length > 0
-      return "  Supported features: " + features.collect do |f|
+      return "Supported features: " + features.collect do |f|
         "`#{f}`"
       end.join(", ") + "."
     end
   end
 
   # Remove the reference to the resource, so GC can clean up.
   def clear
     @resource = nil
     @model = nil
   end
 
   # Retrieve a named command.
   def command(name)
     self.class.command(name)
   end
 
   # Get a parameter value.
   def get(param)
     @property_hash[symbolize(param)] || :absent
   end
 
   def initialize(resource = nil)
     if resource.is_a?(Hash)
       # We don't use a duplicate here, because some providers (ParsedFile, at least)
       # use the hash here for later events.
       @property_hash = resource
     elsif resource
       @resource = resource
       # LAK 2007-05-09: Keep the model stuff around for backward compatibility
       @model = resource
       @property_hash = {}
     else
       @property_hash = {}
     end
   end
 
   def name
     if n = @property_hash[:name]
       return n
     elsif self.resource
       resource.name
     else
       raise Puppet::DevError, "No resource and no name in property hash in #{self.class.name} instance"
     end
   end
 
   # Set passed params as the current values.
   def set(params)
     params.each do |param, value|
       @property_hash[symbolize(param)] = value
     end
   end
 
   def to_s
     "#{@resource}(provider=#{self.class.name})"
   end
 end
 
diff --git a/lib/puppet/util/docs.rb b/lib/puppet/util/docs.rb
index c3d897558..0a7c9bce8 100644
--- a/lib/puppet/util/docs.rb
+++ b/lib/puppet/util/docs.rb
@@ -1,123 +1,123 @@
 # Some simple methods for helping manage automatic documentation generation.
 module Puppet::Util::Docs
   # Specify the actual doc string.
   def desc(str)
     @doc = str
   end
 
   # Add a new autodoc block.  We have to define these as class methods,
   # rather than just sticking them in a hash, because otherwise they're
   # too difficult to do inheritance with.
   def dochook(name, &block)
     method = "dochook_#{name}"
 
     meta_def method, &block
   end
 
   attr_writer :doc
 
   # Generate the full doc string.
   def doc
     extra = methods.find_all { |m| m.to_s =~ /^dochook_.+/ }.sort.collect { |m|
       self.send(m)
-    }.join("  ")
+    }.delete_if {|r| r.nil? }.join("  ")
 
     if @doc
-      @doc + extra
+      @doc + (extra.empty? ? '' : "\n\n" + extra)
     else
       extra
     end
   end
 
   # Build a table
   def doctable(headers, data)
     str = "\n\n"
 
     lengths = []
     # Figure out the longest field for all columns
     data.each do |name, values|
       [name, values].flatten.each_with_index do |value, i|
         lengths[i] ||= 0
         lengths[i] = value.to_s.length if value.to_s.length > lengths[i]
       end
     end
 
     # The headers could also be longest
     headers.each_with_index do |value, i|
       lengths[i] = value.to_s.length if value.to_s.length > lengths[i]
     end
 
     # Add the header names
     str += headers.zip(lengths).collect { |value, num| pad(value, num) }.join(" | ") + " |" + "\n"
 
     # And the header row
     str += lengths.collect { |num| "-" * num }.join(" | ") + " |" + "\n"
 
     # Now each data row
     data.sort { |a, b| a[0].to_s <=> b[0].to_s }.each do |name, rows|
       str += [name, rows].flatten.zip(lengths).collect do |value, length|
         pad(value, length)
       end.join(" | ") + " |" + "\n"
     end
 
     str + "\n"
   end
 
   attr_reader :nodoc
   def nodoc?
     nodoc
   end
 
   # Pad a field with spaces
   def pad(value, length)
     value.to_s + (" " * (length - value.to_s.length))
   end
 
   HEADER_LEVELS = [nil, "#", "##", "###", "####", "#####"]
 
   def markdown_header(name, level)
     "#{HEADER_LEVELS[level]} #{name}\n\n"
   end
 
   def markdown_definitionlist(term, definition)
     lines = scrub(definition).split("\n")
     str = "#{term}\n: #{lines.shift}\n"
     lines.each do |line|
       str << "  " if line =~ /\S/
       str << "#{line}\n"
     end
     str << "\n"
   end
 
   # Handle the inline indentation in the docs.
   def scrub(text)
     # Stupid markdown
     #text = text.gsub("<%=", "&lt;%=")
     # For text with no carriage returns, there's nothing to do.
     return text if text !~ /\n/
     indent = nil
 
     # If we can match an indentation, then just remove that same level of
     # indent from every line.  However, ignore any indentation on the
     # first line, since that can be inconsistent.
     text = text.lstrip
     text.gsub!(/^([\t]+)/) { |s| " "*8*s.length; } # Expand leading tabs
     # Find first non-empty line after the first line:
     line2start = (text =~ /(\n?\s*\n)/)
     line2start += $1.length
     if (text[line2start..-1] =~ /^([ ]+)\S/) == 0
       indent = Regexp.quote($1)
       begin
         return text.gsub(/^#{indent}/,'')
       rescue => detail
         puts detail.backtrace
         puts detail
       end
     else
       return text
     end
 
   end
 
   module_function :scrub
 end