diff --git a/lib/puppet/application/face_base.rb b/lib/puppet/application/face_base.rb
index a111518f1..14ce67b42 100644
--- a/lib/puppet/application/face_base.rb
+++ b/lib/puppet/application/face_base.rb
@@ -1,247 +1,254 @@
 require 'puppet/application'
 require 'puppet/face'
 require 'optparse'
 require 'pp'
 
 class Puppet::Application::FaceBase < Puppet::Application
   should_parse_config
   run_mode :agent
 
   option("--debug", "-d") do |arg|
     Puppet::Util::Log.level = :debug
   end
 
   option("--verbose", "-v") do
     Puppet::Util::Log.level = :info
   end
 
   option("--render-as FORMAT") do |format|
     self.render_as = format.to_sym
   end
 
   option("--mode RUNMODE", "-r") do |arg|
     raise "Invalid run mode #{arg}; supported modes are user, agent, master" unless %w{user agent master}.include?(arg)
     self.class.run_mode(arg.to_sym)
     set_run_mode self.class.run_mode
   end
 
 
   attr_accessor :face, :action, :type, :arguments, :render_as
 
   def render_as=(format)
     if format == :json then
       @render_as = Puppet::Network::FormatHandler.format(:pson)
     else
       @render_as = Puppet::Network::FormatHandler.format(format)
     end
     @render_as or raise ArgumentError, "I don't know how to render '#{format}'"
   end
 
