diff --git a/lib/puppet/application/resource.rb b/lib/puppet/application/resource.rb
index b1a3f8887..c9a84f390 100644
--- a/lib/puppet/application/resource.rb
+++ b/lib/puppet/application/resource.rb
@@ -1,230 +1,237 @@
 require 'puppet/application'
 
 class Puppet::Application::Resource < Puppet::Application
 
   should_not_parse_config
 
   attr_accessor :host, :extra_params
 
   def preinit
     @extra_params = []
-    @host = nil
     Facter.loadfacts
   end
 
   option("--debug","-d")
   option("--verbose","-v")
   option("--edit","-e")
 
   option("--host HOST","-H") do |arg|
     @host = arg
   end
 
   option("--types", "-t") do |arg|
     types = []
     Puppet::Type.loadall
     Puppet::Type.eachtype do |t|
       next if t.name == :component
       types << t.name.to_s
     end
     puts types.sort
     exit
   end
 
   option("--param PARAM", "-p") do |arg|
     @extra_params << arg.to_sym
   end
 
   def help
     <<-HELP
 
 puppet-resource(8) -- The resource abstraction layer shell
 ========
 
 SYNOPSIS
 --------
 Uses the Puppet RAL to directly interact with the system.
 
 
 USAGE
 -----
 puppet resource [-h|--help] [-d|--debug] [-v|--verbose] [-e|--edit]
   [-H|--host <host>] [-p|--param <parameter>] [-t|--types] <type>
   [<name>] [<attribute>=<value> ...]
 
 
 DESCRIPTION
 -----------
 This command provides simple facilities for converting current system
 state into Puppet code, along with some ability to modify the current
 state using Puppet's RAL.
 
 By default, you must at least provide a type to list, in which case
 puppet resource will tell you everything it knows about all resources of
 that type. You can optionally specify an instance name, and puppet
 resource will only describe that single instance.
 
 If given a type, a name, and a series of <attribute>=<value> pairs,
 puppet resource will modify the state of the specified resource.
 Alternately, if given a type, a name, and the '--edit' flag, puppet
 resource will write its output to a file, open that file in an editor,
 and then apply the saved file as a Puppet transaction.
 
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'ssldir' is a valid
 configuration parameter, so you can specify '--ssldir <directory>' 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'.
 
 * --debug:
   Enable full debugging.
 
 * --edit:
   Write the results of the query to a file, open the file in an editor,
   and read the file back in as an executable Puppet manifest.
 
 * --host:
   When specified, connect to the resource server on the named host
   and retrieve the list of resouces of the type specified.
 
 * --help:
   Print this help message.
 
 * --param:
   Add more parameters to be outputted from queries.
 
 * --types:
   List all available types.
 
 * --verbose:
   Print extra information.
 
 
 EXAMPLE
 -------
 This example uses `puppet resource` to return a Puppet configuration for
 the user `luke`:
 
     $ puppet resource user luke
     user { 'luke':
      home => '/home/luke',
      uid => '100',
      ensure => 'present',
      comment => 'Luke Kanies,,,',
      gid => '1000',
      shell => '/bin/bash',
      groups => ['sysadmin','audio','video','puppet']
     }
 
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
   def main
-    args = command_line.args
+    type, name, params = parse_args(command_line.args)
+
+    raise "You cannot edit a remote host" if options[:edit] and @host
+
+    resources = find_or_save_resources(type, name, params)
+    text = resources.
+      map { |resource| resource.prune_parameters(:parameters_to_include => @extra_params).to_manifest }.
+      join("\n")
+
+    options[:edit] ?
+      handle_editing(text) :
+      (puts text)
+  end
+
+  def setup
+    Puppet::Util::Log.newdestination(:console)
+
+    Puppet.parse_config
+
+    if options[:debug]
+      Puppet::Util::Log.level = :debug
+    elsif options[:verbose]
+      Puppet::Util::Log.level = :info
+    end
+  end
+
+  private
+
+  def remote_key(type, name)
+    Puppet::Resource.indirection.terminus_class = :rest
+    port = Puppet[:puppetport]
+    ["https://#{@host}:#{port}", "production", "resources", type, name].join('/')
+  end
+
+  def local_key(type, name)
+    [type, name].join('/')
+  end
+
+  def handle_editing(text)
+    require 'tempfile'
+    # Prefer the current directory, which is more likely to be secure
+    # and, in the case of interactive use, accessible to the user.
+    tmpfile = Tempfile.new('x2puppet', Dir.pwd)
+    begin
+      # sync write, so nothing buffers before we invoke the editor.
+      tmpfile.sync = true
+      tmpfile.puts text
+
+      # edit the content
+      system(ENV["EDITOR"] || 'vi', tmpfile.path)
+
+      # ...and, now, pass that file to puppet to apply.  Because
+      # many editors rename or replace the original file we need to
+      # feed the pathname, not the file content itself, to puppet.
+      system('puppet apply -v ' + tmpfile.path)
+    ensure
+      # The temporary file will be safely removed.
+      tmpfile.close(true)
+    end
+  end
+
+  def parse_args(args)
     type = args.shift or raise "You must specify the type to display"
-    typeobj = Puppet::Type.type(type) or raise "Could not find type #{type}"
+    Puppet::Type.type(type) or raise "Could not find type #{type}"
     name = args.shift
     params = {}
     args.each do |setting|
       if setting =~ /^(\w+)=(.+)$/
         params[$1] = $2
       else
         raise "Invalid parameter setting #{setting}"
       end
     end
 
-    raise "You cannot edit a remote host" if options[:edit] and @host
-
-    properties = typeobj.properties.collect { |s| s.name }
-
-    format = proc {|trans|
-      trans.dup.collect do |param, value|
-        if value.nil? or value.to_s.empty?
-          trans.delete(param)
-        elsif value.to_s == "absent" and param.to_s != "ensure"
-          trans.delete(param)
-        end
-
-        trans.delete(param) unless properties.include?(param) or @extra_params.include?(param)
-      end
-      trans.to_manifest
-    }
+    [type, name, params]
+  end
 
-    if @host
-      Puppet::Resource.indirection.terminus_class = :rest
-      port = Puppet[:puppetport]
-      key = ["https://#{host}:#{port}", "production", "resources", type, name].join('/')
-    else
-      key = [type, name].join('/')
-    end
+  def find_or_save_resources(type, name, params)
+    key = @host ? remote_key(type, name) : local_key(type, name)
 
-    text = if name
+    if name
       if params.empty?
         [ Puppet::Resource.indirection.find( key ) ]
       else
-        [ Puppet::Resource.indirection.save(Puppet::Resource.new( type, name, :parameters => params ), key) ]
+        resource = Puppet::Resource.new( type, name, :parameters => params )
+
+        # save returns [resource that was saved, transaction log from applying the resource]
+        save_result = Puppet::Resource.indirection.save(resource, key)
+        [ save_result.first ]
       end
     else
       if type == "file"
         raise "Listing all file instances is not supported.  Please specify a file or directory, e.g. puppet resource file /etc"
       end
       Puppet::Resource.indirection.search( key, {} )
-    end.map(&format).join("\n")
-
-    if options[:edit]
-      require 'tempfile'
-      # Prefer the current directory, which is more likely to be secure
-      # and, in the case of interactive use, accessible to the user.
-      tmpfile = Tempfile.new('x2puppet', Dir.pwd)
-      begin
-        # sync write, so nothing buffers before we invoke the editor.
-        tmpfile.sync = true
-        tmpfile.puts text
-
-        # edit the content
-        system(ENV["EDITOR"] || 'vi', tmpfile.path)
-
-        # ...and, now, pass that file to puppet to apply.  Because
-        # many editors rename or replace the original file we need to
-        # feed the pathname, not the file content itself, to puppet.
-        system('puppet -v ' + tmpfile.path)
-      ensure
-        # The temporary file will be safely removed.
-        tmpfile.close(true)
-      end
-    else
-      puts text
-    end
-  end
-
-  def setup
-    Puppet::Util::Log.newdestination(:console)
-
-    # Now parse the config
-    Puppet.parse_config
-
-    if options[:debug]
-      Puppet::Util::Log.level = :debug
-    elsif options[:verbose]
-      Puppet::Util::Log.level = :info
     end
   end
 end
