diff --git a/lib/puppet/parameter.rb b/lib/puppet/parameter.rb
index e3e9e5164..de5bad699 100644
--- a/lib/puppet/parameter.rb
+++ b/lib/puppet/parameter.rb
@@ -1,298 +1,307 @@
 require 'puppet/util/methodhelper'
 require 'puppet/util/log_paths'
 require 'puppet/util/logging'
 require 'puppet/util/docs'
 
 class Puppet::Parameter
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Util::LogPaths
   include Puppet::Util::Logging
   include Puppet::Util::MethodHelper
 
   require 'puppet/parameter/value_collection'
 
   class << self
     include Puppet::Util
     include Puppet::Util::Docs
     attr_reader :validater, :munger, :name, :default, :required_features, :value_collection
     attr_accessor :metaparam
 
     # Define the default value for a given parameter or parameter.  This
     # means that 'nil' is an invalid default value.  This defines
     # the 'default' instance method.
     def defaultto(value = nil, &block)
       if block
         define_method(:default, &block)
       else
         if value.nil?
           raise Puppet::DevError,
             "Either a default value or block must be provided"
         end
         define_method(:default) do value end
       end
     end
 
     # Return a documentation string.  If there are valid values,
     # then tack them onto the string.
     def doc
       @doc ||= ""
 
       unless defined?(@addeddocvals)
         @doc += value_collection.doc
 
         if f = self.required_features
           @doc += "  Requires features #{f.flatten.collect { |f| f.to_s }.join(" ")}."
         end
         @addeddocvals = true
       end
 
       @doc
     end
 
     def nodefault
       undef_method :default if public_method_defined? :default
     end
 
     # Store documentation for this parameter.
     def desc(str)
       @doc = str
     end
 
     def initvars
       @value_collection = ValueCollection.new
     end
 
     # This is how we munge the value.  Basically, this is our
     # opportunity to convert the value from one form into another.
     def munge(&block)
       # I need to wrap the unsafe version in begin/rescue parameterments,
       # but if I directly call the block then it gets bound to the
       # class's context, not the instance's, thus the two methods,
       # instead of just one.
       define_method(:unsafe_munge, &block)
     end
 
     # Does the parameter support reverse munging?
     # This will be called when something wants to access the parameter
     # in a canonical form different to what the storage form is.
     def unmunge(&block)
       define_method(:unmunge, &block)
     end
 
     # Mark whether we're the namevar.
     def isnamevar
       @isnamevar = true
       @required = true
     end
 
     # Is this parameter the namevar?  Defaults to false.
     def isnamevar?
       @isnamevar
     end
 
     # This parameter is required.
     def isrequired
       @required = true
     end
 
     # Specify features that are required for this parameter to work.
     def required_features=(*args)
       @required_features = args.flatten.collect { |a| a.to_s.downcase.intern }
     end
 
     # Is this parameter required?  Defaults to false.
     def required?
       @required
     end
 
     # Verify that we got a good value
     def validate(&block)
       define_method(:unsafe_validate, &block)
     end
 
     # Define a new value for our parameter.
     def newvalues(*names)
       @value_collection.newvalues(*names)
     end
 
     def aliasvalue(name, other)
       @value_collection.aliasvalue(name, other)
     end
   end
 
   # Just a simple method to proxy instance methods to class methods
   def self.proxymethods(*values)
     values.each { |val|
       define_method(val) do
         self.class.send(val)
       end
     }
   end
 
   # And then define one of these proxies for each method in our
   # ParamHandler class.
   proxymethods("required?", "isnamevar?")
 
   attr_accessor :resource
   # LAK 2007-05-09: Keep the @parent around for backward compatibility.
   attr_accessor :parent
 
   [:line, :file, :version].each do |param|
     define_method(param) do
       resource.send(param)
     end
   end
 
   def devfail(msg)
     self.fail(Puppet::DevError, msg)
   end
 
   def fail(*args)
     type = nil
     if args[0].is_a?(Class)
       type = args.shift
     else
       type = Puppet::Error
     end
 
     error = type.new(args.join(" "))
 
     error.line = @resource.line if @resource and @resource.line
 
     error.file = @resource.file if @resource and @resource.file
 
     raise error
   end
 
   # Basic parameter initialization.
   def initialize(options = {})
     options = symbolize_options(options)
     if resource = options[:resource]
       self.resource = resource
       options.delete(:resource)
     else
       raise Puppet::DevError, "No resource set for #{self.class.name}"
     end
 
     set_options(options)
   end
 
   def log(msg)
     send_log(resource[:loglevel], msg)
   end
 
   # Is this parameter a metaparam?
   def metaparam?
     self.class.metaparam
   end
 
   # each parameter class must define the name method, and parameter
   # instances do not change that name this implicitly means that a given
   # object can only have one parameter instance of a given parameter
   # class
   def name
     self.class.name
   end
 
   # for testing whether we should actually do anything
   def noop
     @noop ||= false
     tmp = @noop || self.resource.noop || Puppet[:noop] || false
     #debug "noop is #{tmp}"
     tmp
   end
 
   # return the full path to us, for logging and rollback; not currently
   # used
   def pathbuilder
     if @resource
       return [@resource.pathbuilder, self.name]
     else
       return [self.name]
     end
   end
 
   # If the specified value is allowed, then munge appropriately.
   # If the developer uses a 'munge' hook, this method will get overridden.
   def unsafe_munge(value)
     self.class.value_collection.munge(value)
   end
 
   # no unmunge by default
   def unmunge(value)
     value
   end
 
   # A wrapper around our munging that makes sure we raise useful exceptions.
   def munge(value)
     begin
       ret = unsafe_munge(value)
     rescue Puppet::Error => detail
       Puppet.debug "Reraising #{detail}"
       raise
     rescue => detail
       raise Puppet::DevError, "Munging failed for value #{value.inspect} in class #{self.name}: #{detail}", detail.backtrace
     end
     ret
   end
 
   # Verify that the passed value is valid.
   # If the developer uses a 'validate' hook, this method will get overridden.
   def unsafe_validate(value)
     self.class.value_collection.validate(value)
   end
 
   # A protected validation method that only ever raises useful exceptions.
   def validate(value)
     begin
       unsafe_validate(value)
     rescue ArgumentError => detail
       fail detail.to_s
     rescue Puppet::Error, TypeError
       raise
     rescue => detail
       raise Puppet::DevError, "Validate method failed for class #{self.name}: #{detail}", detail.backtrace
     end
   end
 
   def remove
     @resource = nil
   end
 
   def value
     unmunge(@value) unless @value.nil?
   end
 
   # Store the value provided.  All of the checking should possibly be
   # late-binding (e.g., users might not exist when the value is assigned
   # but might when it is asked for).
   def value=(value)
     validate(value)
 
     @value = munge(value)
   end
 
   # Retrieve the resource's provider.  Some types don't have providers, in which
   # case we return the resource object itself.
   def provider
     @resource.provider
   end
 
   # The properties need to return tags so that logs correctly collect them.
   def tags
     unless defined?(@tags)
       @tags = []
       # This might not be true in testing
       @tags = @resource.tags if @resource.respond_to? :tags
       @tags << self.name.to_s
     end
     @tags
   end
 
   def to_s
     name.to_s
   end