-  def render(result)
-    # Invoke the rendering hook supplied by the user, if appropriate.
-    if hook = action.when_rendering(render_as.name)
-      result = hook.call(result)
+  def render(result, args_and_options)
+    hook = action.when_rendering(render_as.name)
+
+    if hook
+      # when defining when_rendering on your action you can optionally
+      # include arguments and options
+      if hook.arity > 1
+        result = hook.call(result, *args_and_options)
+      else
+        result = hook.call(result)
+      end
     end
 
     render_as.render(result)
   end
 
   def preinit
     super
     Signal.trap(:INT) do
       $stderr.puts "Cancelling Face"
       exit(0)
     end
   end
 
   def parse_options
     # We need to parse enough of the command line out early, to identify what
     # the action is, so that we can obtain the full set of options to parse.
 
     # REVISIT: These should be configurable versions, through a global
     # '--version' option, but we don't implement that yet... --daniel 2011-03-29
     @type = self.class.name.to_s.sub(/.+:/, '').downcase.to_sym
     @face = Puppet::Face[@type, :current]
 
     # Now, walk the command line and identify the action.  We skip over
     # arguments based on introspecting the action and all, and find the first
     # non-option word to use as the action.
     action_name = nil
     index       = -1
     until action_name or (index += 1) >= command_line.args.length do
       item = command_line.args[index]
       if item =~ /^-/ then
         option = @face.options.find do |name|
           item =~ /^-+#{name.to_s.gsub(/[-_]/, '[-_]')}(?:[ =].*)?$/
         end
         if option then
           option = @face.get_option(option)
           # If we have an inline argument, just carry on.  We don't need to
           # care about optional vs mandatory in that case because we do a real
           # parse later, and that will totally take care of raising the error
           # when we get there. --daniel 2011-04-04
           if option.takes_argument? and !item.index('=') then
             index += 1 unless
               (option.optional_argument? and command_line.args[index + 1] =~ /^-/)
           end
         elsif option = find_global_settings_argument(item) then
           unless Puppet.settings.boolean? option.name then
             # As far as I can tell, we treat non-bool options as always having
             # a mandatory argument. --daniel 2011-04-05
             index += 1          # ...so skip the argument.
           end
         elsif option = find_application_argument(item) then
           index += 1 if (option[:argument] and not option[:optional])
         else
           raise OptionParser::InvalidOption.new(item.sub(/=.*$/, ''))
         end
       else
         # Stash away the requested action name for later, and try to fetch the
         # action object it represents; if this is an invalid action name that
         # will be nil, and handled later.
         action_name = item.to_sym
         @action = Puppet::Face.find_action(@face.name, action_name)
         @face   = @action.face if @action
       end
     end
 
     if @action.nil?
       if @action = @face.get_default_action() then
         @is_default_action = true
       else
         # REVISIT: ...and this horror thanks to our log setup, which doesn't
         # initialize destinations until the setup method, which we will never
         # reach.  We could also just print here, but that is actually a little
         # uglier and nastier in the long term, in which we should do log setup
         # earlier if at all possible. --daniel 2011-05-31
         Puppet::Util::Log.newdestination(:console)
 
         face   = @face.name
         action = action_name.nil? ? 'default' : "'#{action_name}'"
         msg = "'#{face}' has no #{action} action.  See `puppet help #{face}`."
         Puppet.err(msg)
 
         exit false
       end
     end
 
     # Now we can interact with the default option code to build behaviour
     # around the full set of options we now know we support.
     @action.options.each do |option|
       option = @action.get_option(option) # make it the object.
       self.class.option(*option.optparse) # ...and make the CLI parse it.
     end
 
     # ...and invoke our parent to parse all the command line options.
     super
   end
 
   def find_global_settings_argument(item)
     Puppet.settings.each do |name, object|
       object.optparse_args.each do |arg|
         next unless arg =~ /^-/
         # sadly, we have to emulate some of optparse here...
         pattern = /^#{arg.sub('[no-]', '').sub(/[ =].*$/, '')}(?:[ =].*)?$/
         pattern.match item and return object
       end
     end
     return nil                  # nothing found.
   end
 
   def find_application_argument(item)
     self.class.option_parser_commands.each do |options, function|
       options.each do |option|
         next unless option =~ /^-/
         pattern = /^#{option.sub('[no-]', '').sub(/[ =].*$/, '')}(?:[ =].*)?$/
         next unless pattern.match(item)
         return {
           :argument => option =~ /[ =]/,
           :optional => option =~ /[ =]\[/
         }
       end
     end
     return nil                  # not found
   end
 
   def setup
     Puppet::Util::Log.newdestination :console
 
     @arguments = command_line.args
 
     # Note: because of our definition of where the action is set, we end up
     # with it *always* being the first word of the remaining set of command
     # line arguments.  So, strip that off when we construct the arguments to
     # pass down to the face action. --daniel 2011-04-04
     # Of course, now that we have default actions, we should leave the
     # "action" name on if we didn't actually consume it when we found our
     # action.
     @arguments.delete_at(0) unless @is_default_action
 
     # We copy all of the app options to the end of the call; This allows each
     # action to read in the options.  This replaces the older model where we
     # would invoke the action with options set as global state in the
     # interface object.  --daniel 2011-03-28
     @arguments << options
 
     # If we don't have a rendering format, set one early.
     self.render_as ||= (@action.render_as || :console)
   end
 
 
   def main
     status = false
 
     # Call the method associated with the provided action (e.g., 'find').
     unless @action
       puts Puppet::Face[:help, :current].help(@face.name)
       raise "#{face} does not respond to action #{arguments.first}"
     end
 
     # We need to do arity checking here because this is generic code
     # calling generic methods – that have argument defaulting.  We need to
     # make sure we don't accidentally pass the options as the first
     # argument to a method that takes one argument.  eg:
     #
     #   puppet facts find
     #   => options => {}
     #      @arguments => [{}]
     #   => @face.send :bar, {}
     #
     #   def face.bar(argument, options = {})
     #   => bar({}, {})  # oops!  we thought the options were the
     #                   # positional argument!!
     #
     # We could also fix this by making it mandatory to pass the options on
     # every call, but that would make the Ruby API much more annoying to
     # work with; having the defaulting is a much nicer convention to have.
     #
     # We could also pass the arguments implicitly, by having a magic
     # 'options' method that was visible in the scope of the action, which
     # returned the right stuff.
     #
     # That sounds attractive, but adds complications to all sorts of
     # things, especially when you think about how to pass options when you
     # are writing Ruby code that calls multiple faces.  Especially if
     # faces are involved in that. ;)
     #
     # --daniel 2011-04-27
     if (arity = @action.positional_arg_count) > 0
       unless (count = arguments.length) == arity then
         s = arity == 2 ? '' : 's'
         raise ArgumentError, "puppet #{@face.name} #{@action.name} takes #{arity-1} argument#{s}, but you gave #{count-1}"
       end
     end
 
     result = @face.send(@action.name, *arguments)
-    puts render(result) unless result.nil?
+    puts render(result, arguments) unless result.nil?
     status = true
 
   rescue Exception => detail
     puts detail.backtrace if Puppet[:trace]
     Puppet.err detail.to_s
     Puppet.err "Try 'puppet help #{@face.name} #{@action.name}' for usage"
 
   ensure
     exit status
   end
 end
diff --git a/lib/puppet/interface/action.rb b/lib/puppet/interface/action.rb
index 60ddb2ca3..3f2f41273 100644
--- a/lib/puppet/interface/action.rb
+++ b/lib/puppet/interface/action.rb
@@ -1,318 +1,322 @@
 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_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 then
-      msg = "when_rendering methods take one argument, the result, not "
+
+    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.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 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/spec/unit/application/face_base_spec.rb b/spec/unit/application/face_base_spec.rb
index bebc26210..d72187bb7 100755
--- a/spec/unit/application/face_base_spec.rb
+++ b/spec/unit/application/face_base_spec.rb
@@ -1,361 +1,378 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/application/face_base'
 require 'tmpdir'
 
 class Puppet::Application::FaceBase::Basetest < Puppet::Application::FaceBase
 end
 
 describe Puppet::Application::FaceBase do
   let :app do
     app = Puppet::Application::FaceBase::Basetest.new
     app.command_line.stubs(:subcommand_name).returns('subcommand')
     Puppet::Util::Log.stubs(:newdestination)
     app
   end
 
   describe "#find_global_settings_argument" do
     it "should not match --ca to --ca-location" do
       option = mock('ca option', :optparse_args => ["--ca"])
       Puppet.settings.expects(:each).yields(:ca, option)
 
       app.find_global_settings_argument("--ca-location").should be_nil
     end
   end
 
   describe "#parse_options" do
     before :each do
       app.command_line.stubs(:args).returns %w{}
     end
 
     describe "with just an action" do
       before :all do
         # We have to stub Signal.trap to avoid a crazy mess where we take
         # over signal handling and make it impossible to cancel the test
         # suite run.
         #
         # It would be nice to fix this elsewhere, but it is actually hard to
         # capture this in rspec 2.5 and all. :(  --daniel 2011-04-08
         Signal.stubs(:trap)
         app.command_line.stubs(:args).returns %w{foo}
         app.preinit
         app.parse_options
       end
 
       it "should set the face based on the type" do
         app.face.name.should == :basetest
       end
 
       it "should find the action" do
         app.action.should be
         app.action.name.should == :foo
       end
     end
 
     it "should stop if the first thing found is not an action" do
       app.command_line.stubs(:args).returns %w{banana count_args}
       expect { app.run }.to exit_with 1
       @logs.first.should_not be_nil
       @logs.first.message.should =~ /has no 'banana' action/
     end
 
     it "should use the default action if not given any arguments" do
       app.command_line.stubs(:args).returns []
       action = stub(:options => [], :render_as => nil)
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
       app.stubs(:main)
       app.run
       app.action.should == action
       app.arguments.should == [ { } ]
     end
 
     it "should use the default action if not given a valid one" do
       app.command_line.stubs(:args).returns %w{bar}
       action = stub(:options => [], :render_as => nil)
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
       app.stubs(:main)
       app.run
       app.action.should == action
       app.arguments.should == [ 'bar', { } ]
     end
 
     it "should have no action if not given a valid one and there is no default action" do
       app.command_line.stubs(:args).returns %w{bar}
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
       app.stubs(:main)
       expect { app.run }.to exit_with 1
       @logs.first.message.should =~ /has no 'bar' action./
     end
 
     [%w{something_I_cannot_do},
      %w{something_I_cannot_do argument}].each do |input|
       it "should report unknown actions nicely" do
         app.command_line.stubs(:args).returns input
         Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
         app.stubs(:main)
         expect { app.run }.to exit_with 1
         @logs.first.message.should =~ /has no 'something_I_cannot_do' action/
       end
     end
 
     [%w{something_I_cannot_do --unknown-option},
      %w{something_I_cannot_do argument --unknown-option}].each do |input|
       it "should report unknown actions even if there are unknown options" do
         app.command_line.stubs(:args).returns input
         Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
         app.stubs(:main)
         expect { app.run }.to exit_with 1
         @logs.first.message.should =~ /has no 'something_I_cannot_do' action/
       end
     end
 
     it "should report a sensible error when options with = fail" do
       app.command_line.stubs(:args).returns %w{--action=bar foo}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --action/
     end
 
     it "should fail if an action option is before the action" do
       app.command_line.stubs(:args).returns %w{--action foo}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --action/
     end
 
     it "should fail if an unknown option is before the action" do
       app.command_line.stubs(:args).returns %w{--bar foo}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --bar/
     end
 
     it "should fail if an unknown option is after the action" do
       app.command_line.stubs(:args).returns %w{foo --bar}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --bar/
     end
 
     it "should accept --bar as an argument to a mandatory option after action" do
       app.command_line.stubs(:args).returns %w{foo --mandatory --bar}
       app.preinit
       app.parse_options
       app.action.name.should == :foo
       app.options.should == { :mandatory => "--bar" }
     end
 
     it "should accept --bar as an argument to a mandatory option before action" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
       app.preinit
       app.parse_options
       app.action.name.should == :foo
       app.options.should == { :mandatory => "--bar" }
     end
 
     it "should not skip when --foo=bar is given" do
       app.command_line.stubs(:args).returns %w{--mandatory=bar --bar foo}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --bar/
     end
 
     { "boolean options before" => %w{--trace foo},
       "boolean options after"  => %w{foo --trace}
     }.each do |name, args|
       it "should accept global boolean settings #{name} the action" do
         app.command_line.stubs(:args).returns args
         app.preinit
         app.parse_options
         Puppet[:trace].should be_true
       end
     end
 
     { "before" => %w{--syslogfacility user1 foo},
       " after" => %w{foo --syslogfacility user1}
     }.each do |name, args|
       it "should accept global settings with arguments #{name} the action" do
         app.command_line.stubs(:args).returns args
         app.preinit
         app.parse_options
         Puppet[:syslogfacility].should == "user1"
       end
     end
 
     it "should handle application-level options", :'fails_on_ruby_1.9.2' => true do
       app.command_line.stubs(:args).returns %w{--verbose return_true}
       app.preinit
       app.parse_options
       app.face.name.should == :basetest
     end
   end
 
   describe "#setup" do
     it "should remove the action name from the arguments" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
       app.preinit
       app.parse_options
       app.setup
       app.arguments.should == [{ :mandatory => "--bar" }]
     end
 
     it "should pass positional arguments" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo bar baz quux}
       app.preinit
       app.parse_options
       app.setup
       app.arguments.should == ['bar', 'baz', 'quux', { :mandatory => "--bar" }]
     end
   end
 
   describe "#main" do
     before :each do
       app.stubs(:puts)          # don't dump text to screen.
 
       app.face      = Puppet::Face[:basetest, '0.0.1']
       app.action    = app.face.get_action(:foo)
       app.arguments = ["myname", "myarg"]
     end
 
     it "should send the specified verb and name to the face" do
       app.face.expects(:foo).with(*app.arguments)
       expect { app.main }.to exit_with 0
     end
 
     it "should lookup help when it cannot do anything else" do
       app.action = nil
       Puppet::Face[:help, :current].expects(:help).with(:basetest)
       expect { app.main }.to exit_with 1
     end
 
     it "should use its render method to render any result" do
