diff --git a/lib/puppet/application/resource.rb b/lib/puppet/application/resource.rb
index 4a3a4491a..8ed392ee2 100644
--- a/lib/puppet/application/resource.rb
+++ b/lib/puppet/application/resource.rb
@@ -1,228 +1,240 @@
 require 'puppet/application'
 
 class Puppet::Application::Resource < Puppet::Application
 
   attr_accessor :host, :extra_params
 
   def preinit
     @extra_params = []
   end
 
   option("--debug","-d")
   option("--verbose","-v")
   option("--edit","-e")
+  option("--to_yaml","-y")
 
   option("--host HOST","-H") do |arg|
     Puppet.warning("Accessing resources on the network is deprecated. See http://links.puppetlabs.com/deprecate-networked-resource")
     @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>
+  [-H|--host <host>] [-p|--param <parameter>] [-t|--types] [-y|--to_yaml] <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 setting that's valid in the configuration
 file is also a valid long argument. For example, 'ssldir' is a valid
 setting, 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.
 
+* --to_yaml:
+  Output found resources in yaml format, suitable to use with Hiera and create_resources.
 
 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
     type, name, params = parse_args(command_line.args)
 
     raise "You cannot edit a remote host" if options[:edit] and @host
+    raise "Editing with Yaml output is not supported" if options[:edit] and options[:to_yaml]
 
     resources = find_or_save_resources(type, name, params)
-    text = resources.
-      map { |resource| resource.prune_parameters(:parameters_to_include => @extra_params).to_manifest }.
-      join("\n")
+
+    if options[:to_yaml]
+      text = resources.
+        map { |resource| resource.prune_parameters(:parameters_to_include => @extra_params).to_hierayaml }.
+        join("\n")
+      text.prepend("#{type.downcase}:\n")
+    else
+      text = resources.
+        map { |resource| resource.prune_parameters(:parameters_to_include => @extra_params).to_manifest }.
+        join("\n")
+    end
 
     options[:edit] ?
       handle_editing(text) :
       (puts text)
   end
 
   def setup
     Puppet::Util::Log.newdestination(:console)
     set_log_level
   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"
     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
 
     [type, name, params]
   end
 
   def find_or_save_resources(type, name, params)
     key = @host ? remote_key(type, name) : local_key(type, name)
 
     if name
       if params.empty?
         [ Puppet::Resource.indirection.find( key ) ]
       else
         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
   end
 end