+
+  def self.format_value_for_display(value)
+    if value.is_a? Array
+      formatted_values = value.collect {|value| format_value_for_display(value)}.join(', ')
+      "[#{formatted_values}]"
+    else
+      "'#{value}'"
+    end
+  end
 end
 
 require 'puppet/parameter/path'
diff --git a/lib/puppet/property.rb b/lib/puppet/property.rb
index 12f496a6e..ee8f3b4c1 100644
--- a/lib/puppet/property.rb
+++ b/lib/puppet/property.rb
@@ -1,339 +1,339 @@
 # The virtual base class for properties, which are the self-contained building
 # blocks for actually doing work on the system.
 
 require 'puppet'
 require 'puppet/parameter'
 
 class Puppet::Property < Puppet::Parameter
   require 'puppet/property/ensure'
 
   # Because 'should' uses an array, we have a special method for handling
   # it.  We also want to keep copies of the original values, so that
   # they can be retrieved and compared later when merging.
   attr_reader :shouldorig
 
   attr_writer :noop
 
   class << self
     attr_accessor :unmanaged
     attr_reader :name
 
     # Return array matching info, defaulting to just matching
     # the first value.
     def array_matching
       @array_matching ||= :first
     end
 
     # Set whether properties should match all values or just the first one.
     def array_matching=(value)
       value = value.intern if value.is_a?(String)
       raise ArgumentError, "Supported values for Property#array_matching are 'first' and 'all'" unless [:first, :all].include?(value)
       @array_matching = value
     end
   end
 
   # Look up a value's name, so we can find options and such.
   def self.value_name(name)
     if value = value_collection.match?(name)
       value.name
     end
   end
 
   # Retrieve an option set when a value was defined.
   def self.value_option(name, option)
     if value = value_collection.value(name)
       value.send(option)
     end
   end
 
   # Define a new valid value for a property.  You must provide the value itself,
   # usually as a symbol, or a regex to match the value.
   #
   # The first argument to the method is either the value itself or a regex.
   # The second argument is an option hash; valid options are:
   # * <tt>:method</tt>: The name of the method to define.  Defaults to 'set_<value>'.
   # * <tt>:required_features</tt>: A list of features this value requires.
   # * <tt>:event</tt>: The event that should be returned when this value is set.
   # * <tt>:call</tt>: When to call any associated block.  The default value
   #   is `instead`, which means to call the value instead of calling the
   #   provider.  You can also specify `before` or `after`, which will
   #   call both the block and the provider, according to the order you specify
   #   (the `first` refers to when the block is called, not the provider).
   def self.newvalue(name, options = {}, &block)
     value = value_collection.newvalue(name, options, &block)
 
     define_method(value.method, &value.block) if value.method and value.block
     value
   end
 
   # Call the provider method.
   def call_provider(value)
       provider.send(self.class.name.to_s + "=", value)
   rescue NoMethodError
       self.fail "The #{provider.class.name} provider can not handle attribute #{self.class.name}"
   end
 
   # Call the dynamically-created method associated with our value, if
   # there is one.
   def call_valuemethod(name, value)
     if method = self.class.value_option(name, :method) and self.respond_to?(method)
       begin
         event = self.send(method)
       rescue Puppet::Error
         raise
       rescue => detail
         puts detail.backtrace if Puppet[:trace]
         error = Puppet::Error.new("Could not set '#{value} on #{self.class.name}: #{detail}", @resource.line, @resource.file)
         error.set_backtrace detail.backtrace
         raise error
       end
     elsif block = self.class.value_option(name, :block)
       # FIXME It'd be better here to define a method, so that
       # the blocks could return values.
       self.instance_eval(&block)
     else
       devfail "Could not find method for value '#{name}'"
     end
   end
 
   # How should a property change be printed as a string?
   def change_to_s(current_value, newvalue)
     begin
       if current_value == :absent
