diff --git a/lib/puppet/face/help/action.erb b/lib/puppet/face/help/action.erb
index c84e46cf9..ac048c801 100644
--- a/lib/puppet/face/help/action.erb
+++ b/lib/puppet/face/help/action.erb
@@ -1,53 +1,86 @@
 <% if action.synopsis -%>
 USAGE: <%= action.synopsis %>
 
 <% end -%>
 <%= action.short_description || action.summary || face.summary || "undocumented subcommand" %>
 
 <% if action.returns -%>
 RETURNS: <%= action.returns.strip %>
 
 <% end -%>
 OPTIONS:
 <%# Remove these options once we can introspect them normally. -%>
   --mode MODE                    - The run mode to use (user, agent, or master).
   --render-as FORMAT             - The rendering format to use.
   --verbose                      - Whether to log verbosely.
   --debug                        - Whether to log debug information.
-<% unless action.options.empty?
-     optionroom = 30
-     summaryroom = 80 - 5 - optionroom
+<%  optionroom = 30
+	summaryroom = 80 - 5 - optionroom
+
+	disp_glob_opts = action.display_global_options.uniq
+ 	unless disp_glob_opts.empty?
+		disp_glob_opts.sort.each do |name|
+			option = name
+			desc = Puppet.settings.setting(option).desc
+			type = Puppet.settings.setting(option).default
+			type ||= Puppet.settings.setting(option).type.to_s.upcase -%>
+  <%= 		"--#{option} #{type}".ljust(optionroom) + ' - ' -%>
+<%			if !(desc) -%>
+undocumented option
+<%     		elsif desc.length <= summaryroom -%>
+<%= 			desc %>
+<%
+       		else
+				words = desc.split
+				wrapped = ['']
+				i = 0
+				words.each do |word|
+					if wrapped[i].length + word.length <= summaryroom
+						wrapped[i] << word + ' '
+					else
+						i += 1
+						wrapped[i] = word + ' '
+					end
+				end -%>
+<%= 			wrapped.shift.strip %>
+<%				wrapped.each do |line| -%>
+<%= 				(' ' * (optionroom + 5) ) + line.strip %>
+<%				end
+		 	end
+	  	end
+	end
+	unless action.options.empty?
       action.options.sort.each do |name|
         option = action.get_option name -%>
 <%= "  " + option.optparse.join(" | ")[0,(optionroom - 1)].ljust(optionroom) + ' - ' -%>
 <%     if !(option.summary) -%>
 undocumented option
 <%     elsif option.summary.length <= summaryroom -%>
 <%= option.summary %>
 <%
         else
           words = option.summary.split
           wrapped = ['']
           i = 0
           words.each do |word|
             if wrapped[i].length + word.length <= summaryroom
               wrapped[i] << word + ' '
             else
               i += 1
               wrapped[i] = word + ' '
             end
           end
 -%>
 <%= wrapped.shift.strip %>
 <%       wrapped.each do |line| -%>
 <%= (' ' * (optionroom + 5) ) + line.strip %>
 <%       end
         end
       end -%>
 <% end -%>
 
 <% if face.respond_to? :indirection -%>
 TERMINI: <%= face.class.terminus_classes(face.indirection.name).join(", ") %>
 
 <% end -%>
 See 'puppet man <%= face.name %>' or 'man puppet-<%= face.name %>' for full help.
diff --git a/lib/puppet/face/help/face.erb b/lib/puppet/face/help/face.erb
index 255d3d55b..968d443a2 100644
--- a/lib/puppet/face/help/face.erb
+++ b/lib/puppet/face/help/face.erb
@@ -1,79 +1,111 @@
 <% if face.synopsis -%>
 USAGE: <%= face.synopsis %>
 
 <% end -%>
 <%= (face.short_description || face.summary || "undocumented subcommand").strip %>
 
 OPTIONS:
 <%# Remove these options once we can introspect them normally. -%>
   --mode MODE                    - The run mode to use (user, agent, or master).
   --render-as FORMAT             - The rendering format to use.
   --verbose                      - Whether to log verbosely.
   --debug                        - Whether to log debug information.
