diff --git a/lib/puppet/interface.rb b/lib/puppet/interface.rb
index 10e2ec8d7..6be8b6930 100644
--- a/lib/puppet/interface.rb
+++ b/lib/puppet/interface.rb
@@ -1,175 +1,156 @@
 require 'puppet'
 require 'puppet/util/autoload'
 require 'puppet/interface/documentation'
 require 'prettyprint'
 
 class Puppet::Interface
   include FullDocs
 
   require 'puppet/interface/face_collection'
 
   require 'puppet/interface/action_manager'
   include Puppet::Interface::ActionManager
   extend Puppet::Interface::ActionManager
 
   require 'puppet/interface/option_manager'
   include Puppet::Interface::OptionManager
   extend Puppet::Interface::OptionManager
 
   include Puppet::Util
 
   class << self
     # This is just so we can search for actions.  We only use its
     # list of directories to search.
     # Can't we utilize an external autoloader, or simply use the $LOAD_PATH? -pvb
     def autoloader
       @autoloader ||= Puppet::Util::Autoload.new(:application, "puppet/face")
     end
 
     def faces
       Puppet::Interface::FaceCollection.faces
     end
 
     def register(instance)
       Puppet::Interface::FaceCollection.register(instance)
     end
 
     def define(name, version, &block)
       face = Puppet::Interface::FaceCollection[name, version]
       if face.nil? then
         face = self.new(name, version)
         Puppet::Interface::FaceCollection.register(face)
         # REVISIT: Shouldn't this be delayed until *after* we evaluate the
         # current block, not done before? --daniel 2011-04-07
         face.load_actions
       end
 
       face.instance_eval(&block) if block_given?
 
       return face
     end
 
     def face?(name, version)
       Puppet::Interface::FaceCollection[name, version]
     end
 
     def [](name, version)
       unless face = Puppet::Interface::FaceCollection[name, version]
         if current = Puppet::Interface::FaceCollection[name, :current]
           raise Puppet::Error, "Could not find version #{version} of #{name}"
         else
           raise Puppet::Error, "Could not find Puppet Face #{name.inspect}"
         end
       end
       face
     end
   end
 
   def set_default_format(format)
     Puppet.warning("set_default_format is deprecated (and ineffective); use render_as on your actions instead.")
   end
 
 
   ########################################################################
   # Documentation.  We currently have to rewrite both getters because we share
   # the same instance between build-time and the runtime instance.  When that
   # splits out this should merge into a module that both the action and face
   # include. --daniel 2011-04-17
   def synopsis