diff --git a/lib/puppet/indirector/resource/ral.rb b/lib/puppet/indirector/resource/ral.rb
index bc41d14ae..b7f827a7c 100644
--- a/lib/puppet/indirector/resource/ral.rb
+++ b/lib/puppet/indirector/resource/ral.rb
@@ -1,53 +1,53 @@
 class Puppet::Resource::Ral < Puppet::Indirector::Code
   def find( request )
     # find by name
     res   = type(request).instances.find { |o| o.name == resource_name(request) }
     res ||= type(request).new(:name => resource_name(request), :audit => type(request).properties.collect { |s| s.name })
 
     res.to_resource
   end
 
   def search( request )
     conditions = request.options.dup
     conditions[:name] = resource_name(request) if resource_name(request)
 
     type(request).instances.map do |res|
       res.to_resource
     end.find_all do |res|
       conditions.all? {|property, value| res.to_resource[property].to_s == value.to_s}
     end.sort do |a,b|
       a.title <=> b.title
     end
   end
 
   def save( request )
     # In RAL-land, to "save" means to actually try to change machine state
     res = request.instance
     ral_res = res.to_ral
 
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource ral_res
-    catalog.apply
+    transaction = catalog.apply
 
-    ral_res.to_resource
+    [ral_res.to_resource, transaction.report]
   end
 
   private
 
   # {type,resource}_name: the resource name may contain slashes:
   # File["/etc/hosts"]. To handle, assume the type name does
   # _not_ have any slashes in it, and split only on the first.
 
   def type_name( request )
     request.key.split('/', 2)[0]
   end
 
   def resource_name( request )
     name = request.key.split('/', 2)[1]
     name unless name == ""
   end
 
   def type( request )
     Puppet::Type.type(type_name(request)) or raise Puppet::Error, "Could not find type #{type}"
   end
 end
diff --git a/lib/puppet/resource.rb b/lib/puppet/resource.rb
index 59e387d00..8e94a4c49 100644
--- a/lib/puppet/resource.rb
+++ b/lib/puppet/resource.rb
@@ -1,439 +1,455 @@
 require 'puppet'
 require 'puppet/util/tagging'
 require 'puppet/util/pson'
 
 # The simplest resource class.  Eventually it will function as the
 # base class for all resource-like behaviour.
 class Puppet::Resource
   # This stub class is only needed for serialization compatibility with 0.25.x.
   # Specifically, it exists to provide a compatibility API when using YAML
   # serialized objects loaded from StoreConfigs.
   Reference = Puppet::Resource
 
   include Puppet::Util::Tagging
 
   require 'puppet/resource/type_collection_helper'
   include Puppet::Resource::TypeCollectionHelper
 
   extend Puppet::Util::Pson
   include Enumerable
   attr_accessor :file, :line, :catalog, :exported, :virtual, :validate_parameters, :strict
   attr_reader :type, :title
 
   require 'puppet/indirector'
   extend Puppet::Indirector
   indirects :resource, :terminus_class => :ral
 
   ATTRIBUTES = [:file, :line, :exported]
 
   def self.from_pson(pson)
     raise ArgumentError, "No resource type provided in pson data" unless type = pson['type']
     raise ArgumentError, "No resource title provided in pson data" unless title = pson['title']
 
     resource = new(type, title)
 
     if params = pson['parameters']
       params.each { |param, value| resource[param] = value }
     end
 
     if tags = pson['tags']
       tags.each { |tag| resource.tag(tag) }
     end
 
     ATTRIBUTES.each do |a|
       if value = pson[a.to_s]
         resource.send(a.to_s + "=", value)
       end
     end
 
     resource.exported ||= false
 
     resource
   end
 
   def inspect
     "#{@type}[#{@title}]#{to_hash.inspect}"
   end
 
   def to_pson_data_hash
     data = ([:type, :title, :tags] + ATTRIBUTES).inject({}) do |hash, param|
       next hash unless value = self.send(param)
       hash[param.to_s] = value
       hash
     end
 
     data["exported"] ||= false
 
     params = self.to_hash.inject({}) do |hash, ary|
       param, value = ary
 
       # Don't duplicate the title as the namevar
       next hash if param == namevar and value == title
 
       hash[param] = Puppet::Resource.value_to_pson_data(value)
       hash
     end
 
     data["parameters"] = params unless params.empty?
 
     data
   end
 
   def self.value_to_pson_data(value)
     if value.is_a? Array
       value.map{|v| value_to_pson_data(v) }
     elsif value.is_a? Puppet::Resource
       value.to_s
     else
       value
     end
   end
 
   def yaml_property_munge(x)
     case x
     when Hash
       x.inject({}) { |h,kv|
         k,v = kv
         h[k] = self.class.value_to_pson_data(v)
         h
       }
     else self.class.value_to_pson_data(x)
     end
   end
 
   def to_pson(*args)
     to_pson_data_hash.to_pson(*args)
   end
 
   # Proxy these methods to the parameters hash.  It's likely they'll
   # be overridden at some point, but this works for now.
   %w{has_key? keys length delete empty? <<}.each do |method|
     define_method(method) do |*args|
       parameters.send(method, *args)
     end
   end
 
   # Set a given parameter.  Converts all passed names
   # to lower-case symbols.
   def []=(param, value)
     validate_parameter(param) if validate_parameters
     parameters[parameter_name(param)] = value
   end
 
   # Return a given parameter's value.  Converts all passed names
   # to lower-case symbols.
   def [](param)
     parameters[parameter_name(param)]
   end
 
   def ==(other)
     return false unless other.respond_to?(:title) and self.type == other.type and self.title == other.title
 
     return false unless to_hash == other.to_hash
     true
   end
 
   # Compatibility method.
   def builtin?
     builtin_type?
   end
 
   # Is this a builtin resource type?
   def builtin_type?
     resource_type.is_a?(Class)
   end
 
   # Iterate over each param/value pair, as required for Enumerable.
   def each
     parameters.each { |p,v| yield p, v }
   end
 
   def include?(parameter)
     super || parameters.keys.include?( parameter_name(parameter) )
   end
 
   # These two methods are extracted into a Helper
   # module, but file load order prevents me
   # from including them in the class, and I had weird
   # behaviour (i.e., sometimes it didn't work) when
   # I directly extended each resource with the helper.
   def environment
     Puppet::Node::Environment.new(@environment)
   end
 
   def environment=(env)
     if env.is_a?(String) or env.is_a?(Symbol)
       @environment = env
     else
       @environment = env.name
     end
   end
 
   %w{exported virtual strict}.each do |m|
     define_method(m+"?") do
       self.send(m)
     end
   end
 
   # Create our resource.
   def initialize(type, title = nil, attributes = {})
     @parameters = {}
 
     # Set things like strictness first.
     attributes.each do |attr, value|
       next if attr == :parameters
       send(attr.to_s + "=", value)
     end
 
     @type, @title = extract_type_and_title(type, title)
 
     @type = munge_type_name(@type)
 
     if @type == "Class"
       @title = :main if @title == ""
       @title = munge_type_name(@title)
     end
 
     if params = attributes[:parameters]
       extract_parameters(params)
     end
 
     tag(self.type)
     tag(self.title) if valid_tag?(self.title)
 
     @reference = self # for serialization compatibility with 0.25.x
     if strict? and ! resource_type
       if @type == 'Class'
         raise ArgumentError, "Could not find declared class #{title}"
       else
         raise ArgumentError, "Invalid resource type #{type}"
       end
     end
   end
 
   def ref
     to_s
   end
 
   # Find our resource.
   def resolve
     return(catalog ? catalog.resource(to_s) : nil)
   end
 
   def resource_type
     case type
     when "Class"; known_resource_types.hostclass(title == :main ? "" : title)
     when "Node"; known_resource_types.node(title)
     else
       Puppet::Type.type(type.to_s.downcase.to_sym) || known_resource_types.definition(type)
     end
   end
 
   # Produce a simple hash of our parameters.
   def to_hash
     parse_title.merge parameters
   end
 
   def to_s
     "#{type}[#{title}]"
   end
 
   def uniqueness_key
     # Temporary kludge to deal with inconsistant use patters
     h = self.to_hash
     h[namevar] ||= h[:name]
     h[:name]   ||= h[namevar]
     h.values_at(*key_attributes.sort_by { |k| k.to_s })
   end
 
   def key_attributes
     return(resource_type.respond_to? :key_attributes) ? resource_type.key_attributes : [:name]
   end
 
   # Convert our resource to Puppet code.
   def to_manifest
     # Collect list of attributes to align => and move ensure first
     attr = parameters.keys
     attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max }
 
     attr.sort!
     if attr.first != :ensure  && attr.include?(:ensure)
       attr.delete(:ensure)
       attr.unshift(:ensure)
     end
 
     attributes = attr.collect { |k|
       v = parameters[k]
       if v.is_a? Array
         "  %-#{attr_max}s => %s,\n" % [ k, "[\'#{v.join("', '")}\']" ]
       else
         "  %-#{attr_max}s => %s,\n" % [ k, "\'#{v}\'" ]
       end
     }.join
 
     "%s { '%s':\n%s}" % [self.type.to_s.downcase, self.title, attributes]
   end
 
   def to_ref
     ref
   end
 
   # Convert our resource to a RAL resource instance.  Creates component
   # instances for resource types that don't exist.
   def to_ral
     if typeklass = Puppet::Type.type(self.type)
       return typeklass.new(self)
     else
       return Puppet::Type::Component.new(self)
     end
   end
 
   # Translate our object to a backward-compatible transportable object.
   def to_trans
     if builtin_type? and type.downcase.to_s != "stage"
       result = to_transobject
     else
       result = to_transbucket
     end
 
     result.file = self.file
     result.line = self.line
 
     result
   end
 
   def to_trans_ref
     [type.to_s, title.to_s]
   end
 
   # Create an old-style TransObject instance, for builtin resource types.
   def to_transobject
     # Now convert to a transobject
     result = Puppet::TransObject.new(title, type)
     to_hash.each do |p, v|
       if v.is_a?(Puppet::Resource)
         v = v.to_trans_ref
       elsif v.is_a?(Array)
         v = v.collect { |av|
           av = av.to_trans_ref if av.is_a?(Puppet::Resource)
           av
         }
       end
 
       # If the value is an array with only one value, then
       # convert it to a single value.  This is largely so that
       # the database interaction doesn't have to worry about
       # whether it returns an array or a string.
       result[p.to_s] = if v.is_a?(Array) and v.length == 1
         v[0]
           else
             v
               end
     end
 
     result.tags = self.tags
 
     result
   end
 
   def name
     # this is potential namespace conflict
     # between the notion of an "indirector name"
     # and a "resource name"
     [ type, title ].join('/')
   end
 
   def to_resource
     self
   end
 
   def valid_parameter?(name)
     resource_type.valid_parameter?(name)
   end
 
   def validate_parameter(name)
     raise ArgumentError, "Invalid parameter #{name}" unless valid_parameter?(name)
   end
 