-<% unless face.options.empty?
-     optionroom = 30
-     summaryroom = 80 - 5 - optionroom
+<%	optionroom = 30
+	summaryroom = 80 - 5 - optionroom
+	
+	disp_glob_opts = face.display_global_options.uniq
+ 	unless disp_glob_opts.empty?
+		disp_glob_opts.sort.each do |name|
+			option = name
+			desc = Puppet.settings.setting(option).desc
+			type = Puppet.settings.setting(option).default
+			type ||= Puppet.settings.setting(option).type.to_s.upcase -%>
+  <%= 		"--#{option} #{type}".ljust(optionroom) + ' - ' -%>
+<%			if !(desc) -%>
+undocumented option
+<%     		elsif desc.length <= summaryroom -%>
+<%= 			desc %>
+<%			else
+				words = desc.split
+				wrapped = ['']
+				i = 0
+				words.each do |word|
+					if wrapped[i].length + word.length <= summaryroom
+						wrapped[i] << word + ' '
+					else
+						i += 1
+						wrapped[i] = word + ' '
+					end
+				end -%>
+<%= 			wrapped.shift.strip %>
+<%				wrapped.each do |line| -%>
+<%= 				(' ' * (optionroom + 5) ) + line.strip %>
+<%				end
+		 	end
+	  	end
+	end
+ 	unless face.options.empty?
       face.options.sort.each do |name|
         option = face.get_option name -%>
 <%= "  " + option.optparse.join(" | ")[0,(optionroom - 1)].ljust(optionroom) + ' - ' -%>
 <%     if !(option.summary) -%>
 undocumented option
 <%     elsif option.summary.length <= summaryroom -%>
 <%= option.summary %>
 <%
        else
          words = option.summary.split
          wrapped = ['']
          i = 0
          words.each do |word|
            if wrapped[i].length + word.length <= summaryroom
              wrapped[i] << word + ' '
            else
              i += 1
              wrapped[i] = word + ' '
            end
          end
 -%>
 <%= wrapped.shift.strip %>
 <%       wrapped.each do |line| -%>
 <%= (' ' * (optionroom + 5) ) + line.strip %>
 <%       end
         end
       end -%>
 <% end -%>
 
 ACTIONS:
 <% padding = face.actions.map{|x| x.to_s.length}.max + 2
    summaryroom = 80 - (padding + 4)
    face.actions.each do |actionname|
      action = face.get_action(actionname) -%>
   <%= action.name.to_s.ljust(padding) + '  ' -%>
 <% if !(action.summary) -%>
 undocumented action
 <% elsif action.summary.length <= summaryroom -%>
 <%= action.summary %>
 <% else
           words = action.summary.split
           wrapped = ['']
           i = 0
           words.each do |word|
             if wrapped[i].length + word.length <= summaryroom
               wrapped[i] << word + ' '
             else
               i += 1
               wrapped[i] = word + ' '
             end
           end
 -%>
 <%= wrapped.shift.strip %>
 <%       wrapped.each do |line| -%>
 <%= (' ' * (padding + 4) ) + line.strip %>
 <%       end
         end
 end -%>
 
 <% if face.respond_to? :indirection -%>
 TERMINI: <%= face.class.terminus_classes(face.indirection.name).join(", ") %>
 
 <% end -%>
 See 'puppet man <%= face.name %>' or 'man puppet-<%= face.name %>' for full help.
diff --git a/lib/puppet/face/help/man.erb b/lib/puppet/face/help/man.erb
index 5a3aa2cbe..254c6f03a 100644
--- a/lib/puppet/face/help/man.erb
+++ b/lib/puppet/face/help/man.erb
@@ -1,136 +1,154 @@
 puppet-<%= face.name %>(8) -- <%= face.summary || "Undocumented subcommand." %>
 <%= '=' * (_erbout.length - 1) %>
 
 <% if face.synopsis -%>
 SYNOPSIS
 --------
 <%= face.synopsis %>
 
 <% end
    if face.description -%>
 DESCRIPTION
 -----------
 <%= face.description.strip %>
 
 <% end -%>
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument, although it may or may not be
 relevant to the present action. For example, `server` is a valid
 configuration parameter, so you can specify `--server <servername>` as
 an argument.
 
 See the configuration file documentation at
 <http://docs.puppetlabs.com/references/stable/configuration.html> for the
 full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet with
 `--genconfig`.
 
 * --mode MODE:
   The run mode to use for the current action. Valid modes are `user`, `agent`,
   and `master`.
 * --render-as FORMAT:
   The format in which to render output. The most common formats are `json`,
   `s` (string), `yaml`, and `console`, but other options such as `dot` are
   sometimes available.
 * --verbose:
   Whether to log verbosely.
 * --debug:
   Whether to log debug information.