-    output = PrettyPrint.format do |s|
-      s.text("puppet #{name} <action>")
-      s.breakable
-
-      options.each do |option|
-        option = get_option(option)
-        wrap = option.required? ? %w{ < > } : %w{ [ ] }
-
-        s.group(0, *wrap) do
-          option.optparse.each do |item|
-            unless s.current_group.first?
-              s.breakable
-              s.text '|'
-              s.breakable
-            end
-            s.text item
-          end
-        end
-      end
-    end
+    build_synopsis self.name, '<action>'
   end
 
 
   ########################################################################
   attr_reader :name, :version
 
   def initialize(name, version, &block)
     unless Puppet::Interface::FaceCollection.validate_version(version)
       raise ArgumentError, "Cannot create face #{name.inspect} with invalid version number '#{version}'!"
     end
 
     @name    = Puppet::Interface::FaceCollection.underscorize(name)
     @version = version
 
     # The few bits of documentation we actually demand.  The default license
     # is a favour to our end users; if you happen to get that in a core face
     # report it as a bug, please. --daniel 2011-04-26
     @authors  = []
     @license  = 'All Rights Reserved'
 
     instance_eval(&block) if block_given?
   end
 
   # Try to find actions defined in other files.
   def load_actions
     Puppet::Interface.autoloader.search_directories.each do |dir|
       Dir.glob(File.join(dir, "puppet/face/#{name}", "*.rb")).each do |file|
         action = file.sub(dir, '').sub(/^[\\\/]/, '').sub(/\.rb/, '')
         Puppet.debug "Loading action '#{action}' for '#{name}' from '#{dir}/#{action}.rb'"
         require(action)
       end
     end
   end
 
   def to_s
     "Puppet::Face[#{name.inspect}, #{version.inspect}]"
   end
 
   ########################################################################
   # Action decoration, whee!  You are not expected to care about this code,
   # which exists to support face building and construction.  I marked these
   # private because the implementation is crude and ugly, and I don't yet know
   # enough to work out how to make it clean.
   #
   # Once we have established that these methods will likely change radically,
   # to be unrecognizable in the final outcome.  At which point we will throw
   # all this away, replace it with something nice, and work out if we should
   # be making this visible to the outside world... --daniel 2011-04-14
   private
   def __invoke_decorations(type, action, passed_args = [], passed_options = {})
     [:before, :after].member?(type) or fail "unknown decoration type #{type}"
 
     # Collect the decoration methods matching our pass.
     methods = action.options.select do |name|
       passed_options.has_key? name
     end.map do |name|
       action.get_option(name).__decoration_name(type)
     end
 
     methods.reverse! if type == :after
 
     # Exceptions here should propagate up; this implements a hook we can use
     # reasonably for option validation.
     methods.each do |hook|
       respond_to? hook and self.__send__(hook, action, passed_args, passed_options)
     end
   end
 
   def __add_method(name, proc)
     meta_def(name, &proc)
     method(name).unbind
   end
   def self.__add_method(name, proc)
     define_method(name, proc)
     instance_method(name)
   end
 end
diff --git a/lib/puppet/interface/action.rb b/lib/puppet/interface/action.rb
index 748888c2e..185302b07 100644
--- a/lib/puppet/interface/action.rb
+++ b/lib/puppet/interface/action.rb
@@ -1,305 +1,284 @@
 require 'puppet/interface'
 require 'puppet/interface/documentation'
 require 'prettyprint'
 
 class Puppet::Interface::Action
   extend Puppet::Interface::DocGen
   include Puppet::Interface::FullDocs
 
   def initialize(face, name, attrs = {})
     raise "#{name.inspect} is an invalid action name" unless name.to_s =~ /^[a-z]\w*$/
     @face    = face
     @name    = name.to_sym
 
     # The few bits of documentation we actually demand.  The default license
     # is a favour to our end users; if you happen to get that in a core face
     # report it as a bug, please. --daniel 2011-04-26
     @authors = []
     @license  = 'All Rights Reserved'
 
     attrs.each do |k, v| send("#{k}=", v) end
 
     # @options collects the added options in the order they're declared.
     # @options_hash collects the options keyed by alias for quick lookups.
     @options        = []
     @options_hash   = {}
     @when_rendering = {}
   end
 
   # This is not nice, but it is the easiest way to make us behave like the
   # Ruby Method object rather than UnboundMethod.  Duplication is vaguely
   # annoying, but at least we are a shallow clone. --daniel 2011-04-12
   def __dup_and_rebind_to(to)
     bound_version = self.dup
     bound_version.instance_variable_set(:@face, to)
     return bound_version
   end
 
   def to_s() "#{@face}##{@name}" end
 
   attr_reader   :name
   attr_accessor :default
   def default?
     !!@default
   end
 
   ########################################################################
   # Documentation...
   attr_doc :returns
   attr_doc :arguments
   def synopsis