-      app.expects(:render).with(app.arguments.length + 1)
+      app.expects(:render).with(app.arguments.length + 1, ["myname", "myarg"])
       expect { app.main }.to exit_with 0
     end
   end
 
   describe "error reporting" do
     before :each do
       app.stubs(:puts)          # don't dump text to screen.
 
       app.render_as = :json
       app.face      = Puppet::Face[:basetest, '0.0.1']
       app.arguments = [{}]      # we always have options in there...
     end
 
     it "should exit 0 when the action returns true" do
       app.action    = app.face.get_action :return_true
       expect { app.main }.to exit_with 0
     end
 
     it "should exit 0 when the action returns false" do
       app.action = app.face.get_action :return_false
       expect { app.main }.to exit_with 0
     end
 
     it "should exit 0 when the action returns nil" do
       app.action = app.face.get_action :return_nil
       expect { app.main }.to exit_with 0
     end
 
     it "should exit non-0 when the action raises" do
       app.action = app.face.get_action :return_raise
       expect { app.main }.not_to exit_with 0
     end
   end
 
   describe "#render" do
     before :each do
       app.face      = Puppet::Face[:basetest, '0.0.1']
       app.action    = app.face.get_action(:foo)
     end
 
     context "default rendering" do
       before :each do app.setup end
 
       ["hello", 1, 1.0].each do |input|
         it "should just return a #{input.class.name}" do