-        return "defined '#{name}' as '#{should_to_s(newvalue)}'"
+        return "defined '#{name}' as #{self.class.format_value_for_display should_to_s(newvalue)}"
       elsif newvalue == :absent or newvalue == [:absent]
-        return "undefined '#{name}' from '#{is_to_s(current_value)}'"
+        return "undefined '#{name}' from #{self.class.format_value_for_display is_to_s(current_value)}"
       else
-        return "#{name} changed '#{is_to_s(current_value)}' to '#{should_to_s(newvalue)}'"
+        return "#{name} changed #{self.class.format_value_for_display is_to_s(current_value)} to #{self.class.format_value_for_display should_to_s(newvalue)}"
       end
     rescue Puppet::Error, Puppet::DevError
       raise
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       raise Puppet::DevError, "Could not convert change '#{name}' to string: #{detail}"
     end
   end
 
   # Figure out which event to return.
   def event_name
     value = self.should
 
     event_name = self.class.value_option(value, :event) and return event_name
 
     name == :ensure or return (name.to_s + "_changed").to_sym
 
     return (resource.type.to_s + case value
     when :present; "_created"
     when :absent; "_removed"
     else
       "_changed"
     end).to_sym
   end
 
   # Return a modified form of the resource event.
   def event
     resource.event :name => event_name, :desired_value => should, :property => self, :source_description => path
   end
 
   attr_reader :shadow
 
   # initialize our property
   def initialize(hash = {})
     super
 
     if ! self.metaparam? and klass = Puppet::Type.metaparamclass(self.class.name)
       setup_shadow(klass)
     end
   end
 
   # Determine whether the property is in-sync or not.  If @should is
   # not defined or is set to a non-true value, then we do not have
   # a valid value for it and thus consider the property to be in-sync
   # since we cannot fix it.  Otherwise, we expect our should value
   # to be an array, and if @is matches any of those values, then
   # we consider it to be in-sync.
   #
   # Don't override this method.
   def safe_insync?(is)
     # If there is no @should value, consider the property to be in sync.
     return true unless @should
 
     # Otherwise delegate to the (possibly derived) insync? method.
     insync?(is)
   end
 
   def self.method_added(sym)
     raise "Puppet::Property#safe_insync? shouldn't be overridden; please override insync? instead" if sym == :safe_insync?
   end
 
   # This method should be overridden by derived classes if necessary
   # to provide extra logic to determine whether the property is in
   # sync.
   def insync?(is)
     self.devfail "#{self.class.name}'s should is not array" unless @should.is_a?(Array)
 
     # an empty array is analogous to no should values
     return true if @should.empty?
 
     # Look for a matching value
     return (is == @should or is == @should.collect { |v| v.to_s }) if match_all?
 
     @should.each { |val| return true if is == val or is == val.to_s }
 
     # otherwise, return false
     false
   end
 
   # because the @should and @is vars might be in weird formats,
   # we need to set up a mechanism for pretty printing of the values
   # default to just the values, but this way individual properties can
   # override these methods
   def is_to_s(currentvalue)
     currentvalue
   end
 
   # Send a log message.
   def log(msg)
 
           Puppet::Util::Log.create(
 
       :level => resource[:loglevel],
       :message => msg,
 
       :source => self
     )
   end
 
   # Should we match all values, or just the first?
   def match_all?
     self.class.array_matching == :all
   end
 
   # Execute our shadow's munge code, too, if we have one.
   def munge(value)
     self.shadow.munge(value) if self.shadow
 
     super
   end
 
   # each property class must define the name method, and property instances
   # do not change that name
   # this implicitly means that a given object can only have one property
   # instance of a given property class
   def name
     self.class.name
   end
 
   # for testing whether we should actually do anything
   def noop
     # This is only here to make testing easier.
     if @resource.respond_to?(:noop?)
       @resource.noop?
     else
       if defined?(@noop)
         @noop
       else
         Puppet[:noop]
       end
     end
   end
 
   # By default, call the method associated with the property name on our
   # provider.  In other words, if the property name is 'gid', we'll call
   # 'provider.gid' to retrieve the current value.
   def retrieve
     provider.send(self.class.name)
   end
 
   # Set our value, using the provider, an associated block, or both.
   def set(value)
     # Set a name for looking up associated options like the event.
     name = self.class.value_name(value)
 
     call = self.class.value_option(name, :call) || :none
 
     if call == :instead
       call_valuemethod(name, value)
     elsif call == :none
       # They haven't provided a block, and our parent does not have
       # a provider, so we have no idea how to handle this.
       self.fail "#{self.class.name} cannot handle values of type #{value.inspect}" unless @resource.provider
       call_provider(value)
     else
       # LAK:NOTE 20081031 This is a change in behaviour -- you could
       # previously specify :call => [;before|:after], which would call
       # the setter *in addition to* the block.  I'm convinced this
       # was never used, and it makes things unecessarily complicated.
       # If you want to specify a block and still call the setter, then
       # do so in the block.
       devfail "Cannot use obsolete :call value '#{call}' for property '#{self.class.name}'"
     end
   end
 
   # If there's a shadowing metaparam, instantiate it now.
   # This allows us to create a property or parameter with the
   # same name as a metaparameter, and the metaparam will only be
   # stored as a shadow.
   def setup_shadow(klass)
     @shadow = klass.new(:resource => self.resource)
   end
 
   # Only return the first value
   def should
     return nil unless defined?(@should)
 
     self.devfail "should for #{self.class.name} on #{resource.name} is not an array" unless @should.is_a?(Array)
 
     if match_all?
       return @should.collect { |val| self.unmunge(val) }
     else
       return self.unmunge(@should[0])
     end
   end
 
   # Set the should value.
   def should=(values)
     values = [values] unless values.is_a?(Array)
 
     @shouldorig = values
 
     values.each { |val| validate(val) }
     @should = values.collect { |val| self.munge(val) }
   end
 
   def should_to_s(newvalue)
     [newvalue].flatten.join(" ")
   end
 
   def sync
     devfail "Got a nil value for should" unless should
     set(should)
   end
 
   # Verify that the passed value is valid.
   # If the developer uses a 'validate' hook, this method will get overridden.
   def unsafe_validate(value)
     super
     validate_features_per_value(value)
   end
 
   # Make sure that we've got all of the required features for a given value.
   def validate_features_per_value(value)
     if features = self.class.value_option(self.class.value_name(value), :required_features)
       features = Array(features)
       needed_features = features.collect { |f| f.to_s }.join(", ")
       raise ArgumentError, "Provider must have features '#{needed_features}' to set '#{self.class.name}' to '#{value}'" unless provider.satisfies?(features)
     end
   end
 
   # Just return any should value we might have.
   def value
     self.should
   end
 
   # Match the Parameter interface, but we really just use 'should' internally.
   # Note that the should= method does all of the validation and such.
   def value=(value)
     self.should = value
   end
 end