+  def prune_parameters(options = {})
+    properties = resource_type.properties.map(&:name)
+
+    dup.collect do |attribute, value|
+      if value.nil? or value.to_s.empty?
+        delete(attribute)
+      elsif value.to_s == "absent" and attribute.to_s != "ensure"
+        delete(attribute)
+      end
+
+      parameters_to_include = options[:parameters_to_include] || []
+      delete(attribute) unless properties.include?(attribute) || parameters_to_include.include?(attribute)
+    end
+    self
+  end
+
   private
 
   # Produce a canonical method name.
   def parameter_name(param)
     param = param.to_s.downcase.to_sym
     if param == :name and n = namevar
       param = namevar
     end
     param
   end
 
   # The namevar for our resource type. If the type doesn't exist,
   # always use :name.
   def namevar
     if builtin_type? and t = resource_type and t.key_attributes.length == 1
       t.key_attributes.first
     else
       :name
     end
   end
 
   # Create an old-style TransBucket instance, for non-builtin resource types.
   def to_transbucket
     bucket = Puppet::TransBucket.new([])
 
     bucket.type = self.type
     bucket.name = self.title
 
     # TransBuckets don't support parameters, which is why they're being deprecated.
     bucket
   end
 
   def extract_parameters(params)
     params.each do |param, value|
       validate_parameter(param) if strict?
       self[param] = value
     end
   end
 
   def extract_type_and_title(argtype, argtitle)
     if    (argtitle || argtype) =~ /^([^\[\]]+)\[(.+)\]$/m then [ $1,                 $2            ]
     elsif argtitle                                         then [ argtype,            argtitle      ]
     elsif argtype.is_a?(Puppet::Type)                      then [ argtype.class.name, argtype.title ]
     elsif argtype.is_a?(Hash)                              then
       raise ArgumentError, "Puppet::Resource.new does not take a hash as the first argument. "+
         "Did you mean (#{(argtype[:type] || argtype["type"]).inspect}, #{(argtype[:title] || argtype["title"]).inspect }) ?"
     else raise ArgumentError, "No title provided and #{argtype.inspect} is not a valid resource reference"
     end
   end
 
   def munge_type_name(value)
     return :main if value == :main
     return "Class" if value == "" or value.nil? or value.to_s.downcase == "component"
 
     value.to_s.split("::").collect { |s| s.capitalize }.join("::")
   end
 
   def parse_title
     h = {}
     type = resource_type
     if type.respond_to? :title_patterns
       type.title_patterns.each { |regexp, symbols_and_lambdas|
         if captures = regexp.match(title.to_s)
           symbols_and_lambdas.zip(captures[1..-1]).each { |symbol_and_lambda,capture|
             sym, lam = symbol_and_lambda
             #self[sym] = lam.call(capture)
             h[sym] = lam.call(capture)
           }
           return h
         end
       }
     else
       return { :name => title.to_s }
     end
   end
 
   def parameters
     # @parameters could have been loaded from YAML, causing it to be nil (by
     # bypassing initialize).
     @parameters ||= {}
   end
 end
diff --git a/spec/unit/application/resource_spec.rb b/spec/unit/application/resource_spec.rb
index b6ed8598d..79935cc6a 100755
--- a/spec/unit/application/resource_spec.rb
+++ b/spec/unit/application/resource_spec.rb
@@ -1,250 +1,211 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/resource'
 
 describe Puppet::Application::Resource do
   before :each do
-    @resource = Puppet::Application[:resource]
+    @resource_app = Puppet::Application[:resource]
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Resource.indirection.stubs(:terminus_class=)
   end
 
   it "should ask Puppet::Application to not parse Puppet configuration file" do
-    @resource.should_parse_config?.should be_false
-  end
-
-  it "should declare a main command" do
-    @resource.should respond_to(:main)
-  end
-
-  it "should declare a host option" do
-    @resource.should respond_to(:handle_host)
-  end
-
-  it "should declare a types option" do
-    @resource.should respond_to(:handle_types)
-  end
-
-  it "should declare a param option" do
-    @resource.should respond_to(:handle_param)
-  end
-
-  it "should declare a preinit block" do
-    @resource.should respond_to(:preinit)
+    @resource_app.should_parse_config?.should be_false
   end
 
   describe "in preinit" do
-    it "should set hosts to nil", :'fails_on_ruby_1.9.2' => true do
-      @resource.preinit
-
-      @resource.host.should be_nil
-    end
-
     it "should init extra_params to empty array", :'fails_on_ruby_1.9.2' => true do
-      @resource.preinit
-
-      @resource.extra_params.should == []
+      @resource_app.preinit
+      @resource_app.extra_params.should == []
     end
 
     it "should load Facter facts" do
       Facter.expects(:loadfacts).once
-      @resource.preinit
+      @resource_app.preinit
     end
   end
 
   describe "when handling options" do
-
     [:debug, :verbose, :edit].each do |option|
-      it "should declare handle_#{option} method" do
-        @resource.should respond_to("handle_#{option}".to_sym)
-      end
-
       it "should store argument value when calling handle_#{option}" do
-        @resource.options.expects(:[]=).with(option, 'arg')
-        @resource.send("handle_#{option}".to_sym, 'arg')
+        @resource_app.options.expects(:[]=).with(option, 'arg')
+        @resource_app.send("handle_#{option}".to_sym, 'arg')
       end
     end
 
     it "should set options[:host] to given host" do
-      @resource.handle_host(:whatever)
-
-      @resource.host.should == :whatever
+      @resource_app.handle_host(:whatever)
+      @resource_app.host.should == :whatever
     end
 
     it "should load an display all types with types option" do
       type1 = stub_everything 'type1', :name => :type1
       type2 = stub_everything 'type2', :name => :type2
       Puppet::Type.stubs(:loadall)
       Puppet::Type.stubs(:eachtype).multiple_yields(type1,type2)