diff --git a/lib/puppet/resource.rb b/lib/puppet/resource.rb
index a5419512b..8abb31b0e 100644
--- a/lib/puppet/resource.rb
+++ b/lib/puppet/resource.rb
@@ -1,612 +1,632 @@
 require 'puppet'
 require 'puppet/util/tagging'
 require 'puppet/util/pson'
 require 'puppet/parameter'
 
 # The simplest resource class.  Eventually it will function as the
 # base class for all resource-like behaviour.
 #
 # @api public
 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
 
   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_data_hash(data)
     raise ArgumentError, "No resource type provided in serialized data" unless type = data['type']
     raise ArgumentError, "No resource title provided in serialized data" unless title = data['title']
 
     resource = new(type, title)
 
     if params = data['parameters']
       params.each { |param, value| resource[param] = value }
     end
 
     if tags = data['tags']
       tags.each { |tag| resource.tag(tag) }
     end
 
     ATTRIBUTES.each do |a|
       if value = data[a.to_s]
         resource.send(a.to_s + "=", value)
       end
     end
 
     resource
   end
 
   def self.from_pson(pson)
     Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
     self.from_data_hash(pson)
   end
 
   def inspect
     "#{@type}[#{@title}]#{to_hash.inspect}"
   end
 
   def to_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
 
   # This doesn't include document type as it is part of a catalog
   def to_pson_data_hash
     to_data_hash
   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
 
   YAML_ATTRIBUTES = [:@file, :@line, :@exported, :@type, :@title, :@tags, :@parameters]
 
   # Explicitly list the instance variables that should be serialized when
   # converting to YAML.
   #
   # @api private
   # @return [Array<Symbol>] The intersection of our explicit variable list and
   #   all of the instance variables defined on this class.
   def to_yaml_properties
     YAML_ATTRIBUTES & super
   end
 
   def to_pson(*args)
     to_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
 
   %w{exported virtual strict}.each do |m|
     define_method(m+"?") do
       self.send(m)
     end
   end
 
   def class?
     @is_class ||= @type == "Class"
   end
 
   def stage?
     @is_stage ||= @type.to_s.downcase == "stage"
   end
 
   # Cache to reduce respond_to? lookups
   @@nondeprecating_type = {}
 
   # Construct a resource from data.
   #
   # Constructs a resource instance with the given `type` and `title`. Multiple
   # type signatures are possible for these arguments and most will result in an
   # expensive call to {Puppet::Node::Environment#known_resource_types} in order
   # to resolve `String` and `Symbol` Types to actual Ruby classes.
   #
   # @param type [Symbol, String] The name of the Puppet Type, as a string or
   #   symbol. The actual Type will be looked up using
   #   {Puppet::Node::Environment#known_resource_types}. This lookup is expensive.
   # @param type [String] The full resource name in the form of
   #   `"Type[Title]"`. This method of calling should only be used when
   #   `title` is `nil`.
   # @param type [nil] If a `nil` is passed, the title argument must be a string
   #   of the form `"Type[Title]"`.
   # @param type [Class] A class that inherits from `Puppet::Type`. This method
   #   of construction is much more efficient as it skips calls to
   #   {Puppet::Node::Environment#known_resource_types}.
   #
   # @param title [String, :main, nil] The title of the resource. If type is `nil`, may also
   #   be the full resource name in the form of `"Type[Title]"`.
   #
   # @api public
   def initialize(type, title = nil, attributes = {})
     @parameters = {}
     if type.is_a?(Class) && type < Puppet::Type
       # Set the resource type to avoid an expensive `known_resource_types`
       # lookup.
       self.resource_type = type
       # From this point on, the constructor behaves the same as if `type` had
       # been passed as a symbol.
       type = type.name
     end
 
     # 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 self.class?
       @title = :main if @title == ""
       @title = munge_type_name(@title)
     end
 
     if params = attributes[:parameters]
       extract_parameters(params)
     end
 
     if resource_type and ! @@nondeprecating_type[resource_type]
       if resource_type.respond_to?(:deprecate_params)
         resource_type.deprecate_params(title, attributes[:parameters])
       else
         @@nondeprecating_type[resource_type] = true
       end
     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 self.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
     catalog ? catalog.resource(to_s) : nil
   end
 
   # The resource's type implementation
   # @return [Puppet::Type, Puppet::Resource::Type]
   # @api private
   def resource_type
     @rstype ||= case type
     when "Class"; environment.known_resource_types.hostclass(title == :main ? "" : title)
     when "Node"; environment.known_resource_types.node(title)
     else
       Puppet::Type.type(type) || environment.known_resource_types.definition(type)
     end
   end
 
   # Set the resource's type implementation
   # @param type [Puppet::Type, Puppet::Resource::Type]
   # @api private
   def resource_type=(type)
     @rstype = type
   end
 
   def environment
     @environment ||= if catalog
                        catalog.environment_instance
                      else
                        Puppet.lookup(:current_environment) { Puppet::Node::Environment::NONE }
                      end
   end
 
   def environment=(environment)
     @environment = environment
   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
     resource_type.respond_to?(:key_attributes) ? resource_type.key_attributes : [:name]
   end
 