+<% unless face.display_global_options.empty?
+     face.display_global_options.uniq.sort.each do |name|
+		option = name
+		desc = Puppet.settings.setting(option).desc
+		type = Puppet.settings.setting(option).default
+		type ||= Puppet.settings.setting(option).type.to_s.upcase -%>
+<%= "* --#{option} #{type}" %>:
+<%= desc.gsub(/^/, '  ') || '  undocumented setting' %>
+<%   end
+   end -%>
 <% unless face.options.empty?
      face.options.sort.each do |name|
        option = face.get_option name -%>
 <%= "* " + option.optparse.join(" | " ) %>:
 <%= option.description.gsub(/^/, '  ') || '  ' + option.summary %>
 <%   end
    end -%>
 
 ACTIONS
 -------
 <% face.actions.each do |actionname|
      action = face.get_action(actionname) -%>
 * `<%= action.name.to_s %>` - <%= action.summary %>:
 <%   if action.synopsis -%>
   `SYNOPSIS`
 
   <%= action.synopsis %>
 
 <%   end -%>
   `DESCRIPTION`
 
 <%   if action.description -%>
 <%= action.description.gsub(/^/, '  ') %>
 <% else -%>
   <%= action.summary || "Undocumented action." %>
 <%   end -%>
 
 <%   unique_options = action.options - face.options
-     unless unique_options.empty? -%>
+	 unique_display_global_options = action.display_global_options - face.display_global_options
+     unless unique_options.empty? and unique_display_global_options.empty? -%>
   `OPTIONS`
-
+<%      unique_display_global_options.uniq.sort.each do |name|
+		  option = name
+		  desc = Puppet.settings.setting(option).desc
+		  type = Puppet.settings.setting(option).default
+		  type ||= Puppet.settings.setting(option).type.to_s.upcase -%>
+  <%= "<--#{option} #{type}>" %> -
+<%= desc.gsub(/^/, '  ') %>
+<%      end -%>
 <%     unique_options.sort.each do |name|
          option = action.get_option name
          text = (option.description || option.summary).chomp + "\n" -%>
   <%= '<' + option.optparse.join("> | <") + '>' %> -
 <%= text.gsub(/^/, '  ') %>
 <%     end -%>
 
 <%   end -%>
 <%   if action.returns -%>
   `RETURNS`
 
 <%= action.returns.gsub(/^/, '  ') %>
 
 <%   end
      if action.notes -%>
   `NOTES`
 
 <%= action.notes.gsub(/^/, '  ') %>
 
 <%   end
    end
    if face.examples or face.actions.any? {|actionname| face.get_action(actionname).examples} -%>
 EXAMPLES
 --------
 <% end
    if face.examples -%>
 <%= face.examples %>
 
 <% end
    face.actions.each do |actionname|
      action = face.get_action(actionname)
      if action.examples -%>
 `<%= action.name.to_s %>`
 
 <%= action.examples.strip %>
 
 <%   end
    end -%>
 
 <% if face.notes or face.respond_to? :indirection -%>
 NOTES
 -----
 <% if face.notes -%>
 <%= face.notes.strip %>
 
 <% end # notes
 if face.respond_to? :indirection -%>
 This subcommand is an indirector face, which exposes `find`, `search`, `save`,
 and `destroy` actions for an indirected subsystem of Puppet. Valid termini for
 this face include:
 
 * `<%= face.class.terminus_classes(face.indirection.name).join("`\n* `") %>`
 
 <% end # indirection
    end # notes or indirection
    unless face.authors.empty? -%>
 AUTHOR
 ------
 <%= face.authors.join("\n").gsub(/^/, ' * ') %>
 
 <% end -%>
 COPYRIGHT AND LICENSE
 ---------------------
 <%= face.copyright %>
 <%= face.license %>
diff --git a/lib/puppet/face/module.rb b/lib/puppet/face/module.rb
index 87c14a8d1..523982152 100644
--- a/lib/puppet/face/module.rb
+++ b/lib/puppet/face/module.rb
@@ -1,17 +1,19 @@
 require 'puppet/face'
 require 'puppet/module_tool'
 require 'puppet/util/colors'
 
 Puppet::Face.define(:module, '1.0.0') do
   extend Puppet::Util::Colors
 
   copyright "Puppet Labs", 2012
   license   "Apache 2 license; see COPYING"
 
   summary "Creates, installs and searches for modules on the Puppet Forge."
   description <<-EOT
     This subcommand can find, install, and manage modules from the Puppet Forge,
     a repository of user-contributed Puppet code. It can also generate empty
     modules, and prepare locally developed modules for release on the Forge.
   EOT
+  
+  display_global_options "environment", "modulepath"
 end
diff --git a/lib/puppet/interface/action.rb b/lib/puppet/interface/action.rb
index 5f23f55db..6ebbcb63f 100644
--- a/lib/puppet/interface/action.rb
+++ b/lib/puppet/interface/action.rb
@@ -1,322 +1,338 @@
 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        = []