-      @resource.expects(:puts).with(['type1','type2'])
-      expect { @resource.handle_types(nil) }.to exit_with 0
+      @resource_app.expects(:puts).with(['type1','type2'])
+      expect { @resource_app.handle_types(nil) }.to exit_with 0
     end
 
     it "should add param to extra_params list" do
-      @resource.extra_params = [ :param1 ]
-      @resource.handle_param("whatever")
+      @resource_app.extra_params = [ :param1 ]
+      @resource_app.handle_param("whatever")
 
-      @resource.extra_params.should == [ :param1, :whatever ]
+      @resource_app.extra_params.should == [ :param1, :whatever ]
     end
   end
 
   describe "during setup" do
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet.stubs(:parse_config)
     end
 
-
     it "should set console as the log destination" do
       Puppet::Log.expects(:newdestination).with(:console)
 
-      @resource.setup
+      @resource_app.setup
     end
 
     it "should set log level to debug if --debug was passed" do
-      @resource.options.stubs(:[]).with(:debug).returns(true)
-      @resource.setup
+      @resource_app.options.stubs(:[]).with(:debug).returns(true)
+      @resource_app.setup
       Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
-      @resource.options.stubs(:[]).with(:debug).returns(false)
-      @resource.options.stubs(:[]).with(:verbose).returns(true)
-      @resource.setup
+      @resource_app.options.stubs(:[]).with(:debug).returns(false)
+      @resource_app.options.stubs(:[]).with(:verbose).returns(true)
+      @resource_app.setup
       Puppet::Log.level.should == :info
     end
 
     it "should Parse puppet config" do
       Puppet.expects(:parse_config)
 
-      @resource.setup
+      @resource_app.setup
     end
   end
 
   describe "when running" do
-
     before :each do
       @type = stub_everything 'type', :properties => []
-      @resource.command_line.stubs(:args).returns(['type'])
+      @resource_app.command_line.stubs(:args).returns(['mytype'])
       Puppet::Type.stubs(:type).returns(@type)
+
+      @res = stub_everything "resource"
+      @res.stubs(:prune_parameters).returns(@res)
+      @report = stub_everything "report"
     end
 
     it "should raise an error if no type is given" do
-      @resource.command_line.stubs(:args).returns([])
-      lambda { @resource.main }.should raise_error
+      @resource_app.command_line.stubs(:args).returns([])
+      lambda { @resource_app.main }.should raise_error(RuntimeError, "You must specify the type to display")
     end
 
     it "should raise an error when editing a remote host" do
-      @resource.options.stubs(:[]).with(:edit).returns(true)
-      @resource.host = 'host'
+      @resource_app.options.stubs(:[]).with(:edit).returns(true)
+      @resource_app.host = 'host'
 
-      lambda { @resource.main }.should raise_error
+      lambda { @resource_app.main }.should raise_error(RuntimeError, "You cannot edit a remote host")
     end
 
     it "should raise an error if the type is not found" do
       Puppet::Type.stubs(:type).returns(nil)
 
-      lambda { @resource.main }.should raise_error
+      lambda { @resource_app.main }.should raise_error(RuntimeError, 'Could not find type mytype')
     end
 
     describe "with a host" do
       before :each do
-        @resource.stubs(:puts)
-        @resource.host = 'host'
+        @resource_app.stubs(:puts)
+        @resource_app.host = 'host'
 
         Puppet::Resource.indirection.stubs(:find  ).never
         Puppet::Resource.indirection.stubs(:search).never
         Puppet::Resource.indirection.stubs(:save  ).never
       end
 
       it "should search for resources" do
-        @resource.command_line.stubs(:args).returns(['type'])
+        @resource_app.command_line.stubs(:args).returns(['type'])
         Puppet::Resource.indirection.expects(:search).with('https://host:8139/production/resources/type/', {}).returns([])
-        @resource.main
+        @resource_app.main
       end
 
       it "should describe the given resource" do
-        @resource.command_line.stubs(:args).returns(['type', 'name'])
-        x = stub_everything 'resource'
-        Puppet::Resource.indirection.expects(:find).with('https://host:8139/production/resources/type/name').returns(x)
-        @resource.main
+        @resource_app.command_line.stubs(:args).returns(['type', 'name'])
+        Puppet::Resource.indirection.expects(:find).with('https://host:8139/production/resources/type/name').returns(@res)
+        @resource_app.main
       end
 
       it "should add given parameters to the object" do
-        @resource.command_line.stubs(:args).returns(['type','name','param=temp'])
+        @resource_app.command_line.stubs(:args).returns(['type','name','param=temp'])
 
-        res = stub "resource"
-        Puppet::Resource.indirection.expects(:save).with(res, 'https://host:8139/production/resources/type/name').returns(res)
-        res.expects(:collect)
-        res.expects(:to_manifest)
-        Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(res)
+        Puppet::Resource.indirection.expects(:save).
+          with(@res, 'https://host:8139/production/resources/type/name').
+          returns([@res, @report])
+        Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(@res)
 
-        @resource.main
+        @resource_app.main
       end
-
     end
 
     describe "without a host" do
       before :each do
-        @resource.stubs(:puts)
-        @resource.host = nil
+        @resource_app.stubs(:puts)
+        @resource_app.host = nil
 
         Puppet::Resource.indirection.stubs(:find  ).never
         Puppet::Resource.indirection.stubs(:search).never
         Puppet::Resource.indirection.stubs(:save  ).never
       end
 
       it "should search for resources" do
-        Puppet::Resource.indirection.expects(:search).with('type/', {}).returns([])
-        @resource.main
+        Puppet::Resource.indirection.expects(:search).with('mytype/', {}).returns([])
+        @resource_app.main
       end
 
       it "should describe the given resource" do
-        @resource.command_line.stubs(:args).returns(['type','name'])
-        x = stub_everything 'resource'
-        Puppet::Resource.indirection.expects(:find).with('type/name').returns(x)
-        @resource.main
+        @resource_app.command_line.stubs(:args).returns(['type','name'])
+        Puppet::Resource.indirection.expects(:find).with('type/name').returns(@res)
+        @resource_app.main
       end
 
       it "should add given parameters to the object" do
-        @resource.command_line.stubs(:args).returns(['type','name','param=temp'])
+        @resource_app.command_line.stubs(:args).returns(['type','name','param=temp'])
 
-        res = stub "resource"
-        Puppet::Resource.indirection.expects(:save).with(res, 'type/name').returns(res)
-        res.expects(:collect)
-        res.expects(:to_manifest)
-        Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(res)
+        Puppet::Resource.indirection.expects(:save).with(@res, 'type/name').returns([@res, @report])
+        Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(@res)
 
-        @resource.main
+        @resource_app.main
       end
-
     end
   end
 
   describe "when handling file type" do
     before :each do
       Facter.stubs(:loadfacts)
-      @resource.preinit
+      @resource_app.preinit
     end
 
     it "should raise an exception if no file specified" do
-      @resource.command_line.stubs(:args).returns(['file'])
+      @resource_app.command_line.stubs(:args).returns(['file'])
 
-      lambda { @resource.main }.should raise_error(RuntimeError, /Listing all file instances is not supported/)
+      lambda { @resource_app.main }.should raise_error(RuntimeError, /Listing all file instances is not supported/)
     end
 
     it "should output a file resource when given a file path" do
       path = File.expand_path('/etc')
       res = Puppet::Type.type(:file).new(:path => path).to_resource
       Puppet::Resource.indirection.expects(:find).returns(res)
 