+  # Convert our resource to yaml for Hiera purposes.
+  def to_hierayaml
+    # 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]
+      "    %-#{attr_max}s: %s\n" % [k, Puppet::Parameter.format_value_for_display(v)]
+    }.join
+
+    "  %s:\n%s" % [self.title, attributes]
+  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]
       "  %-#{attr_max}s => %s,\n" % [k, Puppet::Parameter.format_value_for_display(v)]
     }.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
     typeklass = Puppet::Type.type(self.type) || Puppet::Type.type(:component)
     typeklass.new(self)
   end
 
   def name
     # this is potential namespace conflict
     # between the notion of an "indirector name"
     # and a "resource name"
     [ type, title ].join('/')
   end
 
   def missing_arguments
     resource_type.arguments.select do |param, default|
       param = param.to_sym
       parameters[param].nil? || parameters[param].value == :undef
     end
   end
   private :missing_arguments
 
   # Consult external data bindings for class parameter values which must be
   # namespaced in the backend.
   #
   # Example:
   #
   #   class foo($port=0){ ... }
   #
   # We make a request to the backend for the key 'foo::port' not 'foo'
   #
   def lookup_external_default_for(param, scope)
     # Only lookup parameters for host classes
     return nil unless resource_type.type == :hostclass
 
     name = "#{resource_type.name}::#{param}"
     lookup_with_databinding(name, scope)
   end
 
   private :lookup_external_default_for
 
   def lookup_with_databinding(name, scope)
     begin
       Puppet::DataBinding.indirection.find(
         name,
         :environment => scope.environment.to_s,
         :variables => scope)
     rescue Puppet::DataBinding::LookupError => e
       raise Puppet::Error.new("Error from DataBinding '#{Puppet[:data_binding_terminus]}' while looking up '#{name}': #{e.message}", e)
     end
   end
 
   private :lookup_with_databinding
 
   def set_default_parameters(scope)
     return [] unless resource_type and resource_type.respond_to?(:arguments)
 
     unless is_a?(Puppet::Parser::Resource)
       fail Puppet::DevError, "Cannot evaluate default parameters for #{self} - not a parser resource"
     end
 
     missing_arguments.collect do |param, default|
       external_value = lookup_external_default_for(param, scope)
 
       if external_value.nil? && default.nil?
         next
       elsif external_value.nil?
         value = default.safeevaluate(scope)
       else
         value = external_value
       end
 
       self[param.to_sym] = value
       param
     end.compact
   end
 
   def copy_as_resource
     result = Puppet::Resource.new(type, title)
 
     result.file = self.file
     result.line = self.line
     result.exported = self.exported
     result.virtual = self.virtual
     result.tag(*self.tags)
     result.environment = environment
     result.instance_variable_set(:@rstype, resource_type)
 
     to_hash.each do |p, v|
       if v.is_a?(Puppet::Resource)
         v = Puppet::Resource.new(v.type, v.title)
       elsif v.is_a?(Array)
         # flatten resource references arrays
         v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
         v = v.collect do |av|
           av = Puppet::Resource.new(av.type, av.title) if av.is_a?(Puppet::Resource)
           av
         end
       end
 
       if Puppet[:parser] == 'current'
         # 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.
         #
         # This behavior is not done in the future parser, but we can't issue a
         # deprecation warning either since there isn't anything that a user can
         # do about it.
         result[p] = if v.is_a?(Array) and v.length == 1
                       v[0]
                     else
                       v
                     end
       else
         result[p] = v
       end
     end
 
     result
   end
 
   def valid_parameter?(name)
     resource_type.valid_parameter?(name)
   end
 
   # Verify that all required arguments are either present or
   # have been provided with defaults.
   # Must be called after 'set_default_parameters'.  We can't join the methods
   # because Type#set_parameters needs specifically ordered behavior.
   def validate_complete
     return unless resource_type and resource_type.respond_to?(:arguments)
 
     resource_type.arguments.each do |param, default|
       param = param.to_sym
       fail Puppet::ParseError, "Must pass #{param} to #{self}" unless parameters.include?(param)
     end
 
     # Perform optional type checking
     if Puppet[:parser] == 'future'
       # Perform type checking
       arg_types = resource_type.argument_types
       # Parameters is a map from name, to parameter, and the parameter again has name and value
       parameters.each do |name, value|
         next unless t = arg_types[name.to_s]  # untyped, and parameters are symbols here (aargh, strings in the type)
         unless Puppet::Pops::Types::TypeCalculator.instance?(t, value.value)
           inferred_type = Puppet::Pops::Types::TypeCalculator.infer(value.value)
           actual = Puppet::Pops::Types::TypeCalculator.generalize!(inferred_type)
           fail Puppet::ParseError, "Expected parameter '#{name}' of '#{self}' to have type #{t.to_s}, got #{actual.to_s}"
         end
       end
     end
   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.to_s.empty? or Array(value).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 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
 
   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    (argtype.nil? || argtype == :component || argtype == :whit) &&
            argtitle =~ /^([^\[\]]+)\[(.+)\]$/m                 then [ $1,                 $2            ]
     elsif argtitle.nil? && 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 do |symbol_and_lambda,capture|
             symbol, proc = symbol_and_lambda
             # Many types pass "identity" as the proc; we might as well give
             # them a shortcut to delivering that without the extra cost.
             #
             # Especially because the global type defines title_patterns and
             # uses the identity patterns.
             #
             # This was worth about 8MB of memory allocation saved in my
             # testing, so is worth the complexity for the API.
             if proc then
               h[symbol] = proc.call(capture)
             else
               h[symbol] = capture
             end
           end
           return h
         end
       }
       # If we've gotten this far, then none of the provided title patterns
       # matched. Since there's no way to determine the title then the
       # resource should fail here.
       raise Puppet::Error, "No set of title patterns matched the title \"#{title}\"."
     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/resource_spec.rb b/spec/unit/resource_spec.rb