-          app.render(input).should == input
+          app.render(input, {}).should == input
         end
       end
 
       [[1, 2], ["one"], [{ 1 => 1 }]].each do |input|
         it "should render #{input.class} using JSON" do
-          app.render(input).should == input.to_pson.chomp
+          app.render(input, {}).should == input.to_pson.chomp
         end
       end
 
       it "should render a non-trivially-keyed Hash with using JSON" do
         hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
-        app.render(hash).should == hash.to_pson.chomp
+        app.render(hash, {}).should == hash.to_pson.chomp
       end
 
       it "should render a {String,Numeric}-keyed Hash into a table" do
         object = Object.new
         hash = { "one" => 1, "two" => [], "three" => {}, "four" => object,
           5 => 5, 6.0 => 6 }
 
         # Gotta love ASCII-betical sort order.  Hope your objects are better
         # structured for display than my test one is. --daniel 2011-04-18
-        app.render(hash).should == <<EOT
+        app.render(hash, {}).should == <<EOT
 5      5
 6.0    6
 four   #{object.to_pson.chomp}
 one    1
 three  {}
 two    []
 EOT
       end
 
       it "should render a hash nicely with a multi-line value" do
         pending "Moving to PSON rather than PP makes this unsupportable."
         hash = {
           "number" => { "1" => '1' * 40, "2" => '2' * 40, '3' => '3' * 40 },
           "text"   => { "a" => 'a' * 40, 'b' => 'b' * 40, 'c' => 'c' * 40 }
         }