-      @resource.command_line.stubs(:args).returns(['file', path])
-      @resource.expects(:puts).with do |args|
+      @resource_app.command_line.stubs(:args).returns(['file', path])
+      @resource_app.expects(:puts).with do |args|
         args.should =~ /file \{ '#{Regexp.escape(path)}'/m
       end
 
-      @resource.main
+      @resource_app.main
     end
   end
 end
diff --git a/spec/unit/indirector/resource/ral_spec.rb b/spec/unit/indirector/resource/ral_spec.rb
index e38745f05..2ecedd29a 100755
--- a/spec/unit/indirector/resource/ral_spec.rb
+++ b/spec/unit/indirector/resource/ral_spec.rb
@@ -1,128 +1,130 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe "Puppet::Resource::Ral" do
   describe "find", :fails_on_windows => true do
     before do
       @request = stub 'request', :key => "user/root"
     end
 
     it "should find an existing instance" do
       my_resource    = stub "my user resource"
 
       wrong_instance = stub "wrong user", :name => "bob"
       my_instance    = stub "my user",    :name => "root", :to_resource => my_resource
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ wrong_instance, my_instance, wrong_instance ])
       Puppet::Resource::Ral.new.find(@request).should == my_resource
     end
 
     it "if there is no instance, it should create one", :'fails_on_ruby_1.9.2' => true do
       wrong_instance = stub "wrong user", :name => "bob"
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ wrong_instance, wrong_instance ])
       result = Puppet::Resource::Ral.new.find(@request)
       result.should be_is_a(Puppet::Resource)
       result.title.should == "root"
     end
   end
 
   describe "search" do
     before do
       @request = stub 'request', :key => "user/", :options => {}
     end
 
     it "should convert ral resources into regular resources" do
       my_resource = stub "my user resource"
       my_instance = stub "my user", :name => "root", :to_resource => my_resource
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ my_instance ])
       Puppet::Resource::Ral.new.search(@request).should == [my_resource]
     end
 
     it "should filter results by name if there's a name in the key" do
       my_resource    = stub "my user resource"
       my_resource.stubs(:to_resource).returns(my_resource)
       my_resource.stubs(:[]).with(:name).returns("root")
 
       wrong_resource = stub "wrong resource"
       wrong_resource.stubs(:to_resource).returns(wrong_resource)
       wrong_resource.stubs(:[]).with(:name).returns("bad")
 
       my_instance    = stub "my user",    :to_resource => my_resource
       wrong_instance = stub "wrong user", :to_resource => wrong_resource
 
       @request = stub 'request', :key => "user/root", :options => {}
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ my_instance, wrong_instance ])
       Puppet::Resource::Ral.new.search(@request).should == [my_resource]
     end
 
     it "should filter results by query parameters" do
       wrong_resource = stub "my user resource"
       wrong_resource.stubs(:to_resource).returns(wrong_resource)
       wrong_resource.stubs(:[]).with(:name).returns("root")
 
       my_resource = stub "wrong resource"
       my_resource.stubs(:to_resource).returns(my_resource)
       my_resource.stubs(:[]).with(:name).returns("bob")
 
       my_instance    = stub "my user",    :to_resource => my_resource
       wrong_instance = stub "wrong user", :to_resource => wrong_resource
 
       @request = stub 'request', :key => "user/", :options => {:name => "bob"}
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ my_instance, wrong_instance ])
       Puppet::Resource::Ral.new.search(@request).should == [my_resource]
     end
 
     it "should return sorted results" do
       a_resource = stub "alice resource"
       a_resource.stubs(:to_resource).returns(a_resource)
       a_resource.stubs(:title).returns("alice")
 
       b_resource = stub "bob resource"
       b_resource.stubs(:to_resource).returns(b_resource)
       b_resource.stubs(:title).returns("bob")
 
       a_instance = stub "alice user", :to_resource => a_resource
       b_instance = stub "bob user",   :to_resource => b_resource
 
       @request = stub 'request', :key => "user/", :options => {}
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ b_instance, a_instance ])
       Puppet::Resource::Ral.new.search(@request).should == [a_resource, b_resource]
     end
   end
 
   describe "save" do
     before do
       @rebuilt_res = stub 'rebuilt instance'
       @ral_res     = stub 'ral resource', :to_resource => @rebuilt_res
       @instance    = stub 'instance', :to_ral => @ral_res
       @request     = stub 'request',  :key => "user/", :instance => @instance
       @catalog     = stub 'catalog'
+      @report      = stub 'report'
+      @transaction = stub 'transaction', :report => @report
 
       Puppet::Resource::Catalog.stubs(:new).returns(@catalog)
-      @catalog.stubs(:apply)
+      @catalog.stubs(:apply).returns(@transaction)
       @catalog.stubs(:add_resource)
     end
 
     it "should apply a new catalog with a ral object in it" do
       Puppet::Resource::Catalog.expects(:new).returns(@catalog)
       @catalog.expects(:add_resource).with(@ral_res)
-      @catalog.expects(:apply)
-      Puppet::Resource::Ral.new.save(@request)
+      @catalog.expects(:apply).returns(@transaction)
+      Puppet::Resource::Ral.new.save(@request).should
     end
 
     it "should return a regular resource that used to be the ral resource" do
-      Puppet::Resource::Ral.new.save(@request).should == @rebuilt_res
+      Puppet::Resource::Ral.new.save(@request).should == [@rebuilt_res, @report]
     end
   end
 end