-    output = PrettyPrint.format do |s|
-      s.text("puppet #{@face.name}")
-      s.text(" #{name}") unless default?
-      s.breakable
-
-      options.each do |option|
-        option = get_option(option)
-        wrap = option.required? ? %w{ < > } : %w{ [ ] }
-
-        s.group(0, *wrap) do
-          option.optparse.each do |item|
-            unless s.current_group.first?
-              s.breakable
-              s.text '|'
-              s.breakable
-            end
-            s.text item
-          end
-        end
-      end
-      s.text(" #{arguments}") if arguments
-    end
+    build_synopsis(@face.name, default? ? nil : name, arguments)
   end
 
   ########################################################################
   # Support for rendering formats and all.
   def when_rendering(type)
     unless type.is_a? Symbol
       raise ArgumentError, "The rendering format must be a symbol, not #{type.class.name}"
     end
     # Do we have a rendering hook for this name?
     return @when_rendering[type].bind(@face) if @when_rendering.has_key? type
 
     # How about by another name?
     alt = type.to_s.sub(/^to_/, '').to_sym
     return @when_rendering[alt].bind(@face) if @when_rendering.has_key? alt
 
     # Guess not, nothing to run.
     return nil
   end
   def set_rendering_method_for(type, proc)
     unless proc.is_a? Proc
       msg = "The second argument to set_rendering_method_for must be a Proc"
       msg += ", not #{proc.class.name}" unless proc.nil?
       raise ArgumentError, msg
     end
     if proc.arity != 1 then
       msg = "when_rendering methods take one argument, the result, not "
       if proc.arity < 0 then
         msg += "a variable number"
       else
         msg += proc.arity.to_s
       end
       raise ArgumentError, msg
     end
     unless type.is_a? Symbol
       raise ArgumentError, "The rendering format must be a symbol, not #{type.class.name}"
     end
     if @when_rendering.has_key? type then
       raise ArgumentError, "You can't define a rendering method for #{type} twice"
     end
     # Now, the ugly bit.  We add the method to our interface object, and
     # retrieve it, to rotate through the dance of getting a suitable method
     # object out of the whole process. --daniel 2011-04-18
     @when_rendering[type] =
       @face.__send__( :__add_method, __render_method_name_for(type), proc)
   end
 
   def __render_method_name_for(type)
     :"#{name}_when_rendering_#{type}"
   end
   private :__render_method_name_for
 
 
   attr_accessor :render_as
   def render_as=(value)
     @render_as = value.to_sym
   end
 
 
   ########################################################################
   # Initially, this was defined to allow the @action.invoke pattern, which is
   # a very natural way to invoke behaviour given our introspection
   # capabilities.   Heck, our initial plan was to have the faces delegate to
   # the action object for invocation and all.
   #
   # It turns out that we have a binding problem to solve: @face was bound to
   # the parent class, not the subclass instance, and we don't pass the
   # appropriate context or change the binding enough to make this work.
   #
   # We could hack around it, by either mandating that you pass the context in
   # to invoke, or try to get the binding right, but that has probably got
   # subtleties that we don't instantly think of – especially around threads.
   #
   # So, we are pulling this method for now, and will return it to life when we
   # have the time to resolve the problem.  For now, you should replace...
   #
   #     @action = @face.get_action(name)
   #     @action.invoke(arg1, arg2, arg3)
   #
   # ...with...
   #
   #     @action = @face.get_action(name)
   #     @face.send(@action.name, arg1, arg2, arg3)
   #
   # I understand that is somewhat cumbersome, but it functions as desired.
   # --daniel 2011-03-31
   #
   # PS: This code is left present, but commented, to support this chunk of
   # documentation, for the benefit of the reader.
   #
   # def invoke(*args, &block)
   #   @face.send(name, *args, &block)
   # end
 
 
   # We need to build an instance method as a wrapper, using normal code, to be
   # able to expose argument defaulting between the caller and definer in the
   # Ruby API.  An extra method is, sadly, required for Ruby 1.8 to work since
   # it doesn't expose bind on a block.
   #
   # Hopefully we can improve this when we finally shuffle off the last of Ruby
   # 1.8 support, but that looks to be a few "enterprise" release eras away, so
   # we are pretty stuck with this for now.
   #
   # Patches to make this work more nicely with Ruby 1.9 using runtime version
   # checking and all are welcome, provided that they don't change anything
   # outside this little ol' bit of code and all.
   #
   # Incidentally, we though about vendoring evil-ruby and actually adjusting
   # the internal C structure implementation details under the hood to make
   # this stuff work, because it would have been cleaner.  Which gives you an
   # idea how motivated we were to make this cleaner.  Sorry.
   # --daniel 2011-03-31
   attr_reader   :positional_arg_count
   attr_accessor :when_invoked
   def when_invoked=(block)
 
     internal_name = "#{@name} implementation, required on Ruby 1.8".to_sym
 
     arity = @positional_arg_count = block.arity
     if arity == 0 then
       # This will never fire on 1.8.7, which treats no arguments as "*args",
       # but will on 1.9.2, which treats it as "no arguments".  Which bites,
       # because this just begs for us to wind up in the horrible situation
       # where a 1.8 vs 1.9 error bites our end users. --daniel 2011-04-19
       raise ArgumentError, "when_invoked requires at least one argument (options) for action #{@name}"
     elsif arity > 0 then
       range = Range.new(1, arity - 1)
       decl = range.map { |x| "arg#{x}" } << "options = {}"
       optn = ""
       args = "[" + (range.map { |x| "arg#{x}" } << "options").join(", ") + "]"
     else
       range = Range.new(1, arity.abs - 1)
       decl = range.map { |x| "arg#{x}" } << "*rest"
       optn = "rest << {} unless rest.last.is_a?(Hash)"
       if arity == -1 then
         args = "rest"
       else
         args = "[" + range.map { |x| "arg#{x}" }.join(", ") + "] + rest"
       end
     end
 
     file    = __FILE__ + "+eval[wrapper]"
     line    = __LINE__ + 2 # <== points to the same line as 'def' in the wrapper.
     wrapper = <<WRAPPER
 def #{@name}(#{decl.join(", ")})
   #{optn}
   args = #{args}
   options = args.last
 
   action = get_action(#{name.inspect})
   action.validate_args(args)
   __invoke_decorations(:before, action, args, options)
   rval = self.__send__(#{internal_name.inspect}, *args)
   __invoke_decorations(:after, action, args, options)
   return rval
 end
 WRAPPER
 
     if @face.is_a?(Class)
       @face.class_eval do eval wrapper, nil, file, line end
       @face.define_method(internal_name, &block)
       @when_invoked = @face.instance_method(name)
     else
       @face.instance_eval do eval wrapper, nil, file, line end
       @face.meta_def(internal_name, &block)
       @when_invoked = @face.method(name).unbind
     end
   end
 
   def add_option(option)
     option.aliases.each do |name|
       if conflict = get_option(name) then
         raise ArgumentError, "Option #{option} conflicts with existing option #{conflict}"
       elsif conflict = @face.get_option(name) then
         raise ArgumentError, "Option #{option} conflicts with existing option #{conflict} on #{@face}"
       end
     end
 
     option.aliases.each do |name|
       @options << name
       @options_hash[name] = option
     end
 
     option
   end
 
   def option?(name)
     @options_hash.include? name.to_sym
   end
 
   def options
     @face.options + @options
   end
 
   def get_option(name, with_inherited_options = true)
     option = @options_hash[name.to_sym]
     if option.nil? and with_inherited_options
       option = @face.get_option(name)
     end
     option
   end
 
   def validate_args(args)
     # Check for multiple aliases for the same option...
     args.last.keys.each do |name|
       # #7290: If this isn't actually an option, ignore it for now.  We should
       # probably fail, but that wasn't our API, and I don't want to perturb
       # behaviour this late in the RC cycle. --daniel 2011-04-29
       if option = get_option(name) then
         overlap = (option.aliases & args.last.keys)
         unless overlap.length == 1 then
           raise ArgumentError, "Multiple aliases for the same option passed: #{overlap.join(', ')}"
         end
       end
     end
 
     # Check for missing mandatory options.
     required = options.map do |name|
       get_option(name)
     end.select(&:required?).collect(&:name) - args.last.keys
 
     return if required.empty?
     raise ArgumentError, "The following options are required: #{required.join(', ')}"
   end
 
   ########################################################################
   # Support code for action decoration; see puppet/interface.rb for the gory
   # details of why this is hidden away behind private. --daniel 2011-04-15
   private
   def __add_method(name, proc)
     @face.__send__ :__add_method, name, proc
   end
 end
diff --git a/lib/puppet/interface/documentation.rb b/lib/puppet/interface/documentation.rb
index fcaec2568..47e478a44 100644
--- a/lib/puppet/interface/documentation.rb
+++ b/lib/puppet/interface/documentation.rb
@@ -1,199 +1,230 @@
 # This isn't usable outside Puppet::Interface; don't load it alone.
 class Puppet::Interface
   module DocGen
     def self.strip_whitespace(text)
       text.gsub!(/[ \t\f]+$/, '')
 
       # We need to identify an indent: the minimum number of whitespace
       # characters at the start of any line in the text.
       #
       # Using split rather than each_line is because the later only takes a
       # block on Ruby 1.8.5 / Centos, and we support that. --daniel 2011-05-03
       indent = text.split(/\n/).map {|x| x.index(/[^\s]/) }.compact.min
 
       if indent > 0 then
         text.gsub!(/^[ \t\f]{0,#{indent}}/, '')
       end
 
       return text
     end
 
     # The documentation attributes all have some common behaviours; previously
     # we open-coded them across the set of six things, but that seemed
     # wasteful - especially given that they were literally the same, and had
     # the same bug hidden in them.
     #
     # This feels a bit like overkill, but at least the common code is common
     # now. --daniel 2011-04-29
     def attr_doc(name, &validate)
       # Now, which form of the setter do we want, validated or not?
       get_arg = "value.to_s"
       if validate
         define_method(:"_validate_#{name}", validate)
         get_arg = "_validate_#{name}(#{get_arg})"
       end
 
       # We use module_eval, which I don't like much, because we can't have an
       # argument to a block with a default value in Ruby 1.8, and I don't like
       # the side-effects (eg: no argument count validation) of using blocks
       # without as metheds.  When we are 1.9 only (hah!) you can totally
       # replace this with some up-and-up define_method. --daniel 2011-04-29
       module_eval(<<-EOT, __FILE__, __LINE__ + 1)
         def #{name}(value = nil)
           self.#{name} = value unless value.nil?
           @#{name}
         end
 
         def #{name}=(value)
           @#{name} = Puppet::Interface::DocGen.strip_whitespace(#{get_arg})
         end
       EOT
     end
   end
 
   module TinyDocs
     extend Puppet::Interface::DocGen
 
     attr_doc :summary do |value|
       value =~ /\n/ and
         raise ArgumentError, "Face summary should be a single line; put the long text in 'description' instead."
       value
     end
 
     attr_doc :description
+
+    def build_synopsis(face, action = nil, arguments = nil)
+      output = PrettyPrint.format do |s|
+        s.text("puppet #{face}")
+        s.text(" #{action}") unless action.nil?
+        s.text(" ")
+
+        options.each do |option|
+          option = get_option(option)
+          wrap = option.required? ? %w{ < > } : %w{ [ ] }
+
+          s.group(0, *wrap) do
+            option.optparse.each do |item|
+              unless s.current_group.first?
+                s.breakable
+                s.text '|'
+                s.breakable
+              end
+              s.text item
+            end
+          end
+
+          s.breakable
+        end
+
+        if arguments then
+          s.text arguments.to_s
+        end
+      end
+    end
+
   end
 
   module FullDocs
     extend Puppet::Interface::DocGen
     include TinyDocs
 
     attr_doc :examples
     attr_doc :notes
     attr_doc :license
 
     attr_doc :short_description
     def short_description(value = nil)
       self.short_description = value unless value.nil?
       if @short_description.nil? then
         return nil if @description.nil?
         lines = @description.split("\n")
         first_paragraph_break = lines.index('') || 5
         grab  = [5, first_paragraph_break].min
         @short_description = lines[0, grab].join("\n")
         @short_description += ' [...]' if (grab < lines.length and first_paragraph_break >= 5)
       end
       @short_description
     end
 
     def author(value = nil)
       unless value.nil? then
         unless value.is_a? String
           raise ArgumentError, 'author must be a string; use multiple statements for multiple authors'
         end
 
         if value =~ /\n/ then
           raise ArgumentError, 'author should be a single line; use multiple statements for multiple authors'
         end
         @authors.push(Puppet::Interface::DocGen.strip_whitespace(value))
       end
       @authors.empty? ? nil : @authors.join("\n")
     end
     def authors
       @authors
     end
     def author=(value)
       if Array(value).any? {|x| x =~ /\n/ } then
         raise ArgumentError, 'author should be a single line; use multiple statements'
       end
       @authors = Array(value).map{|x| Puppet::Interface::DocGen.strip_whitespace(x) }
     end
     alias :authors= :author=
 
     def copyright(owner = nil, years = nil)
       if years.nil? and not owner.nil? then
         raise ArgumentError, 'copyright takes the owners names, then the years covered'
       end
       self.copyright_owner = owner unless owner.nil?
       self.copyright_years = years unless years.nil?
 
       if self.copyright_years or self.copyright_owner then
         "Copyright #{self.copyright_years} by #{self.copyright_owner}"
       else
         "Unknown copyright owner and years."
       end
     end
 
     attr_accessor :copyright_owner
     def copyright_owner=(value)
       case value
       when String then @copyright_owner = value
       when Array  then @copyright_owner = value.join(", ")
       else
         raise ArgumentError, "copyright owner must be a string or an array of strings"
       end
       @copyright_owner
     end
 
     attr_accessor :copyright_years
     def copyright_years=(value)
       years = munge_copyright_year value
       years = (years.is_a?(Array) ? years : [years]).
         sort_by do |x| x.is_a?(Range) ? x.first : x end
 
       @copyright_years = years.map do |year|
         if year.is_a? Range then
           "#{year.first}-#{year.last}"
         else
           year
         end
       end.join(", ")
     end
 
     def munge_copyright_year(input)
       case input
       when Range then input
       when Integer then
         if input < 1970 then
           fault = "before 1970"
         elsif input > (future = Time.now.year + 2) then
           fault = "after #{future}"
         end
         if fault then
           raise ArgumentError, "copyright with a year #{fault} is very strange; did you accidentally add or subtract two years?"
         end
 
         input
 
       when String then
         input.strip.split(/,/).map do |part|
           part = part.strip
           if part =~ /^\d+$/ then
             part.to_i
           elsif found = part.split(/-/) then
             unless found.length == 2 and found.all? {|x| x.strip =~ /^\d+$/ }
               raise ArgumentError, "#{part.inspect} is not a good copyright year or range"
             end
             Range.new(found[0].to_i, found[1].to_i)
           else
             raise ArgumentError, "#{part.inspect} is not a good copyright year or range"
           end
         end
 
       when Array then
         result = []
         input.each do |item|
           item = munge_copyright_year item
           if item.is_a? Array
             result.concat item
           else
             result << item
           end
         end
         result
 
       else
         raise ArgumentError, "#{input.inspect} is not a good copyright year, set, or range"
       end
     end
   end
 end
diff --git a/spec/unit/interface/documentation_spec.rb b/spec/unit/interface/documentation_spec.rb
new file mode 100755
index 000000000..6865b9073
--- /dev/null
+++ b/spec/unit/interface/documentation_spec.rb
@@ -0,0 +1,34 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require 'puppet/interface'
+require 'puppet/interface/option'
+require 'puppet/interface/documentation'
+
+class Puppet::Interface::TinyDocs::Test
+  include Puppet::Interface::TinyDocs
+  attr_accessor :name, :options
+  def initialize
+    self.name    = "tinydoc-test"
+    self.options = []
+  end
+
+  def get_option(name)
+    Puppet::Interface::Option.new(nil, "--#{name}")
+  end
+end
+
+describe Puppet::Interface::TinyDocs do
+  subject { Puppet::Interface::TinyDocs::Test.new }
+
+  context "#build_synopsis" do
+    before :each do
+      subject.options = [:foo, :bar]
+    end
+
+    it { should respond_to :build_synopsis }
+
+    it "should put a space between options (#7828)" do
+      subject.build_synopsis('baz').should =~ /#{Regexp.quote('[--foo] [--bar]')}/
+    end
+  end
+end