-        app.render(hash).should == <<EOT
+        app.render(hash, {}).should == <<EOT
 number  {"1"=>"1111111111111111111111111111111111111111",
          "2"=>"2222222222222222222222222222222222222222",
          "3"=>"3333333333333333333333333333333333333333"}
 text    {"a"=>"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
          "b"=>"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
          "c"=>"cccccccccccccccccccccccccccccccccccccccc"}
 EOT
       end
 
-      it "should invoke the action rendering hook while rendering" do
-        app.action.set_rendering_method_for(:console, proc { |value| "bi-winning!" })
-        app.render("bi-polar?").should == "bi-winning!"
+      describe "when setting the rendering method" do
+        after do
+          # need to reset the when_rendering block so that other tests can set it later
+          app.action.instance_variable_set("@when_rendering", {})
+        end
+
+        it "should invoke the action rendering hook while rendering" do
+          app.action.set_rendering_method_for(:console, proc { |value| "bi-winning!" })
+          app.render("bi-polar?", {}).should == "bi-winning!"
+        end
+
+        it "should invoke the action rendering hook with args and options while rendering" do
+          app.action.instance_variable_set("@when_rendering", {})
+          app.action.when_invoked = proc { |name, options| 'just need to match arity for rendering' }
+          app.action.set_rendering_method_for(
+            :console,
+            proc { |value, name, options| "I'm #{name}, no wait, I'm #{options[:altername]}" }
+          )
+          app.render("bi-polar?", ['bob', {:altername => 'sue'}]).should == "I'm bob, no wait, I'm sue"
+        end
       end
 
       it "should render JSON when asked for json" do
         app.render_as = :json