diff --git a/spec/unit/resource_spec.rb b/spec/unit/resource_spec.rb
index d9b9fd0b6..7c2c6ac22 100755
--- a/spec/unit/resource_spec.rb
+++ b/spec/unit/resource_spec.rb
@@ -1,811 +1,858 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/resource'
 
 describe Puppet::Resource do
   include PuppetSpec::Files
 
   before do
     @basepath = make_absolute("/somepath")
   end
 
   [:catalog, :file, :line].each do |attr|
     it "should have an #{attr} attribute" do
       resource = Puppet::Resource.new("file", "/my/file")
       resource.should respond_to(attr)
       resource.should respond_to(attr.to_s + "=")
     end
   end
 
   it "should have a :title attribute" do
     Puppet::Resource.new(:user, "foo").title.should == "foo"
   end
 
   it "should require the type and title" do
     lambda { Puppet::Resource.new }.should raise_error(ArgumentError)
   end
 
   it "should canonize types to capitalized strings" do
     Puppet::Resource.new(:user, "foo").type.should == "User"
   end
 
   it "should canonize qualified types so all strings are capitalized" do
     Puppet::Resource.new("foo::bar", "foo").type.should == "Foo::Bar"
   end
 
   it "should tag itself with its type" do
     Puppet::Resource.new("file", "/f").should be_tagged("file")
   end
 
   it "should tag itself with its title if the title is a valid tag" do
     Puppet::Resource.new("user", "bar").should be_tagged("bar")
   end
 
   it "should not tag itself with its title if the title is a not valid tag" do
     Puppet::Resource.new("file", "/bar").should_not be_tagged("/bar")
   end
 
   it "should allow setting of attributes" do
     Puppet::Resource.new("file", "/bar", :file => "/foo").file.should == "/foo"
     Puppet::Resource.new("file", "/bar", :exported => true).should be_exported
   end
 
   it "should set its type to 'Class' and its title to the passed title if the passed type is :component and the title has no square brackets in it" do
     ref = Puppet::Resource.new(:component, "foo")
     ref.type.should == "Class"
     ref.title.should == "Foo"
   end
 
   it "should interpret the title as a reference and assign appropriately if the type is :component and the title contains square brackets" do
     ref = Puppet::Resource.new(:component, "foo::bar[yay]")
     ref.type.should == "Foo::Bar"
     ref.title.should == "yay"
   end
 
   it "should set the type to 'Class' if it is nil and the title contains no square brackets" do
     ref = Puppet::Resource.new(nil, "yay")
     ref.type.should == "Class"
     ref.title.should == "Yay"
   end
 
   it "should interpret the title as a reference and assign appropriately if the type is nil and the title contains square brackets" do
     ref = Puppet::Resource.new(nil, "foo::bar[yay]")
     ref.type.should == "Foo::Bar"
     ref.title.should == "yay"
   end
 
   it "should interpret the title as a reference and assign appropriately if the type is nil and the title contains nested square brackets" do
     ref = Puppet::Resource.new(nil, "foo::bar[baz[yay]]")
     ref.type.should == "Foo::Bar"
     ref.title.should =="baz[yay]"
   end
 
   it "should interpret the type as a reference and assign appropriately if the title is nil and the type contains square brackets" do
     ref = Puppet::Resource.new("foo::bar[baz]")
     ref.type.should == "Foo::Bar"
     ref.title.should =="baz"
   end
 
   it "should be able to extract its information from a Puppet::Type instance" do
     ral = Puppet::Type.type(:file).new :path => @basepath+"/foo"
     ref = Puppet::Resource.new(ral)
     ref.type.should == "File"
     ref.title.should == @basepath+"/foo"
   end
 
 
   it "should fail if the title is nil and the type is not a valid resource reference string" do
     lambda { Puppet::Resource.new("foo") }.should raise_error(ArgumentError)
   end
 
   it 'should fail if strict is set and type does not exist' do
     lambda { Puppet::Resource.new('foo', 'title', {:strict=>true}) }.should raise_error(ArgumentError, 'Invalid resource type foo')
   end
 
   it 'should fail if strict is set and class does not exist' do
     lambda { Puppet::Resource.new('Class', 'foo', {:strict=>true}) }.should raise_error(ArgumentError, 'Could not find declared class foo')
   end
 
   it "should fail if the title is a hash and the type is not a valid resource reference string" do
     expect { Puppet::Resource.new({:type => "foo", :title => "bar"}) }.
       to raise_error ArgumentError, /Puppet::Resource.new does not take a hash/
   end
 
   it "should be able to produce a backward-compatible reference array" do
     Puppet::Resource.new("foobar", "/f").to_trans_ref.should == %w{Foobar /f}
   end
 
   it "should be taggable" do
     Puppet::Resource.ancestors.should be_include(Puppet::Util::Tagging)
   end
 
   it "should have an 'exported' attribute" do
     resource = Puppet::Resource.new("file", "/f")
     resource.exported = true
     resource.exported.should == true
     resource.should be_exported
   end
 
   it "should support an environment attribute" do
     Puppet::Resource.new("file", "/my/file", :environment => :foo).environment.name.should == :foo
   end
 
   describe "and munging its type and title" do
     describe "when modeling a builtin resource" do
       it "should be able to find the resource type" do
         Puppet::Resource.new("file", "/my/file").resource_type.should equal(Puppet::Type.type(:file))
       end
 
       it "should set its type to the capitalized type name" do
         Puppet::Resource.new("file", "/my/file").type.should == "File"
       end
     end
 
     describe "when modeling a defined resource" do
       describe "that exists" do
         before do
           @type = Puppet::Resource::Type.new(:definition, "foo::bar")
           Puppet::Node::Environment.new.known_resource_types.add @type
         end
 
         it "should set its type to the capitalized type name" do
           Puppet::Resource.new("foo::bar", "/my/file").type.should == "Foo::Bar"
         end
 
         it "should be able to find the resource type" do
           Puppet::Resource.new("foo::bar", "/my/file").resource_type.should equal(@type)
         end
 
         it "should set its title to the provided title" do
           Puppet::Resource.new("foo::bar", "/my/file").title.should == "/my/file"
         end
       end
 
       describe "that does not exist" do
         it "should set its resource type to the capitalized resource type name" do
           Puppet::Resource.new("foo::bar", "/my/file").type.should == "Foo::Bar"
         end
       end
     end
 
     describe "when modeling a node" do
       # Life's easier with nodes, because they can't be qualified.
       it "should set its type to 'Node' and its title to the provided title" do
         node = Puppet::Resource.new("node", "foo")
         node.type.should == "Node"
         node.title.should == "foo"
       end
     end
 
     describe "when modeling a class" do
       it "should set its type to 'Class'" do
         Puppet::Resource.new("class", "foo").type.should == "Class"
       end
 
       describe "that exists" do
         before do
           @type = Puppet::Resource::Type.new(:hostclass, "foo::bar")
           Puppet::Node::Environment.new.known_resource_types.add @type
         end
 
         it "should set its title to the capitalized, fully qualified resource type" do
           Puppet::Resource.new("class", "foo::bar").title.should == "Foo::Bar"
         end
 
         it "should be able to find the resource type" do
           Puppet::Resource.new("class", "foo::bar").resource_type.should equal(@type)
         end
       end
 
       describe "that does not exist" do
         it "should set its type to 'Class' and its title to the capitalized provided name" do
           klass = Puppet::Resource.new("class", "foo::bar")
           klass.type.should == "Class"
           klass.title.should == "Foo::Bar"
         end
       end
 
       describe "and its name is set to the empty string" do
         it "should set its title to :main" do
           Puppet::Resource.new("class", "").title.should == :main
         end
 
         describe "and a class exists whose name is the empty string" do # this was a bit tough to track down
           it "should set its title to :main" do
             @type = Puppet::Resource::Type.new(:hostclass, "")
             Puppet::Node::Environment.new.known_resource_types.add @type
 
             Puppet::Resource.new("class", "").title.should == :main
           end
         end
       end
 
       describe "and its name is set to :main" do
         it "should set its title to :main" do
           Puppet::Resource.new("class", :main).title.should == :main
         end
 
         describe "and a class exists whose name is the empty string" do # this was a bit tough to track down
           it "should set its title to :main" do
             @type = Puppet::Resource::Type.new(:hostclass, "")
             Puppet::Node::Environment.new.known_resource_types.add @type
 
             Puppet::Resource.new("class", :main).title.should == :main
           end
         end
       end
     end
   end
 
   it "should return nil when looking up resource types that don't exist" do
     Puppet::Resource.new("foobar", "bar").resource_type.should be_nil
   end
 
   it "should not fail when an invalid parameter is used and strict mode is disabled" do
     type = Puppet::Resource::Type.new(:definition, "foobar")
     Puppet::Node::Environment.new.known_resource_types.add type
     resource = Puppet::Resource.new("foobar", "/my/file")
     resource[:yay] = true
   end
 
   it "should be considered equivalent to another resource if their type and title match and no parameters are set" do
     Puppet::Resource.new("file", "/f").should == Puppet::Resource.new("file", "/f")
   end
 
   it "should be considered equivalent to another resource if their type, title, and parameters are equal" do
     Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"}).should == Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"})
   end
 
   it "should not be considered equivalent to another resource if their type and title match but parameters are different" do
     Puppet::Resource.new("file", "/f", :parameters => {:fee => "baz"}).should_not == Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"})
   end
 
   it "should not be considered equivalent to a non-resource" do
     Puppet::Resource.new("file", "/f").should_not == "foo"
   end
 
   it "should not be considered equivalent to another resource if their types do not match" do
     Puppet::Resource.new("file", "/f").should_not == Puppet::Resource.new("exec", "/f")
   end
 
   it "should not be considered equivalent to another resource if their titles do not match" do
     Puppet::Resource.new("file", "/foo").should_not == Puppet::Resource.new("file", "/f")
   end
 
   describe "when referring to a resource with name canonicalization" do
     it "should canonicalize its own name" do
       res = Puppet::Resource.new("file", "/path/")
       res.uniqueness_key.should == ["/path"]
       res.ref.should == "File[/path/]"
     end
   end
 
   describe "when running in strict mode" do
     it "should be strict" do
       Puppet::Resource.new("file", "/path", :strict => true).should be_strict
     end
 
     it "should fail if invalid parameters are used" do
       lambda { Puppet::Resource.new("file", "/path", :strict => true, :parameters => {:nosuchparam => "bar"}) }.should raise_error
     end
 
     it "should fail if the resource type cannot be resolved" do
       lambda { Puppet::Resource.new("nosuchtype", "/path", :strict => true) }.should raise_error
     end
   end
 
   describe "when managing parameters" do
     before do
       @resource = Puppet::Resource.new("file", "/my/file")
     end
 
     it "should correctly detect when provided parameters are not valid for builtin types" do
       Puppet::Resource.new("file", "/my/file").should_not be_valid_parameter("foobar")
     end
 
     it "should correctly detect when provided parameters are valid for builtin types" do
       Puppet::Resource.new("file", "/my/file").should be_valid_parameter("mode")
     end
 
     it "should correctly detect when provided parameters are not valid for defined resource types" do
       type = Puppet::Resource::Type.new(:definition, "foobar")
       Puppet::Node::Environment.new.known_resource_types.add type
       Puppet::Resource.new("foobar", "/my/file").should_not be_valid_parameter("myparam")
     end
 
     it "should correctly detect when provided parameters are valid for defined resource types" do
       type = Puppet::Resource::Type.new(:definition, "foobar", :arguments => {"myparam" => nil})
       Puppet::Node::Environment.new.known_resource_types.add type
       Puppet::Resource.new("foobar", "/my/file").should be_valid_parameter("myparam")
     end
 
     it "should allow setting and retrieving of parameters" do
       @resource[:foo] = "bar"
       @resource[:foo].should == "bar"
     end
 
     it "should allow setting of parameters at initialization" do
       Puppet::Resource.new("file", "/my/file", :parameters => {:foo => "bar"})[:foo].should == "bar"
     end
 
     it "should canonicalize retrieved parameter names to treat symbols and strings equivalently" do
       @resource[:foo] = "bar"
       @resource["foo"].should == "bar"
     end
 
     it "should canonicalize set parameter names to treat symbols and strings equivalently" do
       @resource["foo"] = "bar"
       @resource[:foo].should == "bar"
     end
 
     it "should set the namevar when asked to set the name" do
       resource = Puppet::Resource.new("user", "bob")
       Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
       resource[:name] = "bob"
       resource[:myvar].should == "bob"
     end
 
     it "should return the namevar when asked to return the name" do
       resource = Puppet::Resource.new("user", "bob")
       Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
       resource[:myvar] = "test"
       resource[:name].should == "test"
     end
 
     it "should be able to set the name for non-builtin types" do
       resource = Puppet::Resource.new(:foo, "bar")
       resource[:name] = "eh"
       lambda { resource[:name] = "eh" }.should_not raise_error
     end
 
     it "should be able to return the name for non-builtin types" do
       resource = Puppet::Resource.new(:foo, "bar")
       resource[:name] = "eh"
       resource[:name].should == "eh"
     end
 
     it "should be able to iterate over parameters" do
       @resource[:foo] = "bar"
       @resource[:fee] = "bare"
       params = {}
       @resource.each do |key, value|
         params[key] = value
       end
       params.should == {:foo => "bar", :fee => "bare"}
     end
 
     it "should include Enumerable" do
       @resource.class.ancestors.should be_include(Enumerable)
     end
 
     it "should have a method for testing whether a parameter is included" do
       @resource[:foo] = "bar"
       @resource.should be_has_key(:foo)
       @resource.should_not be_has_key(:eh)
     end
 
     it "should have a method for providing the list of parameters" do
       @resource[:foo] = "bar"
       @resource[:bar] = "foo"
       keys = @resource.keys
       keys.should be_include(:foo)
       keys.should be_include(:bar)
     end
 
     it "should have a method for providing the number of parameters" do
       @resource[:foo] = "bar"
       @resource.length.should == 1
     end
 
     it "should have a method for deleting parameters" do
       @resource[:foo] = "bar"
       @resource.delete(:foo)
       @resource[:foo].should be_nil
     end
 
     it "should have a method for testing whether the parameter list is empty" do
       @resource.should be_empty
       @resource[:foo] = "bar"
       @resource.should_not be_empty
     end
 
     it "should be able to produce a hash of all existing parameters" do
       @resource[:foo] = "bar"
       @resource[:fee] = "yay"
 
       hash = @resource.to_hash
       hash[:foo].should == "bar"
       hash[:fee].should == "yay"
     end
 
     it "should not provide direct access to the internal parameters hash when producing a hash" do
       hash = @resource.to_hash
       hash[:foo] = "bar"
       @resource[:foo].should be_nil
     end
 
     it "should use the title as the namevar to the hash if no namevar is present" do
       resource = Puppet::Resource.new("user", "bob")
       Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
       resource.to_hash[:myvar].should == "bob"
     end
 
     it "should set :name to the title if :name is not present for non-builtin types" do
       krt = Puppet::Resource::TypeCollection.new("myenv")
       krt.add Puppet::Resource::Type.new(:definition, :foo)
       resource = Puppet::Resource.new :foo, "bar"
       resource.stubs(:known_resource_types).returns krt
       resource.to_hash[:name].should == "bar"
     end
   end
 
   describe "when serializing" do
     before do
       @resource = Puppet::Resource.new("file", "/my/file")
       @resource["one"] = "test"
       @resource["two"] = "other"
     end
 
     it "should be able to be dumped to yaml" do
       proc { YAML.dump(@resource) }.should_not raise_error
     end
 
     it "should produce an equivalent yaml object" do
       text = YAML.dump(@resource)
 
       newresource = YAML.load(text)
       newresource.title.should == @resource.title
       newresource.type.should == @resource.type
       %w{one two}.each do |param|
         newresource[param].should == @resource[param]
       end
     end
   end
 
   describe "when loading 0.25.x storedconfigs YAML" do
     before :each do
       @old_storedconfig_yaml = %q{--- !ruby/object:Puppet::Resource::Reference
 builtin_type:
 title: /tmp/bar
 type: File
 }
     end
 
     it "should deserialize a Puppet::Resource::Reference without exceptions" do
       lambda { YAML.load(@old_storedconfig_yaml) }.should_not raise_error
     end
 
     it "should deserialize as a Puppet::Resource::Reference as a Puppet::Resource" do
       YAML.load(@old_storedconfig_yaml).class.should == Puppet::Resource
     end
 
     it "should to_hash properly" do
       YAML.load(@old_storedconfig_yaml).to_hash.should == { :path => "/tmp/bar" }
     end
   end
 
   describe "when converting to a RAL resource" do
     it "should use the resource type's :new method to create the resource if the resource is of a builtin type" do
       resource = Puppet::Resource.new("file", @basepath+"/my/file")
       result = resource.to_ral
       result.should be_instance_of(Puppet::Type.type(:file))
       result[:path].should == @basepath+"/my/file"
     end
 
     it "should convert to a component instance if the resource type is not of a builtin type" do
       resource = Puppet::Resource.new("foobar", "somename")
       result = resource.to_ral
 
       result.should be_instance_of(Puppet::Type.type(:component))
       result.title.should == "Foobar[somename]"
     end
   end
 