index 91be16ae6..e60b29cb2 100755
--- a/spec/unit/resource_spec.rb
+++ b/spec/unit/resource_spec.rb
@@ -1,985 +1,1005 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/resource'
 
 describe Puppet::Resource do
   include PuppetSpec::Files
 
   let(:basepath) { make_absolute("/somepath") }
   let(:environment) { Puppet::Node::Environment.create(:testing, []) }
 
   [: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
     expect { Puppet::Resource.new }.to 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 not interpret the title as a reference if the type is a non component or whit reference" do
     ref = Puppet::Resource.new("Notify", "foo::bar[baz]")
     ref.type.should == "Notify"
     ref.title.should =="foo::bar[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
     expect { Puppet::Resource.new("resource-spec-foo") }.to raise_error(ArgumentError)
   end
 
   it 'should fail if strict is set and type does not exist' do
     expect { Puppet::Resource.new('resource-spec-foo', 'title', {:strict=>true}) }.to raise_error(ArgumentError, 'Invalid resource type resource-spec-foo')
   end
 
   it 'should fail if strict is set and class does not exist' do
     expect { Puppet::Resource.new('Class', 'resource-spec-foo', {:strict=>true}) }.to raise_error(ArgumentError, 'Could not find declared class resource-spec-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 => "resource-spec-foo", :title => "bar"}) }.
       to raise_error ArgumentError, /Puppet::Resource.new does not take a hash/
   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
 
   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")
           environment.known_resource_types.add @type
         end
 
         it "should set its type to the capitalized type name" do
           Puppet::Resource.new("foo::bar", "/my/file", :environment => environment).type.should == "Foo::Bar"
         end
 
         it "should be able to find the resource type" do
           Puppet::Resource.new("foo::bar", "/my/file", :environment => environment).resource_type.should equal(@type)
         end
 
         it "should set its title to the provided title" do
           Puppet::Resource.new("foo::bar", "/my/file", :environment => environment).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")
           environment.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", :environment => environment).title.should == "Foo::Bar"
         end
 
         it "should be able to find the resource type" do
           Puppet::Resource.new("class", "foo::bar", :environment => environment).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, "")
             environment.known_resource_types.add @type
 
             Puppet::Resource.new("class", "", :environment => environment).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, "")
             environment.known_resource_types.add @type
 
             Puppet::Resource.new("class", :main, :environment => environment).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")
     environment.known_resource_types.add type
     resource = Puppet::Resource.new("foobar", "/my/file", :environment => environment)
     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 setting default parameters" do
     let(:foo_node) { Puppet::Node.new('foo', :environment => environment) }
     let(:compiler) { Puppet::Parser::Compiler.new(foo_node) }
     let(:scope)    { Puppet::Parser::Scope.new(compiler) }
 
     def ast_string(value)
       Puppet::Parser::AST::String.new({:value => value})
     end
 
     it "should fail when asked to set default values and it is not a parser resource" do
       environment.known_resource_types.add(
       Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_string("default")})
       )
       resource = Puppet::Resource.new("default_param", "name", :environment => environment)
       lambda { resource.set_default_parameters(scope) }.should raise_error(Puppet::DevError)
     end
 
     it "should evaluate and set any default values when no value is provided" do
       environment.known_resource_types.add(
         Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_string("a_default_value")})
       )
       resource = Puppet::Parser::Resource.new("default_param", "name", :scope => scope)
       resource.set_default_parameters(scope)
       resource["a"].should == "a_default_value"
     end
 
     it "should skip attributes with no default value" do
       environment.known_resource_types.add(
         Puppet::Resource::Type.new(:definition, "no_default_param", :arguments => {"a" => ast_string("a_default_value")})
       )
       resource = Puppet::Parser::Resource.new("no_default_param", "name", :scope => scope)
       lambda { resource.set_default_parameters(scope) }.should_not raise_error
     end
 
     it "should return the list of default parameters set" do
       environment.known_resource_types.add(
         Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_string("a_default_value")})
       )
       resource = Puppet::Parser::Resource.new("default_param", "name", :scope => scope)
       resource.set_default_parameters(scope).should == ["a"]
     end
 
     describe "when the resource type is :hostclass" do
       let(:environment_name) { "testing env" }
       let(:fact_values) { { :a => 1 } }
       let(:port) { Puppet::Parser::AST::String.new(:value => '80') }
       let(:apache) { Puppet::Resource::Type.new(:hostclass, 'apache', :arguments => { 'port' => port }) }
 
       before do
         environment.known_resource_types.add(apache)
 
         scope.stubs(:host).returns('host')
         scope.stubs(:environment).returns(environment)
         scope.stubs(:facts).returns(Puppet::Node::Facts.new("facts", fact_values))
       end
 
       context "when no value is provided" do
         before(:each) do
           Puppet[:binder] = true
         end
 
         let(:resource) do
           Puppet::Parser::Resource.new("class", "apache", :scope => scope)
         end
 
         it "should query the data_binding terminus using a namespaced key" do
           Puppet::DataBinding.indirection.expects(:find).with(
             'apache::port', all_of(has_key(:environment), has_key(:variables)))
           resource.set_default_parameters(scope)
         end
 
         it "should use the value from the data_binding terminus" do
           Puppet::DataBinding.indirection.expects(:find).returns('443')
 
           resource.set_default_parameters(scope)
 
           resource[:port].should == '443'
         end
 
         it "should use the default value if the data_binding terminus returns nil" do
           Puppet::DataBinding.indirection.expects(:find).returns(nil)
 
           resource.set_default_parameters(scope)
 
           resource[:port].should == '80'
         end
 
         it "should fail with error message about data binding on a hiera failure" do
           Puppet::DataBinding.indirection.expects(:find).raises(Puppet::DataBinding::LookupError, 'Forgettabotit')
           expect {
             resource.set_default_parameters(scope)
           }.to raise_error(Puppet::Error, /Error from DataBinding 'hiera' while looking up 'apache::port':.*Forgettabotit/)
         end
 
       end
 
       context "when a value is provided" do
         let(:port_parameter) do
           Puppet::Parser::Resource::Param.new(
             { :name => 'port', :value => '8080' }
           )
         end
 
         let(:resource) do
           Puppet::Parser::Resource.new("class", "apache", :scope => scope,
             :parameters => [port_parameter])
         end
 
         it "should not query the data_binding terminus" do
           Puppet::DataBinding.indirection.expects(:find).never
           resource.set_default_parameters(scope)
         end
 
         it "should not query the injector" do
           # enable the injector
           Puppet[:binder] = true
           compiler.injector.expects(:find).never
           resource.set_default_parameters(scope)
         end
 
         it "should use the value provided" do
           Puppet::DataBinding.indirection.expects(:find).never
           resource.set_default_parameters(scope).should == []
           resource[:port].should == '8080'
         end
       end
     end
   end
 
   describe "when validating all required parameters are present" do
     it "should be able to validate that all required parameters are present" do
       environment.known_resource_types.add(
         Puppet::Resource::Type.new(:definition, "required_param", :arguments => {"a" => nil})
       )
       lambda { Puppet::Resource.new("required_param", "name", :environment => environment).validate_complete }.should raise_error(Puppet::ParseError)
     end
 
     it "should not fail when all required parameters are present" do
       environment.known_resource_types.add(
         Puppet::Resource::Type.new(:definition, "no_required_param")
       )
       resource = Puppet::Resource.new("no_required_param", "name", :environment => environment)
       resource["a"] = "meh"
       lambda { resource.validate_complete }.should_not raise_error
     end
 
     it "should not validate against builtin types" do
       lambda { Puppet::Resource.new("file", "/bar").validate_complete }.should_not raise_error
     end
   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
       expect { Puppet::Resource.new("file", "/path", :strict => true, :parameters => {:nosuchparam => "bar"}) }.to raise_error
     end
 
     it "should fail if the resource type cannot be resolved" do
       expect { Puppet::Resource.new("nosuchtype", "/path", :strict => true) }.to 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")
       environment.known_resource_types.add type
       Puppet::Resource.new("foobar", "/my/file", :environment => environment).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})
       environment.known_resource_types.add type
       Puppet::Resource.new("foobar", "/my/file", :environment => environment).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"
       expect { resource[:name] = "eh" }.to_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 a native type" do
     before do
       @resource = Puppet::Resource.new("file", "/my/file")
       @resource["one"] = "test"
       @resource["two"] = "other"
     end
 
     it "should produce an equivalent yaml object" do
       text = @resource.render('yaml')
 
       newresource = Puppet::Resource.convert_from('yaml', text)
       newresource.should equal_resource_attributes_of @resource
     end
   end
 
   describe "when serializing a defined type" do
     before do
       type = Puppet::Resource::Type.new(:definition, "foo::bar")
       environment.known_resource_types.add type
 
       @resource = Puppet::Resource.new('foo::bar', 'xyzzy', :environment => environment)
       @resource['one'] = 'test'
       @resource['two'] = 'other'
       @resource.resource_type
     end
 
     it "doesn't include transient instance variables (#4506)" do
       expect(@resource.to_yaml_properties).to_not include :@rstype
     end
 
     it "produces an equivalent yaml object" do
       text = @resource.render('yaml')
 
       newresource = Puppet::Resource.convert_from('yaml', text)
       newresource.should equal_resource_attributes_of @resource
     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.must 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.must be_instance_of(Puppet::Type.type(:component))
       result.title.should == "Foobar[somename]"
     end
   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" 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
 