-        json = app.render({ :one => 1, :two => 2 })
+        json = app.render({ :one => 1, :two => 2 }, {})
         json.should =~ /"one":\s*1\b/
         json.should =~ /"two":\s*2\b/
         PSON.parse(json).should == { "one" => 1, "two" => 2 }
       end
     end
 
     it "should fail early if asked to render an invalid format" do
       app.command_line.stubs(:args).returns %w{--render-as interpretive-dance return_true}
       # We shouldn't get here, thanks to the exception, and our expectation on
       # it, but this helps us fail if that slips up and all. --daniel 2011-04-27
       Puppet::Face[:help, :current].expects(:help).never
 
       expect {
         expect { app.run }.to exit_with 1
       }.to have_printed(/I don't know how to render 'interpretive-dance'/)
     end
 
     it "should work if asked to render a NetworkHandler format" do
       app.command_line.stubs(:args).returns %w{count_args a b c --render-as yaml}
       expect {
         expect { app.run }.to exit_with 0
       }.to have_printed(/--- 3/)
     end
 
     it "should invoke when_rendering hook 's' when asked to render-as 's'" do
       app.command_line.stubs(:args).returns %w{with_s_rendering_hook --render-as s}
       app.action = app.face.get_action(:with_s_rendering_hook)
       expect {
         expect { app.run }.to exit_with 0
       }.to have_printed(/you invoked the 's' rendering hook/)
     end
   end
 end
diff --git a/spec/unit/interface/action_builder_spec.rb b/spec/unit/interface/action_builder_spec.rb
index 602daaaca..f779a5461 100755
--- a/spec/unit/interface/action_builder_spec.rb
+++ b/spec/unit/interface/action_builder_spec.rb
@@ -1,214 +1,216 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/interface/action_builder'
 require 'puppet/network/format_handler'
 
 describe Puppet::Interface::ActionBuilder do
   let :face do Puppet::Interface.new(:puppet_interface_actionbuilder, '0.0.1') end
 
   it "should build an action" do
     action = Puppet::Interface::ActionBuilder.build(face, :foo) do
       when_invoked do |options| true end
     end
     action.should be_a(Puppet::Interface::Action)
     action.name.should == :foo
   end
 
   it "should define a method on the face which invokes the action" do
     face = Puppet::Interface.new(:action_builder_test_interface, '0.0.1') do
       action(:foo) { when_invoked { |options| "invoked the method" } }
     end
 
     face.foo.should == "invoked the method"
   end
 
   it "should require a block" do
     expect { Puppet::Interface::ActionBuilder.build(nil, :foo) }.
       should raise_error("Action :foo must specify a block")
   end
 
   it "should require an invocation block" do
     expect {
       Puppet::Interface::ActionBuilder.build(face, :foo) {}
     }.to raise_error(/actions need to know what to do when_invoked; please add the block/)
   end
 
   describe "when handling options" do
     it "should have a #option DSL function" do
       method = nil
       Puppet::Interface::ActionBuilder.build(face, :foo) do
         when_invoked do |options| true end
         method = self.method(:option)
       end
       method.should be_an_instance_of Method
     end
 
     it "should define an option without a block" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         when_invoked do |options| true end
         option "--bar"
       end
       action.should be_option :bar
     end
 
     it "should accept an empty block" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         when_invoked do |options| true end
         option "--bar" do
           # This space left deliberately blank.
         end
       end
       action.should be_option :bar
     end
   end
 
   context "inline documentation" do
     it "should set the summary" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         when_invoked do |options| true end
         summary "this is some text"
       end
       action.summary.should == "this is some text"
     end
   end
 
   context "action defaulting" do
     it "should set the default to true" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         when_invoked do |options| true end
         default
       end
       action.default.should be_true
     end
 
     it "should not be default by, er, default. *cough*" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         when_invoked do |options| true end
       end
       action.default.should be_false
     end
   end
 
   context "#when_rendering" do
     it "should fail if no rendering format is given" do
       expect {
         Puppet::Interface::ActionBuilder.build(face, :foo) do
           when_invoked do |options| true end
           when_rendering do true end
         end
       }.to raise_error ArgumentError, /must give a rendering format to when_rendering/
     end
 
     it "should fail if no block is given" do
       expect {
         Puppet::Interface::ActionBuilder.build(face, :foo) do
           when_invoked do |options| true end
           when_rendering :json
         end
       }.to raise_error ArgumentError, /must give a block to when_rendering/
     end
 
     it "should fail if the block takes no arguments" do
       expect {
         Puppet::Interface::ActionBuilder.build(face, :foo) do
           when_invoked do |options| true end
           when_rendering :json do true end
         end
-      }.to raise_error ArgumentError, /when_rendering methods take one argument, the result, not/
+      }.to raise_error ArgumentError,
+        /the puppet_interface_actionbuilder face foo action takes .* not/
     end
 