-  it "should be able to convert itself to Puppet code" do
-    Puppet::Resource.new("one::two", "/my/file").should respond_to(:to_manifest)
-  end
-
   describe "when converting to puppet code" do
     before do
       @resource = Puppet::Resource.new("one::two", "/my/file",
         :parameters => {
           :noop => true,
           :foo => %w{one two},
           :ensure => 'present',
         }
       )
     end
 
     it "should align, sort and add trailing commas to attributes with ensure first", :'fails_on_ruby_1.9.2' => true do
       @resource.to_manifest.should == <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
         one::two { '/my/file':
           ensure => 'present',
           foo    => ['one', 'two'],
           noop   => 'true',
         }
       HEREDOC
     end
   end
 
-  it "should be able to convert itself to a TransObject instance" do
-    Puppet::Resource.new("one::two", "/my/file").should respond_to(:to_trans)
-  end
-
   describe "when converting to a TransObject" do
     describe "and the resource is not an instance of a builtin type" do
       before do
         @resource = Puppet::Resource.new("foo", "bar")
       end
 
       it "should return a simple TransBucket if it is not an instance of a builtin type" do
         bucket = @resource.to_trans
         bucket.should be_instance_of(Puppet::TransBucket)
         bucket.type.should == @resource.type
         bucket.name.should == @resource.title
       end
 
       it "should return a simple TransBucket if it is a stage" do
         @resource = Puppet::Resource.new("stage", "bar")
         bucket = @resource.to_trans
         bucket.should be_instance_of(Puppet::TransBucket)
         bucket.type.should == @resource.type
         bucket.name.should == @resource.title
       end
 
       it "should copy over the resource's file" do
         @resource.file = "/foo/bar"
         @resource.to_trans.file.should == "/foo/bar"
       end
 
       it "should copy over the resource's line" do
         @resource.line = 50
         @resource.to_trans.line.should == 50
       end
     end
 
     describe "and the resource is an instance of a builtin type" do
       before do
         @resource = Puppet::Resource.new("file", "bar")
       end
 
       it "should return a TransObject if it is an instance of a builtin resource type" do
         trans = @resource.to_trans
         trans.should be_instance_of(Puppet::TransObject)
         trans.type.should == "file"
         trans.name.should == @resource.title
       end
 
       it "should copy over the resource's file" do
         @resource.file = "/foo/bar"
         @resource.to_trans.file.should == "/foo/bar"
       end
 
       it "should copy over the resource's line" do
         @resource.line = 50
         @resource.to_trans.line.should == 50
       end
 
       # Only TransObjects support tags, annoyingly
       it "should copy over the resource's tags" do
         @resource.tag "foo"
         @resource.to_trans.tags.should == @resource.tags
       end
 
       it "should copy the resource's parameters into the transobject and convert the parameter name to a string" do
         @resource[:foo] = "bar"
         @resource.to_trans["foo"].should == "bar"
       end
 
       it "should be able to copy arrays of values" do
         @resource[:foo] = %w{yay fee}
         @resource.to_trans["foo"].should == %w{yay fee}
       end
 
       it "should reduce single-value arrays to just a value" do
         @resource[:foo] = %w{yay}
         @resource.to_trans["foo"].should == "yay"
       end
 
       it "should convert resource references into the backward-compatible form" do
         @resource[:foo] = Puppet::Resource.new(:file, "/f")
         @resource.to_trans["foo"].should == %w{File /f}
       end
 
       it "should convert resource references into the backward-compatible form even when within arrays" do
         @resource[:foo] = ["a", Puppet::Resource.new(:file, "/f")]
         @resource.to_trans["foo"].should == ["a", %w{File /f}]
       end
     end
   end
 
   describe "when converting to pson", :if => Puppet.features.pson? do
     def pson_output_should
       @resource.class.expects(:pson_create).with { |hash| yield hash }
     end
 
     it "should include the pson util module" do
       Puppet::Resource.singleton_class.ancestors.should be_include(Puppet::Util::Pson)
     end
 
     # LAK:NOTE For all of these tests, we convert back to the resource so we can
     # trap the actual data structure then.
 
     it "should set its type to the provided type" do
       Puppet::Resource.from_pson(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).type.should == "File"
     end
 
     it "should set its title to the provided title" do
       Puppet::Resource.from_pson(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).title.should == "/foo"
     end
 
     it "should include all tags from the resource" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.tag("yay")
 
       Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).tags.should == resource.tags
     end
 
     it "should include the file if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.file = "/my/file"
 
       Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).file.should == "/my/file"
     end
 
     it "should include the line if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.line = 50
 
       Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).line.should == 50
     end
 
     it "should include the 'exported' value if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.exported = true
 
       Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).exported.should be_true
     end
 
     it "should set 'exported' to false if no value is set" do
       resource = Puppet::Resource.new("File", "/foo")
 
       Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).exported.should be_false
     end
 
     it "should set all of its parameters as the 'parameters' entry" do
       resource = Puppet::Resource.new("File", "/foo")
       resource[:foo] = %w{bar eh}
       resource[:fee] = %w{baz}
 
       result = Puppet::Resource.from_pson(PSON.parse(resource.to_pson))
       result["foo"].should == %w{bar eh}
       result["fee"].should == %w{baz}
     end
 
     it "should serialize relationships as reference strings" do
       resource = Puppet::Resource.new("File", "/foo")
       resource[:requires] = Puppet::Resource.new("File", "/bar")
       result = Puppet::Resource.from_pson(PSON.parse(resource.to_pson))
       result[:requires].should == "File[/bar]"
     end
 
     it "should serialize multiple relationships as arrays of reference strings" do
       resource = Puppet::Resource.new("File", "/foo")
       resource[:requires] = [Puppet::Resource.new("File", "/bar"), Puppet::Resource.new("File", "/baz")]
       result = Puppet::Resource.from_pson(PSON.parse(resource.to_pson))
       result[:requires].should == [ "File[/bar]",  "File[/baz]" ]
     end
   end
 
   describe "when converting from pson", :if => Puppet.features.pson? do
     def pson_result_should
       Puppet::Resource.expects(:new).with { |hash| yield hash }
     end
 
     before do
       @data = {
         'type' => "file",
         'title' => @basepath+"/yay",
       }
     end
 
     it "should set its type to the provided type" do
       Puppet::Resource.from_pson(@data).type.should == "File"
     end
 
     it "should set its title to the provided title" do
       Puppet::Resource.from_pson(@data).title.should == @basepath+"/yay"
     end
 
     it "should tag the resource with any provided tags" do
       @data['tags'] = %w{foo bar}
       resource = Puppet::Resource.from_pson(@data)
       resource.tags.should be_include("foo")
       resource.tags.should be_include("bar")
     end
 
     it "should set its file to the provided file" do
       @data['file'] = "/foo/bar"
       Puppet::Resource.from_pson(@data).file.should == "/foo/bar"
     end
 
     it "should set its line to the provided line" do
       @data['line'] = 50
       Puppet::Resource.from_pson(@data).line.should == 50
     end
 
     it "should 'exported' to true if set in the pson data" do
       @data['exported'] = true
       Puppet::Resource.from_pson(@data).exported.should be_true
     end
 
     it "should 'exported' to false if not set in the pson data" do
       Puppet::Resource.from_pson(@data).exported.should be_false
     end
 
     it "should fail if no title is provided" do
       @data.delete('title')
       lambda { Puppet::Resource.from_pson(@data) }.should raise_error(ArgumentError)
     end
 
     it "should fail if no type is provided" do
       @data.delete('type')
       lambda { Puppet::Resource.from_pson(@data) }.should raise_error(ArgumentError)
     end
 
     it "should set each of the provided parameters" do
       @data['parameters'] = {'foo' => %w{one two}, 'fee' => %w{three four}}
       resource = Puppet::Resource.from_pson(@data)
       resource['foo'].should == %w{one two}
       resource['fee'].should == %w{three four}
     end
 
     it "should convert single-value array parameters to normal values" do
       @data['parameters'] = {'foo' => %w{one}}
       resource = Puppet::Resource.from_pson(@data)
       resource['foo'].should == %w{one}
     end
   end
 
   describe "it should implement to_resource" do
     resource = Puppet::Resource.new("file", "/my/file")
     resource.to_resource.should == resource
   end
 
   describe "because it is an indirector model" do
     it "should include Puppet::Indirector" do
       Puppet::Resource.should be_is_a(Puppet::Indirector)
     end
 
     it "should have a default terminus" do
       Puppet::Resource.indirection.terminus_class.should be
     end
 
     it "should have a name" do
       Puppet::Resource.new("file", "/my/file").name.should == "File//my/file"
     end
   end
 
   describe "when resolving resources with a catalog" do
     it "should resolve all resources using the catalog" do
       catalog = mock 'catalog'
       resource = Puppet::Resource.new("foo::bar", "yay")
       resource.catalog = catalog
 
       catalog.expects(:resource).with("Foo::Bar[yay]").returns(:myresource)
 
       resource.resolve.should == :myresource
     end
   end
 
   describe "when generating the uniqueness key" do
     it "should include all of the key_attributes in alphabetical order by attribute name" do
       Puppet::Type.type(:file).stubs(:key_attributes).returns [:myvar, :owner, :path]
       Puppet::Type.type(:file).stubs(:title_patterns).returns(
         [ [ /(.*)/, [ [:path, lambda{|x| x} ] ] ] ]
       )
       res = Puppet::Resource.new("file", "/my/file", :parameters => {:owner => 'root', :content => 'hello'})
       res.uniqueness_key.should == [ nil, 'root', '/my/file']
     end
   end