+  describe "when converting to Yaml for Hiera" do
+    before do
+      @resource = Puppet::Resource.new("one::two", "/my/file",
+        :parameters => {
+          :noop => true,
+          :foo => %w{one two},
+          :ensure => 'present',
+        }
+      )
+    end
+
+    it "should align and sort to attributes with ensure first" do
+      @resource.to_hierayaml.should == <<-HEREDOC.gsub(/^\s{8}/, '')
+          /my/file:
+            ensure: 'present'
+            foo   : ['one', 'two']
+            noop  : 'true'
+      HEREDOC
+    end
+  end
   describe "when converting to 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_data_hash(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_data_hash(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_data_hash(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_data_hash(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_data_hash(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_data_hash(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_data_hash(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_data_hash(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_data_hash(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_data_hash(PSON.parse(resource.to_pson))
       result[:requires].should == [ "File[/bar]",  "File[/baz]" ]
     end
   end
 
   describe "when converting from 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_data_hash(@data).type.should == "File"
     end
 
     it "should set its title to the provided title" do
       Puppet::Resource.from_data_hash(@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_data_hash(@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_data_hash(@data).file.should == "/foo/bar"
     end
 
     it "should set its line to the provided line" do
       @data['line'] = 50
       Puppet::Resource.from_data_hash(@data).line.should == 50
     end
 
     it "should 'exported' to true if set in the pson data" do
       @data['exported'] = true
       Puppet::Resource.from_data_hash(@data).exported.should be_true
     end
 
     it "should 'exported' to false if not set in the pson data" do
       Puppet::Resource.from_data_hash(@data).exported.should be_false
     end
 
     it "should fail if no title is provided" do
       @data.delete('title')
       expect { Puppet::Resource.from_data_hash(@data) }.to raise_error(ArgumentError)
     end
 
     it "should fail if no type is provided" do
       @data.delete('type')
       expect { Puppet::Resource.from_data_hash(@data) }.to 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_data_hash(@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_data_hash(@data)
       resource['foo'].should == %w{one}
     end
   end
 
   it "implements copy_as_resource" do
     resource = Puppet::Resource.new("file", "/my/file")
     resource.copy_as_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 '#parse_title' do
     describe 'with a composite namevar' do
       before do
         Puppet::Type.newtype(:composite) do
 
           newparam(:name)
           newparam(:value)
 
           # Configure two title patterns to match a title that is either
           # separated with a colon or exclamation point. The first capture
           # will be used for the :name param, and the second capture will be
           # used for the :value param.
           def self.title_patterns
             identity = lambda {|x| x }
             reverse  = lambda {|x| x.reverse }
             [
               [
                 /^(.*?):(.*?)$/,
                 [
                   [:name, identity],
                   [:value, identity],
                 ]
               ],
               [
                 /^(.*?)!(.*?)$/,
                 [
                   [:name, reverse],
                   [:value, reverse],
                 ]
               ],
             ]
           end
         end
       end
 
       describe "with no matching title patterns" do
         subject { Puppet::Resource.new(:composite, 'unmatching title')}
 
         it "should raise an exception if no title patterns match" do
           expect do
             subject.to_hash
           end.to raise_error(Puppet::Error, /No set of title patterns matched/)
         end
       end
 
       describe "with a matching title pattern" do
         subject { Puppet::Resource.new(:composite, 'matching:title') }
 
         it "should not raise an exception if there was a match" do
           expect do
             subject.to_hash
           end.to_not raise_error
         end
 
         it "should set the resource parameters from the parsed title values" do
           h = subject.to_hash
           h[:name].should == 'matching'
           h[:value].should == 'title'
         end
       end
 
       describe "and multiple title patterns" do
         subject { Puppet::Resource.new(:composite, 'matching!title') }
 
         it "should use the first title pattern that matches" do
           h = subject.to_hash
           h[:name].should == 'gnihctam'
           h[:value].should == 'eltit'
         end
       end
     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