+    @display_global_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_reader   :face
   attr_accessor :default
   def default?
     !!@default
   end
 
   ########################################################################
   # Documentation...
   attr_doc :returns
   attr_doc :arguments
   def synopsis
     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 and proc.arity != (@positional_arg_count + 1)
       msg =  "the when_rendering method for the #{@face.name} face #{name} action "
       msg += "takes either just one argument, the result of when_invoked, "
       msg += "or the result plus the #{@positional_arg_count} arguments passed "
       msg += "to the when_invoked block, 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}
   action  = get_action(#{name.inspect})
   args   << action.validate_and_clean(args.pop)
   __invoke_decorations(:before, action, args, args.last)
   rval = self.__send__(#{internal_name.inspect}, *args)
   __invoke_decorations(:after, action, args, args.last)
   return rval
 end
 WRAPPER
 
     if @face.is_a?(Class)
       @face.class_eval do eval wrapper, nil, file, line end
       @face.send(: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
 
     @options << option.name
 
     option.aliases.each do |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 add_display_global_options(*args)
+    @display_global_options ||= []
+    [args].flatten.each do |refopt|
+      raise ArgumentError, "Global option #{refopt} does not exist in Puppet.settings" unless Puppet.settings.include? refopt
+      @display_global_options << refopt
+    end
+    @display_global_options.uniq!
+    @display_global_options
+  end
+  
+  def display_global_options(*args)
+    args ? add_display_global_options(args) : @display_global_options + @face.display_global_options 
+  end
+  alias :display_global_option :display_global_options
+  
   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_and_clean(original)
     # The final set of arguments; effectively a hand-rolled shallow copy of
     # the original, which protects the caller from the surprises they might
     # get if they passed us a hash and we mutated it...
     result = {}
 
     # Check for multiple aliases for the same option, and canonicalize the
     # name of the argument while we are about it.
     overlap = Hash.new do |h, k| h[k] = [] end
     unknown = []
     original.keys.each do |name|
       if option = get_option(name) then
         canonical = option.name
         if result.has_key? canonical
           overlap[canonical] << name
         else
           result[canonical] = original[name]
         end
       elsif Puppet.settings.include? name
         result[name] = original[name]
       else
         unknown << name
       end
     end
 
     unless overlap.empty?
       msg = overlap.map {|k, v| "(#{k}, #{v.sort.join(', ')})" }.join(", ")
       raise ArgumentError, "Multiple aliases for the same option passed: #{msg}"
     end
 
     unless unknown.empty?
       msg = unknown.sort.join(", ")
       raise ArgumentError, "Unknown options passed: #{msg}"
     end
 
     # Inject default arguments and check for missing mandating options.
     missing = []
     options.map {|x| get_option(x) }.each do |option|
       name = option.name
       next if result.has_key? name
 
       if option.has_default?
         result[name] = option.default
       elsif option.required?
         missing << name
       end
     end
 
     unless missing.empty?
       msg = missing.sort.join(', ')
       raise ArgumentError, "The following options are required: #{msg}"
     end
 
     # All done.
     return result
   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/action_builder.rb b/lib/puppet/interface/action_builder.rb
index 4948f5fab..7198e9015 100644
--- a/lib/puppet/interface/action_builder.rb
+++ b/lib/puppet/interface/action_builder.rb
@@ -1,74 +1,79 @@
 require 'puppet/interface'
 require 'puppet/interface/action'
 
 class Puppet::Interface::ActionBuilder
   attr_reader :action
 
   def self.build(face, name, &block)
     raise "Action #{name.inspect} must specify a block" unless block
     new(face, name, &block).action
   end
 
   # Ideally the method we're defining here would be added to the action, and a
   # method on the face would defer to it, but we can't get scope correct, so
   # we stick with this. --daniel 2011-03-24
   def when_invoked(&block)
     @action.when_invoked = block
   end
 
   def when_rendering(type = nil, &block)
     if type.nil? then           # the default error message sucks --daniel 2011-04-18
       raise ArgumentError, 'You must give a rendering format to when_rendering'
     end
     if block.nil? then
       raise ArgumentError, 'You must give a block to when_rendering'
     end
     @action.set_rendering_method_for(type, block)
   end
 
   def option(*declaration, &block)
     option = Puppet::Interface::OptionBuilder.build(@action, *declaration, &block)
     @action.add_option(option)
   end
 
   def default(value = true)
     @action.default = !!value
   end
+  
+  def display_global_options(*args)
+    @action.add_display_global_options args
+  end
+  alias :display_global_option :display_global_options
 
   def render_as(value = nil)
     value.nil? and raise ArgumentError, "You must give a rendering format to render_as"
 
     formats = Puppet::Network::FormatHandler.formats
     unless formats.include? value
       raise ArgumentError, "#{value.inspect} is not a valid rendering format: #{formats.sort.join(", ")}"
     end
 
     @action.render_as = value
   end
 
   # Metaprogram the simple DSL from the target class.
   Puppet::Interface::Action.instance_methods.grep(/=$/).each do |setter|
     next if setter =~ /^=/
     property = setter.to_s.chomp('=')
 
     unless method_defined? property
       # Using eval because the argument handling semantics are less awful than
       # when we use the define_method/block version.  The later warns on older
       # Ruby versions if you pass the wrong number of arguments, but carries
       # on, which is totally not what we want. --daniel 2011-04-18
       eval <<-METHOD
         def #{property}(value)
           @action.#{property} = value
         end
       METHOD
     end
   end
 
   private
   def initialize(face, name, &block)
     @face   = face
     @action = Puppet::Interface::Action.new(face, name)
     instance_eval(&block)
     @action.when_invoked or raise ArgumentError, "actions need to know what to do when_invoked; please add the block"
   end
 end
diff --git a/lib/puppet/interface/documentation.rb b/lib/puppet/interface/documentation.rb
index 47e478a44..be4cc3b31 100644
--- a/lib/puppet/interface/documentation.rb
+++ b/lib/puppet/interface/documentation.rb
@@ -1,230 +1,242 @@
 # 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
+        
+        display_global_options.sort.each do |option|
+          wrap = %w{ [ ] }
+          s.group(0, *wrap) do
+        		desc = Puppet.settings.setting(option).desc
+        		type = Puppet.settings.setting(option).default
+        		type ||= Puppet.settings.setting(option).type.to_s.upcase
+            s.text "--#{option} #{type}"
+            s.breakable
+          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/lib/puppet/interface/option_manager.rb b/lib/puppet/interface/option_manager.rb
index a1f300e8e..e9dec7ecd 100644
--- a/lib/puppet/interface/option_manager.rb
+++ b/lib/puppet/interface/option_manager.rb
@@ -1,68 +1,86 @@
 require 'puppet/interface/option_builder'
 
 module Puppet::Interface::OptionManager
+  
+  def display_global_options(*args)
+    @display_global_options ||= []
+    [args].flatten.each do |refopt|
+      raise ArgumentError, "Global option #{refopt} does not exist in Puppet.settings" unless Puppet.settings.include? refopt
+      @display_global_options << refopt if refopt
+    end
+    @display_global_options.uniq!
+    @display_global_options
+  end
+  alias :display_global_option :display_global_options
+  
+  def all_display_global_options
+    walk_inheritance_tree(@display_global_options, :all_display_global_options)
+  end
+  
+  def walk_inheritance_tree(start, sym)
+    result = (start ||= [])
+    if self.is_a?(Class) and superclass.respond_to?(sym)
+      result = superclass.send(sym) + result
+    elsif self.class.respond_to?(sym)
+      result = self.class.send(sym) + result
+    end
+    return result
+  end
+  
   # Declare that this app can take a specific option, and provide
   # the code to do so.
   def option(*declaration, &block)
     add_option Puppet::Interface::OptionBuilder.build(self, *declaration, &block)
   end
 
   def add_option(option)
     # @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 ||= {}
 
     option.aliases.each do |name|
       if conflict = get_option(name) then
         raise ArgumentError, "Option #{option} conflicts with existing option #{conflict}"
       end
 
       actions.each do |action|
         action = get_action(action)
         if conflict = action.get_option(name) then
           raise ArgumentError, "Option #{option} conflicts with existing option #{conflict} on #{action}"
         end
       end
     end
 
     @options << option.name
 
     option.aliases.each do |name|
       @options_hash[name] = option
     end
 
     return option
   end
 
   def options
-    result = (@options ||= [])
-
-    if self.is_a?(Class) and superclass.respond_to?(:options)
-      result = superclass.options + result
-    elsif self.class.respond_to?(:options)
-      result = self.class.options + result
-    end
-
-    return result
+    walk_inheritance_tree(@options, :options)
   end
 
   def get_option(name, with_inherited_options = true)
     @options_hash ||= {}
 
     result = @options_hash[name.to_sym]
     if result.nil? and with_inherited_options then
       if self.is_a?(Class) and superclass.respond_to?(:get_option)
         result = superclass.get_option(name)
       elsif self.class.respond_to?(:get_option)
         result = self.class.get_option(name)
       end
     end
 
     return result
   end
 
   def option?(name)
     options.include? name.to_sym
   end
 end
diff --git a/lib/puppet/util/settings/boolean_setting.rb b/lib/puppet/util/settings/boolean_setting.rb
index d11e4c837..53c91a2a8 100644
--- a/lib/puppet/util/settings/boolean_setting.rb
+++ b/lib/puppet/util/settings/boolean_setting.rb
@@ -1,30 +1,33 @@
 require 'puppet/util/settings/string_setting'
 
 # A simple boolean.
 class Puppet::Util::Settings::BooleanSetting < Puppet::Util::Settings::StringSetting
   # get the arguments in getopt format
   def getopt_args
     if short
       [["--#{name}", "-#{short}", GetoptLong::NO_ARGUMENT], ["--no-#{name}", GetoptLong::NO_ARGUMENT]]
     else
       [["--#{name}", GetoptLong::NO_ARGUMENT], ["--no-#{name}", GetoptLong::NO_ARGUMENT]]
     end
   end
 
   def optparse_args
     if short
       ["--[no-]#{name}", "-#{short}", desc, :NONE ]
     else
       ["--[no-]#{name}", desc, :NONE]
     end
   end
 
   def munge(value)
     case value
     when true, "true"; return true
     when false, "false"; return false
     else
       raise ArgumentError, "Invalid value '#{value.inspect}' for #{@name}"
     end
   end
+  def type
+    :boolean
+  end
 end
diff --git a/lib/puppet/util/settings/string_setting.rb b/lib/puppet/util/settings/string_setting.rb
index 740595236..b72ac0d68 100644
--- a/lib/puppet/util/settings/string_setting.rb
+++ b/lib/puppet/util/settings/string_setting.rb
@@ -1,107 +1,111 @@
 # The base element type.
 class Puppet::Util::Settings::StringSetting
   attr_accessor :name, :section, :default, :call_on_define
   attr_reader :desc, :short
 
   def desc=(value)
     @desc = value.gsub(/^\s*/, '')
   end
   
   #added as a proper method, only to generate a deprecation warning
   #and return value from 
   def setbycli
     Puppet.deprecation_warning "Puppet.settings.setting(#{name}).setbycli is deprecated. Use Puppet.settings.set_by_cli?(#{name}) instead."
     @settings.set_by_cli?(name)
   end
   
   def setbycli=(value)
     Puppet.deprecation_warning "Puppet.settings.setting(#{name}).setbycli= is deprecated. You should not manually set that values were specified on the command line."
     @settings.set_value(name, @settings[name], :cli) if value
     raise ArgumentError, "Cannot unset setbycli" unless value
   end
+  
+  def type
+    :string
+  end
 
   # get the arguments in getopt format
   def getopt_args
     if short
       [["--#{name}", "-#{short}", GetoptLong::REQUIRED_ARGUMENT]]
     else
       [["--#{name}", GetoptLong::REQUIRED_ARGUMENT]]
     end
   end
 
   # get the arguments in OptionParser format
   def optparse_args
     if short
       ["--#{name}", "-#{short}", desc, :REQUIRED]
     else
       ["--#{name}", desc, :REQUIRED]
     end
   end
 
   def hook=(block)
     meta_def :handle, &block
   end
 
   # Create the new element.  Pretty much just sets the name.
   def initialize(args = {})
     unless @settings = args.delete(:settings)
       raise ArgumentError.new("You must refer to a settings object")
     end
 
     args.each do |param, value|
       method = param.to_s + "="
       raise ArgumentError, "#{self.class} (setting '#{args[:name]}') does not accept #{param}" unless self.respond_to? method
 
       self.send(method, value)
     end
 
     raise ArgumentError, "You must provide a description for the #{self.name} config option" unless self.desc
   end
 
   def iscreated
     @iscreated = true
   end
 
   def iscreated?
     @iscreated
   end
 
   def set?
     !!(!@value.nil?)
   end
 
   # short name for the celement
   def short=(value)
     raise ArgumentError, "Short names can only be one character." if value.to_s.length != 1
     @short = value.to_s
   end
 
   # Convert the object to a config statement.
   def to_config
     str = @desc.gsub(/^/, "# ") + "\n"
 
     # Add in a statement about the default.
     str += "# The default value is '#{@default}'.\n" if @default
 
     # If the value has not been overridden, then print it out commented
     # and unconverted, so it's clear that that's the default and how it
     # works.
     value = @settings.value(self.name)
 
     if value != @default
       line = "#{@name} = #{value}"
     else
       line = "# #{@name} = #{@default}"
     end
 
     str += line + "\n"
 
     str.gsub(/^/, "    ")
   end
 
   # Retrieves the value, or if it's not set, retrieves the default.
   def value
     @settings.value(self.name)
   end
 end
 
diff --git a/spec/unit/interface/documentation_spec.rb b/spec/unit/interface/documentation_spec.rb
index 6865b9073..d9c55bdfd 100755
--- a/spec/unit/interface/documentation_spec.rb
+++ b/spec/unit/interface/documentation_spec.rb
@@ -1,34 +1,35 @@
 #!/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
+  attr_accessor :name, :options, :display_global_options
   def initialize
     self.name    = "tinydoc-test"
     self.options = []
+    self.display_global_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
diff --git a/spec/unit/interface_spec.rb b/spec/unit/interface_spec.rb
index 1621b9ad8..f7a7ee48e 100755
--- a/spec/unit/interface_spec.rb
+++ b/spec/unit/interface_spec.rb
@@ -1,233 +1,271 @@
 require 'spec_helper'
 require 'puppet/face'
 require 'puppet/interface'
 
 describe Puppet::Interface do
   subject { Puppet::Interface }
 
   before :each do
     @faces = Puppet::Interface::FaceCollection.
       instance_variable_get("@faces").dup
     @dq = $".dup
     $".delete_if do |path| path =~ %r{/face/.*\.rb$} end
     Puppet::Interface::FaceCollection.instance_variable_get("@faces").clear
   end
 
   after :each do
     Puppet::Interface::FaceCollection.instance_variable_set("@faces", @faces)
     $".clear ; @dq.each do |item| $" << item end
   end
 
   describe "#[]" do
     it "should fail when no version is requested" do
       expect { subject[:huzzah] }.should raise_error ArgumentError
     end
 
     it "should raise an exception when the requested version is unavailable" do
       expect { subject[:huzzah, '17.0.0'] }.should raise_error, Puppet::Error
     end
 
     it "should raise an exception when the requested face doesn't exist" do
       expect { subject[:burrble_toot, :current] }.should raise_error, Puppet::Error
     end
 
     describe "version matching" do
       { '1'     => '1.1.1',
         '1.0'   => '1.0.1',
         '1.0.1' => '1.0.1',
         '1.1'   => '1.1.1',
         '1.1.1' => '1.1.1'
       }.each do |input, expect|
         it "should match #{input.inspect} to #{expect.inspect}" do
           face = subject[:version_matching, input]
           face.should be
           face.version.should == expect
         end
       end
 
       %w{1.0.2 1.2}.each do |input|
         it "should not match #{input.inspect} to any version" do
           expect { subject[:version_matching, input] }.
             to raise_error Puppet::Error, /Could not find version/
         end
       end
     end
   end
 
   describe "#define" do
     it "should register the face" do
       face  = subject.define(:face_test_register, '0.0.1')
       face.should == subject[:face_test_register, '0.0.1']
     end
 
     it "should load actions" do
       subject.any_instance.expects(:load_actions)
       subject.define(:face_test_load_actions, '0.0.1')
     end
 
     it "should require a version number" do
       expect { subject.define(:no_version) }.to raise_error ArgumentError
     end
 
     it "should support summary builder and accessor methods" do
       subject.new(:foo, '1.0.0').should respond_to(:summary).with(0).arguments
       subject.new(:foo, '1.0.0').should respond_to(:summary=).with(1).arguments
     end
 
     # Required documentation methods...
     { :summary     => "summary",
       :description => "This is the description of the stuff\n\nWhee",
       :examples    => "This is my example",
       :short_description => "This is my custom short description",
       :notes       => "These are my notes...",
       :author      => "This is my authorship data",
     }.each do |attr, value|
       it "should support #{attr} in the builder" do
         face = subject.new(:builder, '1.0.0') do
           self.send(attr, value)
         end
         face.send(attr).should == value
       end
     end
   end
 
   describe "#initialize" do
     it "should require a version number" do
       expect { subject.new(:no_version) }.to raise_error ArgumentError
     end
 
     it "should require a valid version number" do
       expect { subject.new(:bad_version, 'Rasins') }.
         should raise_error ArgumentError
     end
 
     it "should instance-eval any provided block" do
       face = subject.new(:face_test_block, '0.0.1') do
         action(:something) do
           when_invoked {|_| "foo" }
         end
       end
 
       face.something.should == "foo"
     end
   end
 
   it "should have a name" do
     subject.new(:me, '0.0.1').name.should == :me
   end
 
   it "should stringify with its own name" do
     subject.new(:me, '0.0.1').to_s.should =~ /\bme\b/
   end
 
   # Why?
   it "should create a class-level autoloader" do
     subject.autoloader.should be_instance_of(Puppet::Util::Autoload)
   end
 
   it "should try to require faces that are not known" do
     subject::FaceCollection.expects(:load_face).with(:foo, :current)
     subject::FaceCollection.expects(:load_face).with(:foo, '0.0.1')
     expect { subject[:foo, '0.0.1'] }.to raise_error Puppet::Error
   end
 
   it_should_behave_like "things that declare options" do
     def add_options_to(&block)
       subject.new(:with_options, '0.0.1', &block)
     end
   end
+  
+  describe "with face-level display_global_options" do
+    it "should not return any action level display_global_options" do
+      face = subject.new(:with_display_global_options, '0.0.1') do
+        display_global_options "environment"
+        action :baz do
+          when_invoked {|_| true }
+          display_global_options "modulepath"
+        end
+      end
+      face.display_global_options =~ ["environment"]
+    end
+        
+    it "should not fail when a face d_g_o duplicates an action d_g_o" do
+      expect {
+        subject.new(:action_level_display_global_options, '0.0.1') do
+          action :bar do
+            when_invoked {|_| true }
+            display_global_options "environment"
+          end
+          display_global_options "environment"
+        end
+      }.should_not raise_error
+    end
+    
+    it "should work when two actions have the same d_g_o" do
+      face = subject.new(:with_display_global_options, '0.0.1') do
+        action :foo do when_invoked {|_| true} ; display_global_options "environment" end
+        action :bar do when_invoked {|_| true} ; display_global_options "environment" end
+      end
+      face.get_action(:foo).display_global_options =~ ["environment"]
+      face.get_action(:bar).display_global_options =~ ["environment"]
+    end
+      
+  end
+  
+  describe "with inherited display_global_options" do
+  end
 
   describe "with face-level options" do
     it "should not return any action-level options" do
       face = subject.new(:with_options, '0.0.1') do
         option "--foo"
         option "--bar"
         action :baz do
           when_invoked {|_| true }
           option "--quux"
         end
       end
       face.options.should =~ [:foo, :bar]
     end
 
     it "should fail when a face option duplicates an action option" do
       expect {
         subject.new(:action_level_options, '0.0.1') do
           action :bar do
             when_invoked {|_| true }
             option "--foo"
           end
           option "--foo"
         end
       }.should raise_error ArgumentError, /Option foo conflicts with existing option foo on/i
     end
 
     it "should work when two actions have the same option" do
       face = subject.new(:with_options, '0.0.1') do
         action :foo do when_invoked {|_| true } ; option "--quux" end
         action :bar do when_invoked {|_| true } ; option "--quux" end
       end
 
       face.get_action(:foo).options.should =~ [:quux]
       face.get_action(:bar).options.should =~ [:quux]
     end
 
     it "should only list options and not aliases" do
       face = subject.new(:face_options, '0.0.1') do
         option "--bar", "-b", "--foo-bar"
       end
       face.options.should =~ [:bar]
     end
 
   end
 
   describe "with inherited options" do
     let :parent do
       parent = Class.new(subject)
       parent.option("--inherited")
       parent.action(:parent_action) do when_invoked {|_| true } end
       parent
     end
 
     let :face do
       face = parent.new(:example, '0.2.1')
       face.option("--local")
       face.action(:face_action) do when_invoked {|_| true } end
       face
     end
 
     describe "#options" do
       it "should list inherited options" do
         face.options.should =~ [:inherited, :local]
       end
 
       it "should see all options on face actions" do
         face.get_action(:face_action).options.should =~ [:inherited, :local]
       end
 
       it "should see all options on inherited actions accessed on the subclass" do
         face.get_action(:parent_action).options.should =~ [:inherited, :local]
       end
 
       it "should not see subclass actions on the parent class" do
         parent.options.should =~ [:inherited]
       end
 
       it "should not see subclass actions on actions accessed on the parent class" do
         parent.get_action(:parent_action).options.should =~ [:inherited]
       end
     end
 
     describe "#get_option" do
       it "should return an inherited option object" do
         face.get_option(:inherited).should be_an_instance_of subject::Option
       end
     end
   end
 
   it_should_behave_like "documentation on faces" do
     subject do
       Puppet::Interface.new(:face_documentation, '0.0.1')
     end
   end
 end