+
+  describe "#prune_parameters" do
+    before do
+      Puppet.newtype('blond') do
+        newproperty(:ensure)
+        newproperty(:height)
+        newproperty(:weight)
+        newproperty(:sign)
+        newproperty(:friends)
+        newparam(:admits_to_dying_hair)
+        newparam(:admits_to_age)
+        newparam(:name)
+      end
+    end
+
+    it "should strip all parameters and strip properties that are nil, empty or absent except for ensure" do
+      resource = Puppet::Resource.new("blond", "Bambi", :parameters => {
+        :ensure               => 'absent',
+        :height               => '',
+        :weight               => 'absent',
+        :friends              => [],
+        :admits_to_age        => true,
+        :admits_to_dying_hair => false
+      })
+
+      pruned_resource = resource.prune_parameters
+      pruned_resource.should == Puppet::Resource.new("blond", "Bambi", :parameters => {:ensure => 'absent'})
+    end
+
+    it "should leave parameters alone if in parameters_to_include" do
+      resource = Puppet::Resource.new("blond", "Bambi", :parameters => {
+        :admits_to_age        => true,
+        :admits_to_dying_hair => false
+      })
+
+      pruned_resource = resource.prune_parameters(:parameters_to_include => [:admits_to_dying_hair])
+      pruned_resource.should == Puppet::Resource.new("blond", "Bambi", :parameters => {:admits_to_dying_hair => false})
+    end
+
+    it "should leave properties if not nil, absent or empty" do
+      resource = Puppet::Resource.new("blond", "Bambi", :parameters => {
+        :ensure          => 'silly',
+        :height          => '7 ft 5 in',
+        :friends         => ['Oprah'],
+      })
+
+      pruned_resource = resource.prune_parameters
+      pruned_resource.should ==
+      resource = Puppet::Resource.new("blond", "Bambi", :parameters => {
+        :ensure          => 'silly',
+        :height          => '7 ft 5 in',
+        :friends         => ['Oprah'],
+      })
+    end
+  end
 end