-    it "should fail if the block takes more than one argument" do
+    it "should fail if the when_rendering block takes a different number of arguments than when_invoked" do
       expect {
         Puppet::Interface::ActionBuilder.build(face, :foo) do
           when_invoked do |options| true end
           when_rendering :json do |a, b, c| true end
         end
-      }.to raise_error ArgumentError, /when_rendering methods take one argument, the result, not/
+      }.to raise_error ArgumentError,
+        /the puppet_interface_actionbuilder face foo action takes .* not 3/
     end
 
     it "should fail if the block takes a variable number of arguments" do
       expect {
         Puppet::Interface::ActionBuilder.build(face, :foo) do
           when_invoked do |options| true end
           when_rendering :json do |*args| true end
         end
-      }.to raise_error(ArgumentError,
-                       /when_rendering methods take one argument, the result, not/)
+      }.to raise_error ArgumentError,
+        /the puppet_interface_actionbuilder face foo action takes .* not/
     end
 
     it "should stash a rendering block" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         when_invoked do |options| true end
         when_rendering :json do |a| true end
       end
       action.when_rendering(:json).should be_an_instance_of Method
     end
 
     it "should fail if you try to set the same rendering twice" do
       expect {
         Puppet::Interface::ActionBuilder.build(face, :foo) do
           when_invoked do |options| true end
           when_rendering :json do |a| true end
           when_rendering :json do |a| true end
         end
       }.to raise_error ArgumentError, /You can't define a rendering method for json twice/
     end
 
     it "should work if you set two different renderings" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         when_invoked do |options| true end
         when_rendering :json do |a| true end
         when_rendering :yaml do |a| true end
       end
       action.when_rendering(:json).should be_an_instance_of Method
       action.when_rendering(:yaml).should be_an_instance_of Method
     end
 
     it "should be bound to the face when called" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         when_invoked do |options| true end
         when_rendering :json do |a| self end
       end
       action.when_rendering(:json).call(true).should == face
     end
   end
 
   context "#render_as" do
     it "should default to nil (eg: based on context)" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         when_invoked do |options| true end
       end
       action.render_as.should be_nil
     end
 
     it "should fail if not rendering format is given" do
       expect {
         Puppet::Interface::ActionBuilder.build(face, :foo) do
           when_invoked do |options| true end
           render_as
         end
       }.to raise_error ArgumentError, /must give a rendering format to render_as/
     end
 
     Puppet::Network::FormatHandler.formats.each do |name|
       it "should accept #{name.inspect} format" do
         action = Puppet::Interface::ActionBuilder.build(face, :foo) do
           when_invoked do |options| true end
           render_as name
         end
         action.render_as.should == name
       end
     end
 
     [:if_you_define_this_format_you_frighten_me, "json", 12].each do |input|
       it "should fail if given #{input.inspect}" do
         expect {
           Puppet::Interface::ActionBuilder.build(face, :foo) do
             when_invoked do |options| true end
             render_as input
           end
         }.to raise_error ArgumentError, /#{input.inspect} is not a valid rendering format/
       end
     end
   end
 end