diff --git a/lib/puppet/indirector/request.rb b/lib/puppet/indirector/request.rb
index 39b623046..a8f6bac59 100644
--- a/lib/puppet/indirector/request.rb
+++ b/lib/puppet/indirector/request.rb
@@ -1,308 +1,307 @@
 require 'cgi'
 require 'uri'
 require 'puppet/indirector'
-require 'puppet/util/pson'
 require 'puppet/network/resolver'
 
 # This class encapsulates all of the information you need to make an
 # Indirection call, and as a result also handles REST calls.  It's somewhat
 # analogous to an HTTP Request object, except tuned for our Indirector.
 class Puppet::Indirector::Request
   # FormatSupport for serialization methods
   include Puppet::Network::FormatSupport
 
   attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_terminus
 
   attr_accessor :server, :port, :uri, :protocol
 
   attr_reader :indirection_name
 
   # trusted_information is specifically left out because we can't serialize it
   # and keep it "trusted"
   OPTION_ATTRIBUTES = [:ip, :node, :authenticated, :ignore_terminus, :ignore_cache, :instance, :environment]
 
   def self.from_data_hash(data)
     raise ArgumentError, "No indirection name provided in data" unless indirection_name = data['type']
     raise ArgumentError, "No method name provided in data" unless method = data['method']
     raise ArgumentError, "No key provided in data" unless key = data['key']
 
     request = new(indirection_name, method, key, nil, data['attributes'])
 
     if instance = data['instance']
       klass = Puppet::Indirector::Indirection.instance(request.indirection_name).model
       if instance.is_a?(klass)
         request.instance = instance
       else
         request.instance = klass.from_data_hash(instance)
       end
     end
 
     request
   end
 
   def self.from_pson(json)
     Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
     self.from_data_hash(json)
   end
 
   def to_data_hash
     result = {
       'type' => indirection_name,
       'method' => method,
       'key' => key
     }
     attributes = {}
     OPTION_ATTRIBUTES.each do |key|
       next unless value = send(key)
       attributes[key] = value
     end
 
     options.each do |opt, value|
       attributes[opt] = value
     end
 
     result['attributes'] = attributes unless attributes.empty?
     result['instance'] = instance if instance
     result
   end
 
   # Is this an authenticated request?
   def authenticated?
     # Double negative, so we just get true or false
     ! ! authenticated
   end
 
   def environment
     # If environment has not been set directly, we should use the application's
     # current environment
     @environment ||= Puppet.lookup(:current_environment)
   end
 
   def environment=(env)
     @environment =
     if env.is_a?(Puppet::Node::Environment)
       env
     elsif (current_environment = Puppet.lookup(:current_environment)).name == env
       current_environment
     else
       Puppet.lookup(:environments).get(env) ||
       raise(Puppet::Environments::EnvironmentNotFound, env)
     end
   end
 
   def escaped_key
     URI.escape(key)
   end
 
   # LAK:NOTE This is a messy interface to the cache, and it's only
   # used by the Configurer class.  I decided it was better to implement
   # it now and refactor later, when we have a better design, than
   # to spend another month coming up with a design now that might
   # not be any better.
   def ignore_cache?
     ignore_cache
   end
 
   def ignore_terminus?
     ignore_terminus
   end
 
   def initialize(indirection_name, method, key, instance, options = {})
     @instance = instance
     options ||= {}
 
     self.indirection_name = indirection_name
     self.method = method
 
     options = options.inject({}) { |hash, ary| hash[ary[0].to_sym] = ary[1]; hash }
 
     set_attributes(options)
 
     @options = options
 
     if key
       # If the request key is a URI, then we need to treat it specially,
       # because it rewrites the key.  We could otherwise strip server/port/etc
       # info out in the REST class, but it seemed bad design for the REST
       # class to rewrite the key.
 
       if key.to_s =~ /^\w+:\// and not Puppet::Util.absolute_path?(key.to_s) # it's a URI
         set_uri_key(key)
       else
         @key = key
       end
     end
 
     @key = @instance.name if ! @key and @instance
   end
 
   # Look up the indirection based on the name provided.
   def indirection
     Puppet::Indirector::Indirection.instance(indirection_name)
   end
 
   def indirection_name=(name)
     @indirection_name = name.to_sym
   end
 
   def model
     raise ArgumentError, "Could not find indirection '#{indirection_name}'" unless i = indirection
     i.model
   end
 
   # Are we trying to interact with multiple resources, or just one?
   def plural?
     method == :search
   end
 
   # Create the query string, if options are present.
   def query_string
     return "" if options.nil? || options.empty?
 
     # For backward compatibility with older (pre-3.3) masters,
     # this puppet option allows serialization of query parameter
     # arrays as yaml.  This can be removed when we remove yaml
     # support entirely.
     if Puppet.settings[:legacy_query_parameter_serialization]
       replace_arrays_with_yaml
     end
 
     "?" + encode_params(expand_into_parameters(options.to_a))
   end
 
   def replace_arrays_with_yaml
     options.each do |key, value|
       case value
         when Array
           options[key] = YAML.dump(value)
       end
     end
   end
 
   def expand_into_parameters(data)
     data.inject([]) do |params, key_value|
       key, value = key_value
 
       expanded_value = case value
                        when Array
                          value.collect { |val| [key, val] }
                        else
                          [key_value]
                        end
 
       params.concat(expand_primitive_types_into_parameters(expanded_value))
     end
   end
 
   def expand_primitive_types_into_parameters(data)
     data.inject([]) do |params, key_value|
       key, value = key_value
       case value
       when nil
         params
       when true, false, String, Symbol, Fixnum, Bignum, Float
         params << [key, value]
       else
         raise ArgumentError, "HTTP REST queries cannot handle values of type '#{value.class}'"
       end
     end
   end
 
   def encode_params(params)
     params.collect do |key, value|
       "#{key}=#{CGI.escape(value.to_s)}"
     end.join("&")
   end
 
   def to_hash
     result = options.dup
 
     OPTION_ATTRIBUTES.each do |attribute|
       if value = send(attribute)
         result[attribute] = value
       end
     end
     result
   end
 
   def to_s
     return(uri ? uri : "/#{indirection_name}/#{key}")
   end
 
   def do_request(srv_service=:puppet, default_server=Puppet.settings[:server], default_port=Puppet.settings[:masterport], &block)
     # We were given a specific server to use, so just use that one.
     # This happens if someone does something like specifying a file
     # source using a puppet:// URI with a specific server.
     return yield(self) if !self.server.nil?
 
     if Puppet.settings[:use_srv_records]
       Puppet::Network::Resolver.each_srv_record(Puppet.settings[:srv_domain], srv_service) do |srv_server, srv_port|
         begin
           self.server = srv_server
           self.port   = srv_port
           return yield(self)
         rescue SystemCallError => e
           Puppet.warning "Error connecting to #{srv_server}:#{srv_port}: #{e.message}"
         end
       end
     end
 
     # ... Fall back onto the default server.
     Puppet.debug "No more servers left, falling back to #{default_server}:#{default_port}" if Puppet.settings[:use_srv_records]
     self.server = default_server
     self.port   = default_port
     return yield(self)
   end
 
   def remote?
     self.node or self.ip
   end
 
   private
 
   def set_attributes(options)
     OPTION_ATTRIBUTES.each do |attribute|
       if options.include?(attribute.to_sym)
         send(attribute.to_s + "=", options[attribute])
         options.delete(attribute)
       end
     end
   end
 
   # Parse the key as a URI, setting attributes appropriately.
   def set_uri_key(key)
     @uri = key
     begin
       uri = URI.parse(URI.escape(key))
     rescue => detail
       raise ArgumentError, "Could not understand URL #{key}: #{detail}", detail.backtrace
     end
 
     # Just short-circuit these to full paths
     if uri.scheme == "file"
       @key = Puppet::Util.uri_to_path(uri)
       return
     end
 
     @server = uri.host if uri.host
 
     # If the URI class can look up the scheme, it will provide a port,
     # otherwise it will default to '0'.
     if uri.port.to_i == 0 and uri.scheme == "puppet"
       @port = Puppet.settings[:masterport].to_i
     else
       @port = uri.port.to_i
     end
 
     @protocol = uri.scheme
 
     if uri.scheme == 'puppet'
       @key = URI.unescape(uri.path.sub(/^\//, ''))
       return
     end
 
     env, indirector, @key = URI.unescape(uri.path.sub(/^\//, '')).split('/',3)
     @key ||= ''
     self.environment = env unless env == ''
   end
 end
diff --git a/lib/puppet/node/facts.rb b/lib/puppet/node/facts.rb
index be9871377..867389773 100644
--- a/lib/puppet/node/facts.rb
+++ b/lib/puppet/node/facts.rb
@@ -1,155 +1,153 @@
 require 'time'
 
 require 'puppet/node'
 require 'puppet/indirector'
 
-require 'puppet/util/pson'
 
 # Manage a given node's facts.  This either accepts facts and stores them, or
 # returns facts for a given node.
 class Puppet::Node::Facts
   # Set up indirection, so that nodes can be looked for in
   # the node sources.
   extend Puppet::Indirector
-  extend Puppet::Util::Pson
 
   # We want to expire any cached nodes if the facts are saved.
   module NodeExpirer
     def save(instance, key = nil, options={})
       Puppet::Node.indirection.expire(instance.name, options)
       super
     end
   end
 
   indirects :facts, :terminus_setting => :facts_terminus, :extend => NodeExpirer
 
   attr_accessor :name, :values
 
   def add_local_facts
     values["clientcert"] = Puppet.settings[:certname]
     values["clientversion"] = Puppet.version.to_s
     values["clientnoop"] = Puppet.settings[:noop]
   end
 
   def initialize(name, values = {})
     @name = name
     @values = values
 
     add_timestamp
   end
 
   def initialize_from_hash(data)
     @name = data['name']
     @values = data['values']
     # Timestamp will be here in YAML
     timestamp = data['values']['_timestamp']
     @values.delete_if do |key, val|
       key =~ /^_/
     end
 
     #Timestamp will be here in pson
     timestamp ||= data['timestamp']
     timestamp = Time.parse(timestamp) if timestamp.is_a? String
     self.timestamp = timestamp
 
     self.expiration = data['expiration']
     if expiration.is_a? String
       self.expiration = Time.parse(expiration)
     end
   end
 
   # Convert all fact values into strings.
   def stringify
     values.each do |fact, value|
       values[fact] = value.to_s
     end
   end
 
   # Sanitize fact values by converting everything not a string, boolean
   # numeric, array or hash into strings.
   def sanitize
     values.each do |fact, value|
       values[fact] = sanitize_fact value
     end
   end
 
   def ==(other)
     return false unless self.name == other.name
     strip_internal == other.send(:strip_internal)
   end
 
   def self.from_data_hash(data)
     new_facts = allocate
     new_facts.initialize_from_hash(data)
     new_facts
   end
 
   def self.from_pson(data)
     Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
     self.from_data_hash(data)
   end
 
   def to_data_hash
     result = {
       'name' => name,
       'values' => strip_internal,
     }
 
     if timestamp
       if timestamp.is_a? Time
         result['timestamp'] = timestamp.iso8601(9)
       else
         result['timestamp'] = timestamp
       end
     end
 
     if expiration
       if expiration.is_a? Time
         result['expiration'] = expiration.iso8601(9)
       else
         result['expiration'] = expiration
       end
     end
 
     result
   end
 
   # Add internal data to the facts for storage.
   def add_timestamp
     self.timestamp = Time.now
   end
 
   def timestamp=(time)
     self.values['_timestamp'] = time
   end
 
   def timestamp
     self.values['_timestamp']
   end
 
   # Strip out that internal data.
   def strip_internal
     newvals = values.dup
     newvals.find_all { |name, value| name.to_s =~ /^_/ }.each { |name, value| newvals.delete(name) }
     newvals
   end
 
   private
 
   def sanitize_fact(fact)
     if fact.is_a? Hash then
       ret = {}
       fact.each_pair { |k,v| ret[sanitize_fact k]=sanitize_fact v }
       ret
     elsif fact.is_a? Array then
       fact.collect { |i| sanitize_fact i }
     elsif fact.is_a? Numeric \
       or fact.is_a? TrueClass \
       or fact.is_a? FalseClass \
       or fact.is_a? String
       fact
     else
       fact.to_s
     end
   end
 end
diff --git a/lib/puppet/relationship.rb b/lib/puppet/relationship.rb
index d360ed75c..3fa10092e 100644
--- a/lib/puppet/relationship.rb
+++ b/lib/puppet/relationship.rb
@@ -1,98 +1,95 @@
 # subscriptions are permanent associations determining how different
 # objects react to an event
 
-require 'puppet/util/pson'
-
 # This is Puppet's class for modeling edges in its configuration graph.
 # It used to be a subclass of GRATR::Edge, but that class has weird hash
 # overrides that dramatically slow down the graphing.
 class Puppet::Relationship
-  extend Puppet::Util::Pson
 
   # FormatSupport for serialization methods
   include Puppet::Network::FormatSupport
 
   attr_accessor :source, :target, :callback
 
   attr_reader :event
 
   def self.from_data_hash(data)
     source = data["source"]
     target = data["target"]
 
     args = {}
     if event = data["event"]
       args[:event] = event
     end
     if callback = data["callback"]
       args[:callback] = callback
     end
 
     new(source, target, args)
   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 event=(event)
     raise ArgumentError, "You must pass a callback for non-NONE events" if event != :NONE and ! callback
     @event = event
   end
 
   def initialize(source, target, options = {})
     @source, @target = source, target
 
     options = (options || {}).inject({}) { |h,a| h[a[0].to_sym] = a[1]; h }
     [:callback, :event].each do |option|
       if value = options[option]
         send(option.to_s + "=", value)
       end
     end
   end
 
   # Does the passed event match our event?  This is where the meaning
   # of :NONE comes from.
   def match?(event)
     if self.event.nil? or event == :NONE or self.event == :NONE
       return false
     elsif self.event == :ALL_EVENTS or event == self.event
       return true
     else
       return false
     end
   end
 
   def label
     result = {}
     result[:callback] = callback if callback
     result[:event] = event if event
     result
   end
 
   def ref
     "#{source} => #{target}"
   end
 
   def inspect
     "{ #{source} => #{target} }"
   end
 
   def to_data_hash
     data = {
       'source' => source.to_s,
       'target' => target.to_s
     }
 
     ["event", "callback"].each do |attr|
       next unless value = send(attr)
       data[attr] = value
     end
     data
   end
 
   def to_s
     ref
   end
 end
diff --git a/lib/puppet/resource.rb b/lib/puppet/resource.rb
index 0734c139a..464ef0247 100644
--- a/lib/puppet/resource.rb
+++ b/lib/puppet/resource.rb
@@ -1,623 +1,621 @@
 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
 
   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
 
   # 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/lib/puppet/resource/catalog.rb b/lib/puppet/resource/catalog.rb
index 1c8e1d7a7..d70e04650 100644
--- a/lib/puppet/resource/catalog.rb
+++ b/lib/puppet/resource/catalog.rb
@@ -1,539 +1,537 @@
 require 'puppet/node'
 require 'puppet/indirector'
 require 'puppet/transaction'
-require 'puppet/util/pson'
 require 'puppet/util/tagging'
 require 'puppet/graph'
 
 # This class models a node catalog.  It is the thing meant to be passed
 # from server to client, and it contains all of the information in the
 # catalog, including the resources and the relationships between them.
 #
 # @api public
 
 class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   class DuplicateResourceError < Puppet::Error
     include Puppet::ExternalFileError
   end
 
   extend Puppet::Indirector
   indirects :catalog, :terminus_setting => :catalog_terminus
 
   include Puppet::Util::Tagging
-  extend Puppet::Util::Pson
 
   # The host name this is a catalog for.
   attr_accessor :name
 
   # The catalog version.  Used for testing whether a catalog
   # is up to date.
   attr_accessor :version
 
   # How long this catalog took to retrieve.  Used for reporting stats.
   attr_accessor :retrieval_duration
 
   # Whether this is a host catalog, which behaves very differently.
   # In particular, reports are sent, graphs are made, and state is
   # stored in the state database.  If this is set incorrectly, then you often
   # end up in infinite loops, because catalogs are used to make things
   # that the host catalog needs.
   attr_accessor :host_config
 
   # Whether this catalog was retrieved from the cache, which affects
   # whether it is written back out again.
   attr_accessor :from_cache
 
   # Some metadata to help us compile and generally respond to the current state.
   attr_accessor :client_version, :server_version
 
   # A String representing the environment for this catalog
   attr_accessor :environment
 
   # The actual environment instance that was used during compilation
   attr_accessor :environment_instance
 
   # Add classes to our class list.
   def add_class(*classes)
     classes.each do |klass|
       @classes << klass
     end
 
     # Add the class names as tags, too.
     tag(*classes)
   end
 
   def title_key_for_ref( ref )
     ref =~ /^([-\w:]+)\[(.*)\]$/m
     [$1, $2]
   end
 
   def add_resource(*resources)
     resources.each do |resource|
       add_one_resource(resource)
     end
   end
 
   # @param resource [A Resource] a resource in the catalog
   # @return [A Resource, nil] the resource that contains the given resource
   # @api public
   def container_of(resource)
     adjacent(resource, :direction => :in)[0]
   end
 
   def add_one_resource(resource)
     title_key = title_key_for_ref(resource.ref)
     if @resource_table[title_key]
       fail_on_duplicate_type_and_title(resource, title_key)
     end
 
     add_resource_to_table(resource, title_key)
     create_resource_aliases(resource)
 
     resource.catalog = self if resource.respond_to?(:catalog=)
     add_resource_to_graph(resource)
   end
   private :add_one_resource
 
   def add_resource_to_table(resource, title_key)
     @resource_table[title_key] = resource
     @resources << title_key
   end
   private :add_resource_to_table
 
   def add_resource_to_graph(resource)
     add_vertex(resource)
     @relationship_graph.add_vertex(resource) if @relationship_graph
   end
   private :add_resource_to_graph
 
   def create_resource_aliases(resource)
     if resource.respond_to?(:isomorphic?) and resource.isomorphic? and resource.name != resource.title
       self.alias(resource, resource.uniqueness_key)
     end
   end
   private :create_resource_aliases
 
   # Create an alias for a resource.
   def alias(resource, key)
     resource.ref =~ /^(.+)\[/
     class_name = $1 || resource.class.name
 
     newref = [class_name, key].flatten
 
     if key.is_a? String
       ref_string = "#{class_name}[#{key}]"
       return if ref_string == resource.ref
     end
 
     # LAK:NOTE It's important that we directly compare the references,
     # because sometimes an alias is created before the resource is
     # added to the catalog, so comparing inside the below if block
     # isn't sufficient.
     if existing = @resource_table[newref]
       return if existing == resource
       resource_declaration = " at #{resource.file}:#{resource.line}" if resource.file and resource.line
       existing_declaration = " at #{existing.file}:#{existing.line}" if existing.file and existing.line
       msg = "Cannot alias #{resource.ref} to #{key.inspect}#{resource_declaration}; resource #{newref.inspect} already declared#{existing_declaration}"
       raise ArgumentError, msg
     end
     @resource_table[newref] = resource
     @aliases[resource.ref] ||= []
     @aliases[resource.ref] << newref
   end
 
   # Apply our catalog to the local host.
   # @param options [Hash{Symbol => Object}] a hash of options
   # @option options [Puppet::Transaction::Report] :report
   #   The report object to log this transaction to. This is optional,
   #   and the resulting transaction will create a report if not
   #   supplied.
   # @option options [Array[String]] :tags
   #   Tags used to filter the transaction. If supplied then only
   #   resources tagged with any of these tags will be evaluated.
   # @option options [Boolean] :ignoreschedules
   #   Ignore schedules when evaluating resources
   # @option options [Boolean] :for_network_device
   #   Whether this catalog is for a network device
   #
   # @return [Puppet::Transaction] the transaction created for this
   #   application
   #
   # @api public
   def apply(options = {})
     Puppet::Util::Storage.load if host_config?
 
     transaction = create_transaction(options)
 
     begin
       transaction.report.as_logging_destination do
         transaction.evaluate
       end
     rescue Puppet::Error => detail
       Puppet.log_exception(detail, "Could not apply complete catalog: #{detail}")
     rescue => detail
       Puppet.log_exception(detail, "Got an uncaught exception of type #{detail.class}: #{detail}")
     ensure
       # Don't try to store state unless we're a host config
       # too recursive.
       Puppet::Util::Storage.store if host_config?
     end
 
     yield transaction if block_given?
 
     transaction
   end
 
   # The relationship_graph form of the catalog. This contains all of the
   # dependency edges that are used for determining order.
   #
   # @param given_prioritizer [Puppet::Graph::Prioritizer] The prioritization
   #   strategy to use when constructing the relationship graph. Defaults the
   #   being determined by the `ordering` setting.
   # @return [Puppet::Graph::RelationshipGraph]
   # @api public
   def relationship_graph(given_prioritizer = nil)
     if @relationship_graph.nil?
       @relationship_graph = Puppet::Graph::RelationshipGraph.new(given_prioritizer || prioritizer)
       @relationship_graph.populate_from(self)
     end
     @relationship_graph
   end
 
   def clear(remove_resources = true)
     super()
     # We have to do this so that the resources clean themselves up.
     @resource_table.values.each { |resource| resource.remove } if remove_resources
     @resource_table.clear
     @resources = []
 
     if @relationship_graph
       @relationship_graph.clear
       @relationship_graph = nil
     end
   end
 
   def classes
     @classes.dup
   end
 
   # Create a new resource and register it in the catalog.
   def create_resource(type, options)
     unless klass = Puppet::Type.type(type)
       raise ArgumentError, "Unknown resource type #{type}"
     end
     return unless resource = klass.new(options)
 
     add_resource(resource)
     resource
   end
 
   # Make sure all of our resources are "finished".
   def finalize
     make_default_resources
 
     @resource_table.values.each { |resource| resource.finish }
 
     write_graph(:resources)
   end
 
   def host_config?
     host_config
   end
 
   def initialize(name = nil, environment = Puppet::Node::Environment::NONE)
     super()
     @name = name
     @classes = []
     @resource_table = {}
     @resources = []
     @relationship_graph = nil
 
     @host_config = true
     @environment_instance = environment
     @environment = environment.to_s
 
     @aliases = {}
 
     if block_given?
       yield(self)
       finalize
     end
   end
 
   # Make the default objects necessary for function.
   def make_default_resources
     # We have to add the resources to the catalog, or else they won't get cleaned up after
     # the transaction.
 
     # First create the default scheduling objects
     Puppet::Type.type(:schedule).mkdefaultschedules.each { |res| add_resource(res) unless resource(res.ref) }
 
     # And filebuckets
     if bucket = Puppet::Type.type(:filebucket).mkdefaultbucket
       add_resource(bucket) unless resource(bucket.ref)
     end
   end
 
   # Remove the resource from our catalog.  Notice that we also call
   # 'remove' on the resource, at least until resource classes no longer maintain
   # references to the resource instances.
   def remove_resource(*resources)
     resources.each do |resource|
       title_key = title_key_for_ref(resource.ref)
       @resource_table.delete(title_key)
       if aliases = @aliases[resource.ref]
         aliases.each { |res_alias| @resource_table.delete(res_alias) }
         @aliases.delete(resource.ref)
       end
       remove_vertex!(resource) if vertex?(resource)
       @relationship_graph.remove_vertex!(resource) if @relationship_graph and @relationship_graph.vertex?(resource)
       @resources.delete(title_key)
       resource.remove
     end
   end
 
   # Look a resource up by its reference (e.g., File[/etc/passwd]).
   def resource(type, title = nil)
     # Always create a resource reference, so that it always
     # canonicalizes how we are referring to them.
     if title
       res = Puppet::Resource.new(type, title)
     else
       # If they didn't provide a title, then we expect the first
       # argument to be of the form 'Class[name]', which our
       # Reference class canonicalizes for us.
       res = Puppet::Resource.new(nil, type)
     end
     res.catalog = self
     title_key      = [res.type, res.title.to_s]
     uniqueness_key = [res.type, res.uniqueness_key].flatten
     @resource_table[title_key] || @resource_table[uniqueness_key]
   end
 
   def resource_refs
     resource_keys.collect{ |type, name| name.is_a?( String ) ? "#{type}[#{name}]" : nil}.compact
   end
 
   def resource_keys
     @resource_table.keys
   end
 
   def resources
     @resources.collect do |key|
       @resource_table[key]
     end
   end
 
   def self.from_data_hash(data)
     result = new(data['name'], Puppet::Node::Environment::NONE)
 
     if tags = data['tags']
       result.tag(*tags)
     end
 
     if version = data['version']
       result.version = version
     end
 
     if environment = data['environment']
       result.environment = environment
       result.environment_instance = Puppet::Node::Environment.remote(environment.to_sym)
     end
 
     if resources = data['resources']
       result.add_resource(*resources.collect do |res|
         Puppet::Resource.from_data_hash(res)
       end)
     end
 
     if edges = data['edges']
       edges.each do |edge_hash|
         edge = Puppet::Relationship.from_data_hash(edge_hash)
         unless source = result.resource(edge.source)
           raise ArgumentError, "Could not intern from data: Could not find relationship source #{edge.source.inspect} for #{edge.target.to_s}"
         end
         edge.source = source
 
         unless target = result.resource(edge.target)
           raise ArgumentError, "Could not intern from data: Could not find relationship target #{edge.target.inspect} for #{edge.source.to_s}"
         end
         edge.target = target
 
         result.add_edge(edge)
       end
     end
 
     if classes = data['classes']
       result.add_class(*classes)
     end
 
     result
   end
 
   def self.from_pson(data)
     Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
     self.from_data_hash(data)
   end
 
   def to_data_hash
     {
       'tags'      => tags,
       'name'      => name,
       'version'   => version,
       'environment' => environment.to_s,
       'resources' => @resources.collect { |v| @resource_table[v].to_data_hash },
       'edges'     => edges.   collect { |e| e.to_data_hash },
       'classes'   => classes
     }
   end
 
   # Convert our catalog into a RAL catalog.
   def to_ral
     to_catalog :to_ral
   end
 
   # Convert our catalog into a catalog of Puppet::Resource instances.
   def to_resource
     to_catalog :to_resource
   end
 
   # filter out the catalog, applying +block+ to each resource.
   # If the block result is false, the resource will
   # be kept otherwise it will be skipped
   def filter(&block)
     to_catalog :to_resource, &block
   end
 
   # Store the classes in the classfile.
   def write_class_file
     ::File.open(Puppet[:classfile], "w") do |f|
       f.puts classes.join("\n")
     end
   rescue => detail
     Puppet.err "Could not create class file #{Puppet[:classfile]}: #{detail}"
   end
 
   # Store the list of resources we manage
   def write_resource_file
     ::File.open(Puppet[:resourcefile], "w") do |f|
       to_print = resources.map do |resource|
         next unless resource.managed?
         if resource.name_var
           "#{resource.type}[#{resource[resource.name_var]}]"
         else
           "#{resource.ref.downcase}"
         end
       end.compact
       f.puts to_print.join("\n")
     end
   rescue => detail
     Puppet.err "Could not create resource file #{Puppet[:resourcefile]}: #{detail}"
   end
 
   # Produce the graph files if requested.
   def write_graph(name)
     # We only want to graph the main host catalog.
     return unless host_config?
 
     super
   end
 
   private
 
   def prioritizer
     @prioritizer ||= case Puppet[:ordering]
                      when "title-hash"
                        Puppet::Graph::TitleHashPrioritizer.new
                      when "manifest"
                        Puppet::Graph::SequentialPrioritizer.new
                      when "random"
                        Puppet::Graph::RandomPrioritizer.new
                      else
                        raise Puppet::DevError, "Unknown ordering type #{Puppet[:ordering]}"
                      end
   end
 
   def create_transaction(options)
     transaction = Puppet::Transaction.new(self, options[:report], prioritizer)
     transaction.tags = options[:tags] if options[:tags]
     transaction.ignoreschedules = true if options[:ignoreschedules]
     transaction.for_network_device = options[:network_device]
 
     transaction
   end
 
   # Verify that the given resource isn't declared elsewhere.
   def fail_on_duplicate_type_and_title(resource, title_key)
     # Short-circuit the common case,
     return unless existing_resource = @resource_table[title_key]
 
     # If we've gotten this far, it's a real conflict
     msg = "Duplicate declaration: #{resource.ref} is already declared"
 
     msg << " in file #{existing_resource.file}:#{existing_resource.line}" if existing_resource.file and existing_resource.line
 
     msg << "; cannot redeclare"
 
     raise DuplicateResourceError.new(msg, resource.file, resource.line)
   end
 
   # An abstracted method for converting one catalog into another type of catalog.
   # This pretty much just converts all of the resources from one class to another, using
   # a conversion method.
   def to_catalog(convert)
     result = self.class.new(self.name, self.environment_instance)
 
     result.version = self.version
 
     map = {}
     resources.each do |resource|
       next if virtual_not_exported?(resource)
       next if block_given? and yield resource
 
       newres = resource.copy_as_resource
       newres.catalog = result
 
       if convert != :to_resource
         newres = newres.to_ral
       end
 
       # We can't guarantee that resources don't munge their names
       # (like files do with trailing slashes), so we have to keep track
       # of what a resource got converted to.
       map[resource.ref] = newres
 
       result.add_resource newres
     end
 
     message = convert.to_s.gsub "_", " "
     edges.each do |edge|
       # Skip edges between virtual resources.
       next if virtual_not_exported?(edge.source)
       next if block_given? and yield edge.source
 
       next if virtual_not_exported?(edge.target)
       next if block_given? and yield edge.target
 
       unless source = map[edge.source.ref]
         raise Puppet::DevError, "Could not find resource #{edge.source.ref} when converting #{message} resources"
       end
 
       unless target = map[edge.target.ref]
         raise Puppet::DevError, "Could not find resource #{edge.target.ref} when converting #{message} resources"
       end
 
       result.add_edge(source, target, edge.label)
     end
 
     map.clear
 
     result.add_class(*self.classes)
     result.tag(*self.tags)
 
     result
   end
 
   def virtual_not_exported?(resource)
     resource.virtual && !resource.exported
   end
 end
diff --git a/lib/puppet/util/pson.rb b/lib/puppet/util/pson.rb
deleted file mode 100644
index b796cb111..000000000
--- a/lib/puppet/util/pson.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-# A simple module to provide consistency between how we use PSON and how
-# ruby expects it to be used.  Basically, we don't want to require
-# that the sender specify a class.
-#  Ruby wants everyone to provide a 'type' field, and the PSON support
-# requires such a field to track the class down.  Because we use our URL to
-# figure out what class we're working on, we don't need that, and we don't want
-# our consumers and producers to need to know anything about our internals.
-module Puppet::Util::Pson
-  def pson_create(pson)
-    raise ArgumentError, "No data provided in pson data" unless pson['data']
-    from_data_hash(pson['data'])
-  end
-end
diff --git a/spec/lib/puppet/indirector_testing.rb b/spec/lib/puppet/indirector_testing.rb
index 9bea43206..9f9b2207a 100644
--- a/spec/lib/puppet/indirector_testing.rb
+++ b/spec/lib/puppet/indirector_testing.rb
@@ -1,28 +1,27 @@
 require 'puppet/indirector'
-require 'puppet/util/pson'
 
 class Puppet::IndirectorTesting
   extend Puppet::Indirector
   indirects :indirector_testing
 
   # We should have some way to identify if we got a valid object back with the
   # current values, no?
   attr_accessor :value
   alias_method :name, :value
   alias_method :name=, :value=
   def initialize(value)
     self.value = value
   end
 
   def self.from_raw(raw)
     new(raw)
   end
 
   def self.from_data_hash(data)
     new(data['value'])
   end
 
   def to_data_hash
     { 'value' => value }
   end
 end
diff --git a/spec/unit/util/pson_spec.rb b/spec/unit/external/pson_spec.rb
similarity index 73%
rename from spec/unit/util/pson_spec.rb
rename to spec/unit/external/pson_spec.rb
index c2307498f..94d6135fb 100755
--- a/spec/unit/util/pson_spec.rb
+++ b/spec/unit/external/pson_spec.rb
@@ -1,71 +1,55 @@
 #! /usr/bin/env ruby
 # Encoding: UTF-8
 require 'spec_helper'
 
-require 'puppet/util/pson'
-
-class PsonUtil
-  include Puppet::Util::Pson
-end
-
-describe Puppet::Util::Pson do
-  it "should fail if no data is provided" do
-    expect {
-      PsonUtil.new.pson_create("type" => "foo")
-    }.to raise_error(ArgumentError, /No data provided in pson data/)
-  end
-
-  it "should call 'from_data_hash' with the provided data" do
-    pson = PsonUtil.new
-    pson.expects(:from_data_hash).with("mydata")
-    pson.pson_create("type" => "foo", "data" => "mydata")
-  end
+require 'puppet/external/pson/common'
 
+describe PSON do
   {
     'foo' => '"foo"',
     1 => '1',
     "\x80" => "\"\x80\"",
     [] => '[]'
   }.each do |str, expect|
     it "should be able to encode #{str.inspect}" do
       got = str.to_pson
       if got.respond_to? :force_encoding
         got.force_encoding('binary').should == expect.force_encoding('binary')
       else
         got.should == expect
       end
     end
   end
 
   it "should be able to handle arbitrary binary data" do
     bin_string = (1..20000).collect { |i| ((17*i+13*i*i) % 255).chr }.join
     parsed = PSON.parse(%Q{{ "type": "foo", "data": #{bin_string.to_pson} }})["data"]
 
     if parsed.respond_to? :force_encoding
       parsed.force_encoding('binary')
       bin_string.force_encoding('binary')
     end
 
     parsed.should == bin_string
   end
 
   it "should be able to handle UTF8 that isn't a real unicode character" do
     s = ["\355\274\267"]
     PSON.parse( [s].to_pson ).should == [s]
   end
 
   it "should be able to handle UTF8 for \\xFF" do
     s = ["\xc3\xbf"]
     PSON.parse( [s].to_pson ).should == [s]
   end
 
   it "should be able to handle invalid UTF8 bytes" do
     s = ["\xc3\xc3"]
     PSON.parse( [s].to_pson ).should == [s]
   end
 
   it "should be able to parse JSON containing UTF-8 characters in strings" do
     s = '{ "foö": "bár" }'
     lambda { PSON.parse s }.should_not raise_error
   end
 end
diff --git a/spec/unit/indirector/request_spec.rb b/spec/unit/indirector/request_spec.rb
index 7f369d1b0..849d4fbad 100755
--- a/spec/unit/indirector/request_spec.rb
+++ b/spec/unit/indirector/request_spec.rb
@@ -1,593 +1,592 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'matchers/json'
 require 'puppet/indirector/request'
-require 'puppet/util/pson'
 
 describe Puppet::Indirector::Request do
   include JSONMatchers
 
   describe "when initializing" do
     it "should always convert the indirection name to a symbol" do
       Puppet::Indirector::Request.new("ind", :method, "mykey", nil).indirection_name.should == :ind
     end
 
     it "should use provided value as the key if it is a string" do
       Puppet::Indirector::Request.new(:ind, :method, "mykey", nil).key.should == "mykey"
     end
 
     it "should use provided value as the key if it is a symbol" do
       Puppet::Indirector::Request.new(:ind, :method, :mykey, nil).key.should == :mykey
     end
 
     it "should use the name of the provided instance as its key if an instance is provided as the key instead of a string" do
       instance = mock 'instance', :name => "mykey"
       request = Puppet::Indirector::Request.new(:ind, :method, nil, instance)
       request.key.should == "mykey"
       request.instance.should equal(instance)
     end
 
     it "should support options specified as a hash" do
       expect { Puppet::Indirector::Request.new(:ind, :method, :key, nil, :one => :two) }.to_not raise_error
     end
 
     it "should support nil options" do
       expect { Puppet::Indirector::Request.new(:ind, :method, :key, nil, nil) }.to_not raise_error
     end
 
     it "should support unspecified options" do
       expect { Puppet::Indirector::Request.new(:ind, :method, :key, nil) }.to_not raise_error
     end
 
     it "should use an empty options hash if nil was provided" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, nil).options.should == {}
     end
 
     it "should default to a nil node" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil).node.should be_nil
     end
 
     it "should set its node attribute if provided in the options" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, :node => "foo.com").node.should == "foo.com"
     end
 
     it "should default to a nil ip" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil).ip.should be_nil
     end
 
     it "should set its ip attribute if provided in the options" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ip => "192.168.0.1").ip.should == "192.168.0.1"
     end
 
     it "should default to being unauthenticated" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil).should_not be_authenticated
     end
 
     it "should set be marked authenticated if configured in the options" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, :authenticated => "eh").should be_authenticated
     end
 
     it "should keep its options as a hash even if a node is specified" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, :node => "eh").options.should be_instance_of(Hash)
     end
 
     it "should keep its options as a hash even if another option is specified" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, :foo => "bar").options.should be_instance_of(Hash)
     end
 
     it "should treat options other than :ip, :node, and :authenticated as options rather than attributes" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, :server => "bar").options[:server].should == "bar"
     end
 
     it "should normalize options to use symbols as keys" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, "foo" => "bar").options[:foo].should == "bar"
     end
 
     describe "and the request key is a URI" do
       let(:file) { File.expand_path("/my/file with spaces") }
 
       describe "and the URI is a 'file' URI" do
         before do
           @request = Puppet::Indirector::Request.new(:ind, :method, "#{URI.unescape(Puppet::Util.path_to_uri(file).to_s)}", nil)
         end
 
         it "should set the request key to the unescaped full file path" do
           @request.key.should == file
         end
 
         it "should not set the protocol" do
           @request.protocol.should be_nil
         end
 
         it "should not set the port" do
           @request.port.should be_nil
         end
 
         it "should not set the server" do
           @request.server.should be_nil
         end
       end
 
       it "should set the protocol to the URI scheme" do
         Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff", nil).protocol.should == "http"
       end
 
       it "should set the server if a server is provided" do
         Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff", nil).server.should == "host"
       end
 
       it "should set the server and port if both are provided" do
         Puppet::Indirector::Request.new(:ind, :method, "http://host:543/stuff", nil).port.should == 543
       end
 
       it "should default to the masterport if the URI scheme is 'puppet'" do
         Puppet[:masterport] = "321"
         Puppet::Indirector::Request.new(:ind, :method, "puppet://host/stuff", nil).port.should == 321
       end
 
       it "should use the provided port if the URI scheme is not 'puppet'" do
         Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff", nil).port.should == 80
       end
 
       it "should set the request key to the unescaped key part path from the URI" do
         Puppet::Indirector::Request.new(:ind, :method, "http://host/environment/terminus/stuff with spaces", nil).key.should == "stuff with spaces"
       end
 
       it "should set the :uri attribute to the full URI" do
         Puppet::Indirector::Request.new(:ind, :method, "http:///stu ff", nil).uri.should == 'http:///stu ff'
       end
 
       it "should not parse relative URI" do
         Puppet::Indirector::Request.new(:ind, :method, "foo/bar", nil).uri.should be_nil
       end
 
       it "should not parse opaque URI" do
         Puppet::Indirector::Request.new(:ind, :method, "mailto:joe", nil).uri.should be_nil
       end
     end
 
     it "should allow indication that it should not read a cached instance" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ignore_cache => true).should be_ignore_cache
     end
 
     it "should default to not ignoring the cache" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil).should_not be_ignore_cache
     end
 
     it "should allow indication that it should not not read an instance from the terminus" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ignore_terminus => true).should be_ignore_terminus
     end
 
     it "should default to not ignoring the terminus" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil).should_not be_ignore_terminus
     end
   end
 
   it "should look use the Indirection class to return the appropriate indirection" do
     ind = mock 'indirection'
     Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
     request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
     request.indirection.should equal(ind)
   end
 
   it "should use its indirection to look up the appropriate model" do
     ind = mock 'indirection'
     Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
     request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
     ind.expects(:model).returns "mymodel"
 
     request.model.should == "mymodel"
   end
 
   it "should fail intelligently when asked to find a model but the indirection cannot be found" do
     Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns nil
     request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
     expect { request.model }.to raise_error(ArgumentError)
   end
 
   it "should have a method for determining if the request is plural or singular" do
     Puppet::Indirector::Request.new(:myind, :method, :key, nil).should respond_to(:plural?)
   end
 
   it "should be considered plural if the method is 'search'" do
     Puppet::Indirector::Request.new(:myind, :search, :key, nil).should be_plural
   end
 
   it "should not be considered plural if the method is not 'search'" do
     Puppet::Indirector::Request.new(:myind, :find, :key, nil).should_not be_plural
   end
 
   it "should use its uri, if it has one, as its string representation" do
     Puppet::Indirector::Request.new(:myind, :find, "foo://bar/baz", nil).to_s.should == "foo://bar/baz"
   end
 
   it "should use its indirection name and key, if it has no uri, as its string representation" do
     Puppet::Indirector::Request.new(:myind, :find, "key", nil) == "/myind/key"
   end
 
   it "should be able to return the URI-escaped key" do
     Puppet::Indirector::Request.new(:myind, :find, "my key", nil).escaped_key.should == URI.escape("my key")
   end
 
   it "should set its environment to an environment instance when a string is specified as its environment" do
     env = Puppet::Node::Environment.create(:foo, [])
 
     Puppet.override(:environments => Puppet::Environments::Static.new(env)) do
       Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => "foo").environment.should == env
     end
   end
 
   it "should use any passed in environment instances as its environment" do
     env = Puppet::Node::Environment.create(:foo, [])
 
     Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => env).environment.should equal(env)
   end
 
   it "should use the current environment when none is provided" do
     configured = Puppet::Node::Environment.create(:foo, [])
 
     Puppet[:environment] = "foo"
 
     expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil).environment).to eq(Puppet.lookup(:current_environment))
   end
 
   it "should support converting its options to a hash" do
     Puppet::Indirector::Request.new(:myind, :find, "my key", nil ).should respond_to(:to_hash)
   end
 
   it "should include all of its attributes when its options are converted to a hash" do
     Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :node => 'foo').to_hash[:node].should == 'foo'
   end
 
   describe "when building a query string from its options" do
     def a_request_with_options(options)
       Puppet::Indirector::Request.new(:myind, :find, "my key", nil, options)
     end
 
     def the_parsed_query_string_from(request)
       CGI.parse(request.query_string.sub(/^\?/, ''))
     end
 
     it "should return an empty query string if there are no options" do
       request = a_request_with_options(nil)
 
       request.query_string.should == ""
     end
 
     it "should return an empty query string if the options are empty" do
       request = a_request_with_options({})
 
       request.query_string.should == ""
     end
 
     it "should prefix the query string with '?'" do
       request = a_request_with_options(:one => "two")
 
       request.query_string.should =~ /^\?/
     end
 
     it "should include all options in the query string, separated by '&'" do
       request = a_request_with_options(:one => "two", :three => "four")
 
       the_parsed_query_string_from(request).should == {
         "one" => ["two"],
         "three" => ["four"]
       }
     end
 
     it "should ignore nil options" do
       request = a_request_with_options(:one => "two", :three => nil)
 
       the_parsed_query_string_from(request).should == {
         "one" => ["two"]
       }
     end
 
     it "should convert 'true' option values into strings" do
       request = a_request_with_options(:one => true)
 
       the_parsed_query_string_from(request).should == {
         "one" => ["true"]
       }
     end
 
     it "should convert 'false' option values into strings" do
       request = a_request_with_options(:one => false)
 
       the_parsed_query_string_from(request).should == {
         "one" => ["false"]
       }
     end
 
     it "should convert to a string all option values that are integers" do
       request = a_request_with_options(:one => 50)
 
       the_parsed_query_string_from(request).should == {
         "one" => ["50"]
       }
     end
 
     it "should convert to a string all option values that are floating point numbers" do
       request = a_request_with_options(:one => 1.2)
 
       the_parsed_query_string_from(request).should == {
         "one" => ["1.2"]
       }
     end
 
     it "should CGI-escape all option values that are strings" do
       request = a_request_with_options(:one => "one two")
 
       the_parsed_query_string_from(request).should == {
         "one" => ["one two"]
       }
     end
 
     it "should convert an array of values into multiple entries for the same key" do
       request = a_request_with_options(:one => %w{one two})
 
       the_parsed_query_string_from(request).should == {
         "one" => ["one", "two"]
       }
     end
 
     it "should convert an array of values into a single yaml entry when in legacy mode" do
       Puppet[:legacy_query_parameter_serialization] = true
       request = a_request_with_options(:one => %w{one two})
 
       the_parsed_query_string_from(request).should == {
           "one" => ["--- \n  - one\n  - two"]
       }
     end
 
     it "should stringify simple data types inside an array" do
       request = a_request_with_options(:one => ['one', nil])
 
       the_parsed_query_string_from(request).should == {
         "one" => ["one"]
       }
     end
 
     it "should error if an array contains another array" do
       request = a_request_with_options(:one => ['one', ["not allowed"]])
 
       expect { request.query_string }.to raise_error(ArgumentError)
     end
 
     it "should error if an array contains illegal data" do
       request = a_request_with_options(:one => ['one', { :not => "allowed" }])
 
       expect { request.query_string }.to raise_error(ArgumentError)
     end
 
     it "should convert to a string and CGI-escape all option values that are symbols" do
       request = a_request_with_options(:one => :"sym bol")
 
       the_parsed_query_string_from(request).should == {
         "one" => ["sym bol"]
       }
     end
 
     it "should fail if options other than booleans or strings are provided" do
       request = a_request_with_options(:one => { :one => :two })
 
       expect { request.query_string }.to raise_error(ArgumentError)
     end
   end
 
   describe "when converting to json" do
     before do
       @request = Puppet::Indirector::Request.new(:facts, :find, "foo", nil)
     end
 
     it "should set the 'key'" do
       @request.should set_json_attribute("key").to("foo")
     end
 
     it "should include an attribute for its indirection name" do
       @request.should set_json_attribute("type").to("facts")
     end
 
     it "should include a 'method' attribute set to its method" do
       @request.should set_json_attribute("method").to("find")
     end
 
     it "should add all attributes under the 'attributes' attribute" do
       @request.ip = "127.0.0.1"
       @request.should set_json_attribute("attributes", "ip").to("127.0.0.1")
     end
 
     it "should add all options under the 'attributes' attribute" do
       @request.options["opt"] = "value"
       PSON.parse(@request.to_pson)['attributes']['opt'].should == "value"
     end
 
     it "should include the instance if provided" do
       facts = Puppet::Node::Facts.new("foo")
       @request.instance = facts
       PSON.parse(@request.to_pson)['instance'].should be_instance_of(Hash)
     end
   end
 
   describe "when converting from json" do
     before do
       @request = Puppet::Indirector::Request.new(:facts, :find, "foo", nil)
       @klass = Puppet::Indirector::Request
       @format = Puppet::Network::FormatHandler.format('pson')
     end
 
     def from_json(json)
       @format.intern(Puppet::Indirector::Request, json)
     end
 
     it "should set the 'key'" do
       from_json(@request.to_pson).key.should == "foo"
     end
 
     it "should fail if no key is provided" do
       json = PSON.parse(@request.to_pson)
       json.delete("key")
       expect { from_json(json.to_pson) }.to raise_error(ArgumentError)
     end
 
     it "should set its indirector name" do
       from_json(@request.to_pson).indirection_name.should == :facts
     end
 
     it "should fail if no type is provided" do
       json = PSON.parse(@request.to_pson)
       json.delete("type")
       expect { from_json(json.to_pson) }.to raise_error(ArgumentError)
     end
 
     it "should set its method" do
       from_json(@request.to_pson).method.should == "find"
     end
 
     it "should fail if no method is provided" do
       json = PSON.parse(@request.to_pson)
       json.delete("method")
       expect { from_json(json.to_pson) }.to raise_error(ArgumentError)
     end
 
     it "should initialize with all attributes and options" do
       @request.ip = "127.0.0.1"
       @request.options["opt"] = "value"
       result = from_json(@request.to_pson)
       result.options[:opt].should == "value"
       result.ip.should == "127.0.0.1"
     end
 
     it "should set its instance as an instance if one is provided" do
       facts = Puppet::Node::Facts.new("foo")
       @request.instance = facts
       result = from_json(@request.to_pson)
       result.instance.should be_instance_of(Puppet::Node::Facts)
     end
   end
 
   context '#do_request' do
     before :each do
       @request = Puppet::Indirector::Request.new(:myind, :find, "my key", nil)
     end
 
     context 'when not using SRV records' do
       before :each do
         Puppet.settings[:use_srv_records] = false
       end
 
       it "yields the request with the default server and port when no server or port were specified on the original request" do
         count = 0
         rval = @request.do_request(:puppet, 'puppet.example.com', '90210') do |got|
           count += 1
           got.server.should == 'puppet.example.com'
           got.port.should   == '90210'
           'Block return value'
         end
         count.should == 1
 
         rval.should == 'Block return value'
       end
     end
 
     context 'when using SRV records' do
       before :each do
         Puppet.settings[:use_srv_records] = true
         Puppet.settings[:srv_domain]      = 'example.com'
       end
 
       it "yields the request with the original server and port unmodified" do
         @request.server = 'puppet.example.com'
         @request.port   = '90210'
 
         count = 0
         rval = @request.do_request do |got|
           count += 1
           got.server.should == 'puppet.example.com'
           got.port.should   == '90210'
           'Block return value'
         end
         count.should == 1
 
         rval.should == 'Block return value'
       end
 
       context "when SRV returns servers" do
         before :each do
           @dns_mock = mock('dns')
           Resolv::DNS.expects(:new).returns(@dns_mock)
 
           @port = 7205
           @host = '_x-puppet._tcp.example.com'
           @srv_records = [Resolv::DNS::Resource::IN::SRV.new(0, 0, @port, @host)]
 
           @dns_mock.expects(:getresources).
             with("_x-puppet._tcp.#{Puppet.settings[:srv_domain]}", Resolv::DNS::Resource::IN::SRV).
             returns(@srv_records)
         end
 
         it "yields a request using the server and port from the SRV record" do
           count = 0
           rval = @request.do_request do |got|
             count += 1
             got.server.should == '_x-puppet._tcp.example.com'
             got.port.should == 7205
 
             @block_return
           end
           count.should == 1
 
           rval.should == @block_return
         end
 
         it "should fall back to the default server when the block raises a SystemCallError" do
           count = 0
           second_pass = nil
 
           rval = @request.do_request(:puppet, 'puppet', 8140) do |got|
             count += 1
 
             if got.server == '_x-puppet._tcp.example.com' then
               raise SystemCallError, "example failure"
             else
               second_pass = got
             end
 
             @block_return
           end
 
           second_pass.server.should == 'puppet'
           second_pass.port.should   == 8140
           count.should == 2
 
           rval.should == @block_return
         end
       end
     end
   end
 
   describe "#remote?" do
     def request(options = {})
       Puppet::Indirector::Request.new('node', 'find', 'localhost', nil, options)
     end
 
     it "should not be unless node or ip is set" do
       request.should_not be_remote
     end
 
     it "should be remote if node is set" do
       request(:node => 'example.com').should be_remote
     end
 
     it "should be remote if ip is set" do
       request(:ip => '127.0.0.1').should be_remote
     end
 
     it "should be remote if node and ip are set" do
       request(:node => 'example.com', :ip => '127.0.0.1').should be_remote
     end
   end
 end