diff --git a/lib/puppet/resource.rb b/lib/puppet/resource.rb
index 59e387d00..a2994c9f5 100644
--- a/lib/puppet/resource.rb
+++ b/lib/puppet/resource.rb
@@ -1,439 +1,436 @@
 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.
 class Puppet::Resource
   # This stub class is only needed for serialization compatibility with 0.25.x.
   # Specifically, it exists to provide a compatibility API when using YAML
   # serialized objects loaded from StoreConfigs.
   Reference = Puppet::Resource
 
   include Puppet::Util::Tagging
 
   require 'puppet/resource/type_collection_helper'
   include Puppet::Resource::TypeCollectionHelper
 
   extend Puppet::Util::Pson
   include Enumerable
   attr_accessor :file, :line, :catalog, :exported, :virtual, :validate_parameters, :strict
   attr_reader :type, :title
 
   require 'puppet/indirector'
   extend Puppet::Indirector
   indirects :resource, :terminus_class => :ral
 
   ATTRIBUTES = [:file, :line, :exported]
 
   def self.from_pson(pson)
     raise ArgumentError, "No resource type provided in pson data" unless type = pson['type']
     raise ArgumentError, "No resource title provided in pson data" unless title = pson['title']
 
     resource = new(type, title)
 
     if params = pson['parameters']
       params.each { |param, value| resource[param] = value }
     end
 
     if tags = pson['tags']
       tags.each { |tag| resource.tag(tag) }
     end
 
     ATTRIBUTES.each do |a|
       if value = pson[a.to_s]
         resource.send(a.to_s + "=", value)
       end
     end
 
     resource.exported ||= false
 
     resource
   end
 
   def inspect
     "#{@type}[#{@title}]#{to_hash.inspect}"
   end
 
   def to_pson_data_hash
     data = ([:type, :title, :tags] + ATTRIBUTES).inject({}) do |hash, param|
       next hash unless value = self.send(param)
       hash[param.to_s] = value
       hash
     end
 
     data["exported"] ||= false
 
     params = self.to_hash.inject({}) do |hash, ary|
       param, value = ary
 
       # Don't duplicate the title as the namevar
       next hash if param == namevar and value == title
 
       hash[param] = Puppet::Resource.value_to_pson_data(value)
       hash
     end
 
     data["parameters"] = params unless params.empty?
 
     data
   end
 
   def self.value_to_pson_data(value)
     if value.is_a? Array
       value.map{|v| value_to_pson_data(v) }
     elsif value.is_a? Puppet::Resource
       value.to_s
     else
       value
     end
   end
 
   def yaml_property_munge(x)
     case x
     when Hash
       x.inject({}) { |h,kv|
         k,v = kv
         h[k] = self.class.value_to_pson_data(v)
         h
       }
     else self.class.value_to_pson_data(x)
     end
   end
 
   def to_pson(*args)
     to_pson_data_hash.to_pson(*args)
   end
 
   # Proxy these methods to the parameters hash.  It's likely they'll
   # be overridden at some point, but this works for now.
   %w{has_key? keys length delete empty? <<}.each do |method|
     define_method(method) do |*args|
       parameters.send(method, *args)
     end
   end
 
   # Set a given parameter.  Converts all passed names
   # to lower-case symbols.
   def []=(param, value)
     validate_parameter(param) if validate_parameters
     parameters[parameter_name(param)] = value
   end
 
   # Return a given parameter's value.  Converts all passed names
   # to lower-case symbols.
   def [](param)
     parameters[parameter_name(param)]
   end
 
   def ==(other)
     return false unless other.respond_to?(:title) and self.type == other.type and self.title == other.title
 
     return false unless to_hash == other.to_hash
     true
   end
 
   # Compatibility method.
   def builtin?
     builtin_type?
   end
 
   # Is this a builtin resource type?
   def builtin_type?
     resource_type.is_a?(Class)
   end
 
   # Iterate over each param/value pair, as required for Enumerable.
   def each
     parameters.each { |p,v| yield p, v }
   end
 
   def include?(parameter)
     super || parameters.keys.include?( parameter_name(parameter) )
   end
 
   # These two methods are extracted into a Helper
   # module, but file load order prevents me
   # from including them in the class, and I had weird
   # behaviour (i.e., sometimes it didn't work) when
   # I directly extended each resource with the helper.
   def environment
     Puppet::Node::Environment.new(@environment)
   end
 
   def environment=(env)
     if env.is_a?(String) or env.is_a?(Symbol)
       @environment = env
     else
       @environment = env.name
     end
   end
 
   %w{exported virtual strict}.each do |m|
     define_method(m+"?") do
       self.send(m)
     end
   end
 
   # Create our resource.
   def initialize(type, title = nil, attributes = {})
     @parameters = {}
 
     # Set things like strictness first.
     attributes.each do |attr, value|
       next if attr == :parameters
       send(attr.to_s + "=", value)
     end
 
     @type, @title = extract_type_and_title(type, title)
 
     @type = munge_type_name(@type)
 
     if @type == "Class"
       @title = :main if @title == ""
       @title = munge_type_name(@title)
     end
 
     if params = attributes[:parameters]
       extract_parameters(params)
     end
 
     tag(self.type)
     tag(self.title) if valid_tag?(self.title)
 
     @reference = self # for serialization compatibility with 0.25.x
     if strict? and ! resource_type
       if @type == 'Class'
         raise ArgumentError, "Could not find declared class #{title}"
       else
         raise ArgumentError, "Invalid resource type #{type}"
       end
     end
   end
 
   def ref
     to_s
   end
 
   # Find our resource.
   def resolve
     return(catalog ? catalog.resource(to_s) : nil)
   end
 
   def resource_type
     case type
     when "Class"; known_resource_types.hostclass(title == :main ? "" : title)
     when "Node"; known_resource_types.node(title)
     else
       Puppet::Type.type(type.to_s.downcase.to_sym) || known_resource_types.definition(type)
     end
   end
 
   # Produce a simple hash of our parameters.
   def to_hash
     parse_title.merge parameters
   end
 
   def to_s
     "#{type}[#{title}]"
   end
 
   def uniqueness_key
     # Temporary kludge to deal with inconsistant use patters
     h = self.to_hash
     h[namevar] ||= h[:name]
     h[:name]   ||= h[namevar]
     h.values_at(*key_attributes.sort_by { |k| k.to_s })
   end
 
   def key_attributes
     return(resource_type.respond_to? :key_attributes) ? resource_type.key_attributes : [:name]
   end
 
   # Convert our resource to Puppet code.
   def to_manifest
     # Collect list of attributes to align => and move ensure first
     attr = parameters.keys
     attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max }
 
     attr.sort!
     if attr.first != :ensure  && attr.include?(:ensure)
       attr.delete(:ensure)
       attr.unshift(:ensure)
     end
 
     attributes = attr.collect { |k|
       v = parameters[k]
-      if v.is_a? Array
-        "  %-#{attr_max}s => %s,\n" % [ k, "[\'#{v.join("', '")}\']" ]
-      else
-        "  %-#{attr_max}s => %s,\n" % [ k, "\'#{v}\'" ]
-      end
+      "  %-#{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
     if typeklass = Puppet::Type.type(self.type)
       return typeklass.new(self)
     else
       return Puppet::Type::Component.new(self)
     end
   end
 
   # Translate our object to a backward-compatible transportable object.
   def to_trans
     if builtin_type? and type.downcase.to_s != "stage"
       result = to_transobject
     else
       result = to_transbucket
     end
 
     result.file = self.file
     result.line = self.line
 
     result
   end
 
   def to_trans_ref
     [type.to_s, title.to_s]
   end
 
   # Create an old-style TransObject instance, for builtin resource types.
   def to_transobject
     # Now convert to a transobject
     result = Puppet::TransObject.new(title, type)
     to_hash.each do |p, v|
       if v.is_a?(Puppet::Resource)
         v = v.to_trans_ref
       elsif v.is_a?(Array)
         v = v.collect { |av|
           av = av.to_trans_ref if av.is_a?(Puppet::Resource)
           av
         }
       end
 
       # If the value is an array with only one value, then
       # convert it to a single value.  This is largely so that
       # the database interaction doesn't have to worry about
       # whether it returns an array or a string.
       result[p.to_s] = if v.is_a?(Array) and v.length == 1
         v[0]
           else
             v
               end
     end
 
     result.tags = self.tags
 
     result
   end
 
   def name
     # this is potential namespace conflict
     # between the notion of an "indirector name"
     # and a "resource name"
     [ type, title ].join('/')
   end
 
   def to_resource
     self
   end
 
   def valid_parameter?(name)
     resource_type.valid_parameter?(name)
   end
 
   def validate_parameter(name)
     raise ArgumentError, "Invalid parameter #{name}" unless valid_parameter?(name)
   end
 
   private
 
   # Produce a canonical method name.
   def parameter_name(param)
     param = param.to_s.downcase.to_sym
     if param == :name and n = namevar
       param = namevar
     end
     param
   end
 
   # The namevar for our resource type. If the type doesn't exist,
   # always use :name.
   def namevar
     if builtin_type? and t = resource_type and t.key_attributes.length == 1
       t.key_attributes.first
     else
       :name
     end
   end
 
   # Create an old-style TransBucket instance, for non-builtin resource types.
   def to_transbucket
     bucket = Puppet::TransBucket.new([])
 
     bucket.type = self.type
     bucket.name = self.title
 
     # TransBuckets don't support parameters, which is why they're being deprecated.
     bucket
   end
 
   def extract_parameters(params)
     params.each do |param, value|
       validate_parameter(param) if strict?
       self[param] = value
     end
   end
 
   def extract_type_and_title(argtype, argtitle)
     if    (argtitle || argtype) =~ /^([^\[\]]+)\[(.+)\]$/m then [ $1,                 $2            ]
     elsif argtitle                                         then [ argtype,            argtitle      ]
     elsif argtype.is_a?(Puppet::Type)                      then [ argtype.class.name, argtype.title ]
     elsif argtype.is_a?(Hash)                              then
       raise ArgumentError, "Puppet::Resource.new does not take a hash as the first argument. "+
         "Did you mean (#{(argtype[:type] || argtype["type"]).inspect}, #{(argtype[:title] || argtype["title"]).inspect }) ?"
     else raise ArgumentError, "No title provided and #{argtype.inspect} is not a valid resource reference"
     end
   end
 
   def munge_type_name(value)
     return :main if value == :main
     return "Class" if value == "" or value.nil? or value.to_s.downcase == "component"
 
     value.to_s.split("::").collect { |s| s.capitalize }.join("::")
   end
 
   def parse_title
     h = {}
     type = resource_type
     if type.respond_to? :title_patterns
       type.title_patterns.each { |regexp, symbols_and_lambdas|
         if captures = regexp.match(title.to_s)
           symbols_and_lambdas.zip(captures[1..-1]).each { |symbol_and_lambda,capture|
             sym, lam = symbol_and_lambda
             #self[sym] = lam.call(capture)
             h[sym] = lam.call(capture)
           }
           return h
         end
       }
     else
       return { :name => title.to_s }
     end
   end
 
   def parameters
     # @parameters could have been loaded from YAML, causing it to be nil (by
     # bypassing initialize).
     @parameters ||= {}
   end
 end
diff --git a/spec/unit/parameter_spec.rb b/spec/unit/parameter_spec.rb
index 1ed211957..0504de35d 100755
--- a/spec/unit/parameter_spec.rb
+++ b/spec/unit/parameter_spec.rb
@@ -1,160 +1,184 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/parameter'
 
 describe Puppet::Parameter do
   before do
     @class = Class.new(Puppet::Parameter) do
       @name = :foo
     end
     @class.initvars
     @resource = mock 'resource'
     @resource.stub_everything
     @parameter = @class.new :resource => @resource
   end
 
   it "should create a value collection" do
     @class = Class.new(Puppet::Parameter)
     @class.value_collection.should be_nil
     @class.initvars
     @class.value_collection.should be_instance_of(Puppet::Parameter::ValueCollection)
   end
 
   it "should return its name as a string when converted to a string" do
     @parameter.to_s.should == @parameter.name.to_s
   end
 
   [:line, :file, :version].each do |data|
     it "should return its resource's #{data} as its #{data}" do
       @resource.expects(data).returns "foo"
       @parameter.send(data).should == "foo"
     end
   end
 
   it "should return the resource's tags plus its name as its tags" do
     @resource.expects(:tags).returns %w{one two}
     @parameter.tags.should == %w{one two foo}
   end
 
   it "should provide source_descriptors" do
     @resource.expects(:line).returns 10
     @resource.expects(:file).returns "file"
     @resource.expects(:tags).returns %w{one two}
     @parameter.source_descriptors.should == {:tags=>["one", "two", "foo"], :path=>"//foo", :file => "file", :line => 10}
   end
 
   describe "when returning the value" do
     it "should return nil if no value is set" do
       @parameter.value.should be_nil
     end
 
     it "should validate the value" do
       @parameter.expects(:validate).with("foo")
       @parameter.value = "foo"
     end
 
     it "should munge the value and use any result as the actual value" do
       @parameter.expects(:munge).with("foo").returns "bar"
       @parameter.value = "foo"
       @parameter.value.should == "bar"
     end
 
     it "should unmunge the value when accessing the actual value" do
       @parameter.class.unmunge do |value| value.to_sym end
       @parameter.value = "foo"
       @parameter.value.should == :foo
     end
 
     it "should return the actual value by default when unmunging" do
       @parameter.unmunge("bar").should == "bar"
     end
 
     it "should return any set value" do
       @parameter.value = "foo"
       @parameter.value.should == "foo"
     end
   end
 
   describe "when validating values" do
     it "should do nothing if no values or regexes have been defined" do
       @parameter.validate("foo")
     end
 
     it "should catch abnormal failures thrown during validation" do
       @class.validate { |v| raise "This is broken" }
       lambda { @parameter.validate("eh") }.should raise_error(Puppet::DevError)
     end
 
     it "should fail if the value is not a defined value or alias and does not match a regex" do
       @class.newvalues :foo
       lambda { @parameter.validate("bar") }.should raise_error(Puppet::Error)
     end
 
     it "should succeed if the value is one of the defined values" do
       @class.newvalues :foo
       lambda { @parameter.validate(:foo) }.should_not raise_error(ArgumentError)
     end
 
     it "should succeed if the value is one of the defined values even if the definition uses a symbol and the validation uses a string" do
       @class.newvalues :foo
       lambda { @parameter.validate("foo") }.should_not raise_error(ArgumentError)
     end
 
     it "should succeed if the value is one of the defined values even if the definition uses a string and the validation uses a symbol" do
       @class.newvalues "foo"
       lambda { @parameter.validate(:foo) }.should_not raise_error(ArgumentError)
     end
 
     it "should succeed if the value is one of the defined aliases" do
       @class.newvalues :foo
       @class.aliasvalue :bar, :foo
       lambda { @parameter.validate("bar") }.should_not raise_error(ArgumentError)
     end
 
     it "should succeed if the value matches one of the regexes" do
       @class.newvalues %r{\d}
       lambda { @parameter.validate("10") }.should_not raise_error(ArgumentError)
     end
   end
 
   describe "when munging values" do
     it "should do nothing if no values or regexes have been defined" do
       @parameter.munge("foo").should == "foo"
     end
 
     it "should catch abnormal failures thrown during munging" do
       @class.munge { |v| raise "This is broken" }
       lambda { @parameter.munge("eh") }.should raise_error(Puppet::DevError)
     end
 
     it "should return return any matching defined values" do
       @class.newvalues :foo, :bar
       @parameter.munge("foo").should == :foo
     end
 
     it "should return any matching aliases" do
       @class.newvalues :foo
       @class.aliasvalue :bar, :foo
       @parameter.munge("bar").should == :foo
     end
 
     it "should return the value if it matches a regex" do
       @class.newvalues %r{\w}
       @parameter.munge("bar").should == "bar"
     end
 
     it "should return the value if no other option is matched" do
       @class.newvalues :foo
       @parameter.munge("bar").should == "bar"
     end
   end
 
   describe "when logging" do
     it "should use its resource's log level and the provided message" do
       @resource.expects(:[]).with(:loglevel).returns :notice
       @parameter.expects(:send_log).with(:notice, "mymessage")
       @parameter.log "mymessage"
     end
   end
+
+  describe ".format_value_for_display" do
+    it 'should format strings appropriately' do
+      described_class.format_value_for_display('foo').should == "'foo'"
+    end
+
+    it 'should format numbers appropriately' do
+      described_class.format_value_for_display(1).should == "'1'"
+    end
+
+    it 'should format symbols appropriately' do
+      described_class.format_value_for_display(:bar).should == "'bar'"
+    end
+
+    it 'should format arrays appropriately' do
+      described_class.format_value_for_display([1, 'foo', :bar]).should == "['1', 'foo', 'bar']"
+    end
+
+    it 'should format arrays with nested data appropriately' do
+      described_class.format_value_for_display(
+        [1, 'foo', :bar, [1, 2, 3]]
+      ).should == "['1', 'foo', 'bar', ['1', '2', '3']]"
+    end
+  end
 end