diff --git a/spec/unit/relationship_spec.rb b/spec/unit/relationship_spec.rb
index 66cd38183..ce7206cfb 100755
--- a/spec/unit/relationship_spec.rb
+++ b/spec/unit/relationship_spec.rb
@@ -1,228 +1,224 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/relationship'
 
 describe Puppet::Relationship do
   before do
     @edge = Puppet::Relationship.new(:a, :b)
   end
 
   it "should have a :source attribute" do
     @edge.should respond_to(:source)
   end
 
   it "should have a :target attribute" do
     @edge.should respond_to(:target)
   end
 
   it "should have a :callback attribute" do
     @edge.callback = :foo
     @edge.callback.should == :foo
   end
 
   it "should have an :event attribute" do
     @edge.event = :NONE
     @edge.event.should == :NONE
   end
 
   it "should require a callback if a non-NONE event is specified" do
     proc { @edge.event = :something }.should raise_error(ArgumentError)
   end
 
   it "should have a :label attribute" do
     @edge.should respond_to(:label)
   end
 
   it "should provide a :ref method that describes the edge" do
     @edge = Puppet::Relationship.new("a", "b")
     @edge.ref.should == "a => b"
   end
 
   it "should be able to produce a label as a hash with its event and callback" do
     @edge.callback = :foo
     @edge.event = :bar
 
     @edge.label.should == {:callback => :foo, :event => :bar}
   end
 
   it "should work if nil options are provided" do
     lambda { Puppet::Relationship.new("a", "b", nil) }.should_not raise_error
   end
 end
 
 describe Puppet::Relationship, " when initializing" do
   before do
     @edge = Puppet::Relationship.new(:a, :b)
   end
 
   it "should use the first argument as the source" do
     @edge.source.should == :a
   end
 
   it "should use the second argument as the target" do
     @edge.target.should == :b
   end
 
   it "should set the rest of the arguments as the event and callback" do
     @edge = Puppet::Relationship.new(:a, :b, :callback => :foo, :event => :bar)
     @edge.callback.should == :foo
     @edge.event.should == :bar
   end
 
   it "should accept events specified as strings" do
     @edge = Puppet::Relationship.new(:a, :b, "event" => :NONE)
     @edge.event.should == :NONE
   end
 
   it "should accept callbacks specified as strings" do
     @edge = Puppet::Relationship.new(:a, :b, "callback" => :foo)
     @edge.callback.should == :foo
   end
 end
 
 describe Puppet::Relationship, " when matching edges with no specified event" do
   before do
     @edge = Puppet::Relationship.new(:a, :b)
   end
 
   it "should not match :NONE" do
     @edge.should_not be_match(:NONE)
   end
 
   it "should not match :ALL_EVENTS" do
     @edge.should_not be_match(:NONE)
   end
 
   it "should not match any other events" do
     @edge.should_not be_match(:whatever)
   end
 end
 
 describe Puppet::Relationship, " when matching edges with :NONE as the event" do
   before do
     @edge = Puppet::Relationship.new(:a, :b, :event => :NONE)
   end
   it "should not match :NONE" do
     @edge.should_not be_match(:NONE)
   end
 
   it "should not match :ALL_EVENTS" do
     @edge.should_not be_match(:ALL_EVENTS)
   end
 
   it "should not match other events" do
     @edge.should_not be_match(:yayness)
   end
 end
 
 describe Puppet::Relationship, " when matching edges with :ALL as the event" do
   before do
     @edge = Puppet::Relationship.new(:a, :b, :event => :ALL_EVENTS, :callback => :whatever)
   end
 
   it "should not match :NONE" do
     @edge.should_not be_match(:NONE)
   end
 
   it "should match :ALL_EVENTS" do
     @edge.should be_match(:ALLEVENTS)
   end
 
   it "should match all other events" do
     @edge.should be_match(:foo)
   end
 end
 
 describe Puppet::Relationship, " when matching edges with a non-standard event" do
   before do
     @edge = Puppet::Relationship.new(:a, :b, :event => :random, :callback => :whatever)
   end
 
   it "should not match :NONE" do
     @edge.should_not be_match(:NONE)
   end
 
   it "should not match :ALL_EVENTS" do
     @edge.should_not be_match(:ALL_EVENTS)
   end
 
   it "should match events with the same name" do
     @edge.should be_match(:random)
   end
 end
 
 describe Puppet::Relationship, "when converting to pson" do
   before do
     @edge = Puppet::Relationship.new(:a, :b, :event => :random, :callback => :whatever)
   end
 
   it "should store the stringified source as the source in the data" do
     PSON.parse(@edge.to_pson)["source"].should == "a"
   end
 
   it "should store the stringified target as the target in the data" do
     PSON.parse(@edge.to_pson)['target'].should == "b"
   end
 
   it "should store the psonified event as the event in the data" do
     PSON.parse(@edge.to_pson)["event"].should == "random"
   end
 
   it "should not store an event when none is set" do
     @edge.event = nil
     PSON.parse(@edge.to_pson)["event"].should be_nil
   end
 
   it "should store the psonified callback as the callback in the data" do
     @edge.callback = "whatever"
     PSON.parse(@edge.to_pson)["callback"].should == "whatever"
   end
 
   it "should not store a callback when none is set in the edge" do
     @edge.callback = nil
     PSON.parse(@edge.to_pson)["callback"].should be_nil
   end
 end
 
 describe Puppet::Relationship, "when converting from pson" do
   before do
     @event = "random"
     @callback = "whatever"
     @data = {
       "source" => "mysource",
       "target" => "mytarget",
       "event" => @event,
       "callback" => @callback
     }
     @pson = {
       "type" => "Puppet::Relationship",
       "data" => @data
     }
   end
 
   def pson_result_should
     Puppet::Relationship.expects(:new).with { |*args| yield args }
   end
 
-  it "should be extended with the PSON utility module" do
-    Puppet::Relationship.singleton_class.ancestors.should be_include(Puppet::Util::Pson)
-  end
-
   # LAK:NOTE For all of these tests, we convert back to the edge so we can
   # trap the actual data structure then.
   it "should pass the source in as the first argument" do
     Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget").source.should == "mysource"
   end
 
   it "should pass the target in as the second argument" do
     Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget").target.should == "mytarget"
   end
 
   it "should pass the event as an argument if it's provided" do
     Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget", "event" => "myevent", "callback" => "eh").event.should == "myevent"
   end
 
   it "should pass the callback as an argument if it's provided" do
     Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget", "callback" => "mycallback").callback.should == "mycallback"
   end
 end
diff --git a/spec/unit/resource_spec.rb b/spec/unit/resource_spec.rb
index e60b29cb2..330023463 100755
--- a/spec/unit/resource_spec.rb
+++ b/spec/unit/resource_spec.rb
@@ -1,1005 +1,997 @@
 #! /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