diff --git a/lib/puppet/parser/compiler.rb b/lib/puppet/parser/compiler.rb
index 8aee2e689..01accea18 100644
--- a/lib/puppet/parser/compiler.rb
+++ b/lib/puppet/parser/compiler.rb
@@ -1,483 +1,484 @@
 require 'puppet/node'
 require 'puppet/resource/catalog'
 require 'puppet/util/errors'
 
 require 'puppet/resource/type_collection_helper'
 
 # Maintain a graph of scopes, along with a bunch of data
 # about the individual catalog we're compiling.
 class Puppet::Parser::Compiler
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Resource::TypeCollectionHelper
 
   def self.compile(node)
     # We get these from the environment and only cache them in a thread
     # variable for the duration of the compilation.  If nothing else is using
     # the thread, though, we can leave 'em hanging round with no ill effects,
     # and this is safer than cleaning them at the end and assuming that will
     # stick until the next entry to this function.
     Thread.current[:known_resource_types] = nil
     Thread.current[:env_module_directories] = nil
 
     # ...and we actually do the compile now we have caching ready.
     new(node).compile.to_resource
   rescue => detail
     puts detail.backtrace if Puppet[:trace]
     raise Puppet::Error, "#{detail} on node #{node.name}"
  end
 
   attr_reader :node, :facts, :collections, :catalog, :node_scope, :resources, :relationships
 
   # Add a collection to the global list.
   def add_collection(coll)
     @collections << coll
   end
 
   def add_relationship(dep)
     @relationships << dep
   end
 
   # Store a resource override.
   def add_override(override)
     # If possible, merge the override in immediately.
     if resource = @catalog.resource(override.ref)
       resource.merge(override)
     else
       # Otherwise, store the override for later; these
       # get evaluated in Resource#finish.
       @resource_overrides[override.ref] << override
     end
   end
 
   # Store a resource in our resource table.
   def add_resource(scope, resource)
     @resources << resource
 
     # Note that this will fail if the resource is not unique.
     @catalog.add_resource(resource)
 
     if resource.type.to_s.downcase != "class" && resource[:stage]
       raise ArgumentError, "Only classes can set 'stage'; normal resources like #{resource} cannot change run stage"
     end
 
     # Stages should not be inside of classes.  They are always a
     # top-level container, regardless of where they appear in the
     # manifest.
     return if resource.type.to_s.downcase == "stage"
 
     # This adds a resource to the class it lexically appears in in the
     # manifest.
     if resource.type.to_s.downcase != "class"
       return @catalog.add_edge(scope.resource, resource)
     end
   end
 
   # Do we use nodes found in the code, vs. the external node sources?
   def ast_nodes?
     known_resource_types.nodes?
   end
 
   # Store the fact that we've evaluated a class
   def add_class(name)
     @catalog.add_class(name) unless name == ""
   end
 
 
   # Return a list of all of the defined classes.
   def classlist
     @catalog.classes
   end
 
   # Compiler our catalog.  This mostly revolves around finding and evaluating classes.
   # This is the main entry into our catalog.
   def compile
     # Set the client's parameters into the top scope.
     set_node_parameters
     create_settings_scope
 
     evaluate_main
 
     evaluate_ast_node
 
     evaluate_node_classes
 
     evaluate_generators
 
     finish
 
     fail_on_unevaluated
 
     @catalog
   end
 
   # LAK:FIXME There are no tests for this.
   def delete_collection(coll)
     @collections.delete(coll) if @collections.include?(coll)
   end
 
   # Return the node's environment.
   def environment
     unless defined?(@environment)
       @environment = (node.environment and node.environment != "") ? node.environment : nil
     end
     Puppet::Node::Environment.current = @environment
     @environment
   end
 
   # Evaluate all of the classes specified by the node.
   def evaluate_node_classes
     evaluate_classes(@node.classes, topscope)
   end
 
   # Evaluate each specified class in turn.  If there are any classes we can't
   # find, raise an error.  This method really just creates resource objects
   # that point back to the classes, and then the resources are themselves
   # evaluated later in the process.
   def evaluate_classes(classes, scope, lazy_evaluate = true)
     raise Puppet::DevError, "No source for scope passed to evaluate_classes" unless scope.source
     param_classes = nil
     # if we are a param class, save the classes hash
     # and transform classes to be the keys
     if classes.class == Hash
       param_classes = classes
       classes = classes.keys
     end
     classes.each do |name|
       # If we can find the class, then make a resource that will evaluate it.
       if klass = scope.find_hostclass(name)
 
         if param_classes
           resource = klass.ensure_in_catalog(scope, param_classes[name] || {})
         else
           next if scope.class_scope(klass)
           resource = klass.ensure_in_catalog(scope)
         end
 
         # If they've disabled lazy evaluation (which the :include function does),
         # then evaluate our resource immediately.
         resource.evaluate unless lazy_evaluate
       else
         raise Puppet::Error, "Could not find class #{name} for #{node.name}"
       end
     end
   end
 
   def evaluate_relationships
     @relationships.each { |rel| rel.evaluate(catalog) }
   end
 
   # Return a resource by either its ref or its type and title.
   def findresource(*args)
     @catalog.resource(*args)
   end
 
   def initialize(node, options = {})
     @node = node
 
     options.each do |param, value|
       begin
         send(param.to_s + "=", value)
       rescue NoMethodError
         raise ArgumentError, "Compiler objects do not accept #{param}"
       end
     end
 
     initvars
   end
 
   # Create a new scope, with either a specified parent scope or
   # using the top scope.
   def newscope(parent, options = {})
     parent ||= topscope
     options[:compiler] = self
     scope = Puppet::Parser::Scope.new(options)
     scope.parent = parent
     scope
   end
 
   # Return any overrides for the given resource.
   def resource_overrides(resource)
     @resource_overrides[resource.ref]
   end
 
   # The top scope is usually the top-level scope, but if we're using AST nodes,
   # then it is instead the node's scope.
   def topscope
     node_scope || @topscope
   end
 
   private
 
   # If ast nodes are enabled, then see if we can find and evaluate one.
   def evaluate_ast_node
     return unless ast_nodes?
 
     # Now see if we can find the node.
     astnode = nil
     @node.names.each do |name|
       break if astnode = known_resource_types.node(name.to_s.downcase)
     end
 
     unless (astnode ||= known_resource_types.node("default"))
       raise Puppet::ParseError, "Could not find default node or by name with '#{node.names.join(", ")}'"
     end
 
     # Create a resource to model this node, and then add it to the list
     # of resources.
     resource = astnode.ensure_in_catalog(topscope)
 
     resource.evaluate
 
     # Now set the node scope appropriately, so that :topscope can
     # behave differently.
     @node_scope = topscope.class_scope(astnode)
   end
 
   # Evaluate our collections and return true if anything returned an object.
   # The 'true' is used to continue a loop, so it's important.
   def evaluate_collections
     return false if @collections.empty?
 
     found_something = false
     exceptwrap do
       # We have to iterate over a dup of the array because
       # collections can delete themselves from the list, which
       # changes its length and causes some collections to get missed.
       @collections.dup.each do |collection|
         found_something = true if collection.evaluate
       end
     end
 
     found_something
   end
 
   # Make sure all of our resources have been evaluated into native resources.
   # We return true if any resources have, so that we know to continue the
   # evaluate_generators loop.
   def evaluate_definitions
     exceptwrap do
       !unevaluated_resources.each { |resource| resource.evaluate }.empty?
     end
   end
 
   # Iterate over collections and resources until we're sure that the whole
   # compile is evaluated.  This is necessary because both collections
   # and defined resources can generate new resources, which themselves could
   # be defined resources.
   def evaluate_generators
     count = 0
     loop do
       done = true
 
       # Call collections first, then definitions.
       done = false if evaluate_collections
       done = false if evaluate_definitions
       break if done
 
       count += 1
 
       if count > 1000
         raise Puppet::ParseError, "Somehow looped more than 1000 times while evaluating host catalog"
       end
     end
   end
 
   # Find and evaluate our main object, if possible.
   def evaluate_main
     @main = known_resource_types.find_hostclass([""], "") || known_resource_types.add(Puppet::Resource::Type.new(:hostclass, ""))
     @topscope.source = @main
     @main_resource = Puppet::Parser::Resource.new("class", :main, :scope => @topscope, :source => @main)
     @topscope.resource = @main_resource
 
     add_resource(@topscope, @main_resource)
 
     @main_resource.evaluate
   end
 
   # Make sure the entire catalog is evaluated.
   def fail_on_unevaluated
     fail_on_unevaluated_overrides
     fail_on_unevaluated_resource_collections
   end
 
   # If there are any resource overrides remaining, then we could
   # not find the resource they were supposed to override, so we
   # want to throw an exception.
   def fail_on_unevaluated_overrides
     remaining = []
     @resource_overrides.each do |name, overrides|
       remaining.concat overrides
     end
 
     unless remaining.empty?
       fail Puppet::ParseError,
         "Could not find resource(s) %s for overriding" % remaining.collect { |o|
           o.ref
         }.join(", ")
     end
   end
 
   # Make sure we don't have any remaining collections that specifically
   # look for resources, because we want to consider those to be
   # parse errors.
   def fail_on_unevaluated_resource_collections
     remaining = []
     @collections.each do |coll|
       # We're only interested in the 'resource' collections,
       # which result from direct calls of 'realize'.  Anything
       # else is allowed not to return resources.
       # Collect all of them, so we have a useful error.
       if r = coll.resources
         if r.is_a?(Array)
           remaining += r
         else
           remaining << r
         end
       end
     end
 
     raise Puppet::ParseError, "Failed to realize virtual resources #{remaining.join(', ')}" unless remaining.empty?
   end
 
   # Make sure all of our resources and such have done any last work
   # necessary.
   def finish
     evaluate_relationships
 
     resources.each do |resource|
       # Add in any resource overrides.
       if overrides = resource_overrides(resource)
         overrides.each do |over|
           resource.merge(over)
         end
 
         # Remove the overrides, so that the configuration knows there
         # are none left.
         overrides.clear
       end
 
       resource.finish if resource.respond_to?(:finish)
     end
 
     add_resource_metaparams
   end
 
   def add_resource_metaparams
     unless main = catalog.resource(:class, :main)
       raise "Couldn't find main"
     end
 
     names = []
     Puppet::Type.eachmetaparam do |name|
       next if Puppet::Parser::Resource.relationship_parameter?(name)
       names << name
     end
 
     data = {}
     catalog.walk(main, :out) do |source, target|
       if source_data = data[source] || metaparams_as_data(source, names)
         # only store anything in the data hash if we've actually got
         # data
         data[source] ||= source_data
         source_data.each do |param, value|
           target[param] = value if target[param].nil?
         end
         data[target] = source_data.merge(metaparams_as_data(target, names))
       end
 
       target.tag(*(source.tags))
     end
   end
 
   def metaparams_as_data(resource, params)
     data = nil
     params.each do |param|
       unless resource[param].nil?
         # Because we could be creating a hash for every resource,
         # and we actually probably don't often have any data here at all,
         # we're optimizing a bit by only creating a hash if there's
         # any data to put in it.
         data ||= {}
         data[param] = resource[param]
       end
     end
     data
   end
 
   # Set up all of our internal variables.
   def initvars
     # The list of objects that will available for export.
     @exported_resources = {}
 
     # The list of overrides.  This is used to cache overrides on objects
     # that don't exist yet.  We store an array of each override.
     @resource_overrides = Hash.new do |overs, ref|
       overs[ref] = []
     end
 
     # The list of collections that have been created.  This is a global list,
     # but they each refer back to the scope that created them.
     @collections = []
 
     # The list of relationships to evaluate.
     @relationships = []
 
     # For maintaining the relationship between scopes and their resources.
     @catalog = Puppet::Resource::Catalog.new(@node.name)
     @catalog.version = known_resource_types.version
 
     # Create our initial scope and a resource that will evaluate main.
     @topscope = Puppet::Parser::Scope.new(:compiler => self)
 
     @main_stage_resource = Puppet::Parser::Resource.new("stage", :main, :scope => @topscope)
     @catalog.add_resource(@main_stage_resource)
 
     # local resource array to maintain resource ordering
     @resources = []
 
     # Make sure any external node classes are in our class list
     if @node.classes.class == Hash
       @catalog.add_class(*@node.classes.keys)
     else
       @catalog.add_class(*@node.classes)
     end
   end
 
   # Set the node's parameters into the top-scope as variables.
   def set_node_parameters
     node.parameters.each do |param, value|
       @topscope.setvar(param, value)
     end
 
     # These might be nil.
     catalog.client_version = node.parameters["clientversion"]
     catalog.server_version = node.parameters["serverversion"]
   end
 
   def create_settings_scope
     unless settings_type = environment.known_resource_types.hostclass("settings")
       settings_type = Puppet::Resource::Type.new :hostclass, "settings"
       environment.known_resource_types.add(settings_type)
     end
 
     settings_resource = Puppet::Parser::Resource.new("class", "settings", :scope => @topscope)
-    settings_type.evaluate_code(settings_resource)
 
     @catalog.add_resource(settings_resource)
 
+    settings_type.evaluate_code(settings_resource)
+
     scope = @topscope.class_scope(settings_type)
 
     Puppet.settings.each do |name, setting|
       next if name.to_s == "name"
       scope.setvar name.to_s, environment[name]
     end
   end
 
   # Return an array of all of the unevaluated resources.  These will be definitions,
   # which need to get evaluated into native resources.
   def unevaluated_resources
     # The order of these is significant for speed due to short-circuting
     resources.reject { |resource| resource.evaluated? or resource.virtual? or resource.builtin_type? }
   end
 end
diff --git a/lib/puppet/parser/resource.rb b/lib/puppet/parser/resource.rb
index 4a1900315..bf967cfa8 100644
--- a/lib/puppet/parser/resource.rb
+++ b/lib/puppet/parser/resource.rb
@@ -1,343 +1,342 @@
 require 'puppet/resource'
 
 # The primary difference between this class and its
 # parent is that this class has rules on who can set
 # parameters
 class Puppet::Parser::Resource < Puppet::Resource
   require 'puppet/parser/resource/param'
   require 'puppet/util/tagging'
   require 'puppet/file_collection/lookup'
   require 'puppet/parser/yaml_trimmer'
   require 'puppet/resource/type_collection_helper'
 
   include Puppet::FileCollection::Lookup
   include Puppet::Resource::TypeCollectionHelper
 
   include Puppet::Util
   include Puppet::Util::MethodHelper
   include Puppet::Util::Errors
   include Puppet::Util::Logging
   include Puppet::Util::Tagging
   include Puppet::Parser::YamlTrimmer
 
   attr_accessor :source, :scope, :collector_id
   attr_accessor :virtual, :override, :translated, :catalog, :evaluated
 
   attr_reader :exported, :parameters
 
   # Determine whether the provided parameter name is a relationship parameter.
   def self.relationship_parameter?(name)
     @relationship_names ||= Puppet::Type.relationship_params.collect { |p| p.name }
     @relationship_names.include?(name)
   end
 
   # Set up some boolean test methods
   def translated?; !!@translated; end
   def override?;   !!@override;   end
   def evaluated?;  !!@evaluated;  end
 
   def [](param)
     param = symbolize(param)
     if param == :title
       return self.title
     end
     if @parameters.has_key?(param)
       @parameters[param].value
     else
       nil
     end
   end
 
   def []=(param, value)
     set_parameter(param, value)
   end
 
   def eachparam
     @parameters.each do |name, param|
       yield param
     end
   end
 
   def environment
     scope.environment
   end
 
   # Process the  stage metaparameter for a class.   A containment edge
   # is drawn from  the class to the stage.   The stage for containment
   # defaults to main, if none is specified.
   def add_edge_to_stage
     return unless self.type.to_s.downcase == "class"
 
     unless stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
       raise ArgumentError, "Could not find stage #{self[:stage] || :main} specified by #{self}"
     end
 
     self[:stage] ||= stage.title unless stage.title == :main
     catalog.add_edge(stage, self)
   end
 
   # Retrieve the associated definition and evaluate it.
   def evaluate
     return if evaluated?
     @evaluated = true
     if klass = resource_type and ! builtin_type?
       finish
       evaluated_code = klass.evaluate_code(self)
-      add_edge_to_stage
 
       return evaluated_code
     elsif builtin?
       devfail "Cannot evaluate a builtin type (#{type})"
     else
       self.fail "Cannot find definition #{type}"
     end
   end
 
   # Mark this resource as both exported and virtual,
   # or remove the exported mark.
   def exported=(value)
     if value
       @virtual = true
       @exported = value
     else
       @exported = value
     end
   end
 
   # Do any finishing work on this object, called before evaluation or
   # before storage/translation.
   def finish
     return if finished?
     @finished = true
     add_defaults
     add_metaparams
     add_scope_tags
     validate
   end
 
   # Has this resource already been finished?
   def finished?
     @finished
   end
 
   def initialize(*args)
     raise ArgumentError, "Resources require a scope" unless args.last[:scope]
     super
 
     @source ||= scope.source
   end
 
   # Is this resource modeling an isomorphic resource type?
   def isomorphic?
     if builtin_type?
       return resource_type.isomorphic?
     else
       return true
     end
   end
 
   # Merge an override resource in.  This will throw exceptions if
   # any overrides aren't allowed.
   def merge(resource)
     # Test the resource scope, to make sure the resource is even allowed
     # to override.
     unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
       raise Puppet::ParseError.new("Only subclasses can override parameters", resource.line, resource.file)
     end
     # Some of these might fail, but they'll fail in the way we want.
     resource.parameters.each do |name, param|
       override_parameter(param)
     end
   end
 
   # Unless we're running >= 0.25, we're in compat mode.
   def metaparam_compatibility_mode?
     ! (catalog and ver = (catalog.client_version||'0.0.0').split(".") and (ver[0] > "0" or ver[1].to_i >= 25))
   end
 
   def name
     self[:name] || self.title
   end
 
   # A temporary occasion, until I get paths in the scopes figured out.
   def path
     to_s
   end
 
   # Define a parameter in our resource.
   # if we ever receive a parameter named 'tag', set
   # the resource tags with its value.
   def set_parameter(param, value = nil)
     if ! value.nil?
       param = Puppet::Parser::Resource::Param.new(
         :name => param, :value => value, :source => self.source
       )
     elsif ! param.is_a?(Puppet::Parser::Resource::Param)
       raise ArgumentError, "Must pass a parameter or all necessary values"
     end
 
     tag(*param.value) if param.name == :tag
 
     # And store it in our parameter hash.
     @parameters[param.name] = param
   end
 
   def to_hash
     @parameters.inject({}) do |hash, ary|
       param = ary[1]
       # Skip "undef" values.
       hash[param.name] = param.value if param.value != :undef
       hash
     end
   end
 
 
   # Create a Puppet::Resource instance from this parser resource.
   # We plan, at some point, on not needing to do this conversion, but
   # it's sufficient for now.
   def to_resource
     result = Puppet::Resource.new(type, title)
 
     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 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] = if v.is_a?(Array) and v.length == 1
         v[0]
           else
             v
               end
     end
 
     result.file = self.file
     result.line = self.line
     result.exported = self.exported
     result.virtual = self.virtual
     result.tag(*self.tags)
 
     result
   end
 
   # Translate our object to a transportable object.
   def to_trans
     return nil if virtual?
 
     to_resource.to_trans
   end
 
   # Convert this resource to a RAL resource.  We hackishly go via the
   # transportable stuff.
   def to_ral
     to_resource.to_ral
   end
 
   private
 
   # Add default values from our definition.
   def add_defaults
     scope.lookupdefaults(self.type).each do |name, param|
       unless @parameters.include?(name)
         self.debug "Adding default for #{name}"
 
         @parameters[name] = param.dup
       end
     end
   end
 
   def add_backward_compatible_relationship_param(name)
     # Skip metaparams for which we get no value.
     return unless val = scope.lookupvar(name.to_s) and val != :undefined
 
     # The default case: just set the value
     set_parameter(name, val) and return unless @parameters[name]
 
     # For relationship params, though, join the values (a la #446).
     @parameters[name].value = [@parameters[name].value, val].flatten
   end
 
   # Add any metaparams defined in our scope. This actually adds any metaparams
   # from any parent scope, and there's currently no way to turn that off.
   def add_metaparams
     compat_mode = metaparam_compatibility_mode?
 
     Puppet::Type.eachmetaparam do |name|
       next unless self.class.relationship_parameter?(name)
       add_backward_compatible_relationship_param(name) if compat_mode
     end
   end
 
   def add_scope_tags
     if scope_resource = scope.resource
       tag(*scope_resource.tags)
     end
   end
 
   # Accept a parameter from an override.
   def override_parameter(param)
     # This can happen if the override is defining a new parameter, rather
     # than replacing an existing one.
     (set_parameter(param) and return) unless current = @parameters[param.name]
 
     # The parameter is already set.  Fail if they're not allowed to override it.
     unless param.source.child_of?(current.source)
       puts caller if Puppet[:trace]
       msg = "Parameter '#{param.name}' is already set on #{self}"
       msg += " by #{current.source}" if current.source.to_s != ""
       if current.file or current.line
         fields = []
         fields << current.file if current.file
         fields << current.line.to_s if current.line
         msg += " at #{fields.join(":")}"
       end
       msg += "; cannot redefine"
       raise Puppet::ParseError.new(msg, param.line, param.file)
     end
 
     # If we've gotten this far, we're allowed to override.
 
     # Merge with previous value, if the parameter was generated with the +>
     # syntax.  It's important that we use a copy of the new param instance
     # here, not the old one, and not the original new one, so that the source
     # is registered correctly for later overrides but the values aren't
     # implcitly shared when multiple resources are overrriden at once (see
     # ticket #3556).
     if param.add
       param = param.dup
       param.value = [current.value, param.value].flatten
     end
 
     set_parameter(param)
   end
 
   # Make sure the resource's parameters are all valid for the type.
   def validate
     @parameters.each do |name, param|
       validate_parameter(name)
     end
   rescue => detail
     fail Puppet::ParseError, detail.to_s
   end
 
   private
 
   def extract_parameters(params)
     params.each do |param|
       # Don't set the same parameter twice
       self.fail Puppet::ParseError, "Duplicate parameter '#{param.name}' for on #{self}" if @parameters[param.name]
 
       set_parameter(param)
     end
   end
 end
diff --git a/lib/puppet/resource/type.rb b/lib/puppet/resource/type.rb
index f8d820b77..600f4498a 100644
--- a/lib/puppet/resource/type.rb
+++ b/lib/puppet/resource/type.rb
@@ -1,342 +1,344 @@
 require 'puppet/parser/parser'
 require 'puppet/util/warnings'
 require 'puppet/util/errors'
 require 'puppet/util/inline_docs'
 require 'puppet/parser/ast/leaf'
 require 'puppet/dsl'
 
 class Puppet::Resource::Type
   Puppet::ResourceType = self
   include Puppet::Util::InlineDocs
   include Puppet::Util::Warnings
   include Puppet::Util::Errors
 
   RESOURCE_SUPERTYPES = [:hostclass, :node, :definition]
 
   attr_accessor :file, :line, :doc, :code, :ruby_code, :parent, :resource_type_collection
   attr_reader :type, :namespace, :arguments, :behaves_like, :module_name
 
   RESOURCE_SUPERTYPES.each do |t|
     define_method("#{t}?") { self.type == t }
   end
 
   require 'puppet/indirector'
   extend Puppet::Indirector
   indirects :resource_type, :terminus_class => :parser
 
   def self.from_pson(data)
     name = data.delete('name') or raise ArgumentError, "Resource Type names must be specified"
     type = data.delete('type') || "definition"
 
     data = data.inject({}) { |result, ary| result[ary[0].intern] = ary[1]; result }
 
     new(type, name, data)
   end
 
   def to_pson_data_hash
     data = [:doc, :line, :file, :parent].inject({}) do |hash, param|
       next hash unless (value = self.send(param)) and (value != "")
       hash[param.to_s] = value
       hash
     end
 
     data['arguments'] = arguments.dup unless arguments.empty?
 
     data['name'] = name
     data['type'] = type
 
     data
   end
 
   def to_pson(*args)
     to_pson_data_hash.to_pson(*args)
   end
 
   # Are we a child of the passed class?  Do a recursive search up our
   # parentage tree to figure it out.
   def child_of?(klass)
     return false unless parent
 
     return(klass == parent_type ? true : parent_type.child_of?(klass))
   end
 
   # Now evaluate the code associated with this class or definition.
   def evaluate_code(resource)
 
     static_parent = evaluate_parent_type(resource)
     scope = static_parent || resource.scope
 
     scope = scope.newscope(:namespace => namespace, :source => self, :resource => resource, :dynamic => !static_parent) unless resource.title == :main
     scope.compiler.add_class(name) unless definition?
 
     set_resource_parameters(resource, scope)
 
+    resource.add_edge_to_stage
+
     code.safeevaluate(scope) if code
 
     evaluate_ruby_code(resource, scope) if ruby_code
   end
 
   def initialize(type, name, options = {})
     @type = type.to_s.downcase.to_sym
     raise ArgumentError, "Invalid resource supertype '#{type}'" unless RESOURCE_SUPERTYPES.include?(@type)
 
     name = convert_from_ast(name) if name.is_a?(Puppet::Parser::AST::HostName)
 
     set_name_and_namespace(name)
 
     [:code, :doc, :line, :file, :parent].each do |param|
       next unless value = options[param]
       send(param.to_s + "=", value)
     end
 
     set_arguments(options[:arguments])
 
     @module_name = options[:module_name]
   end
 
   # This is only used for node names, and really only when the node name
   # is a regexp.
   def match(string)
     return string.to_s.downcase == name unless name_is_regex?
 
     @name =~ string
   end
 
   # Add code from a new instance to our code.
   def merge(other)
     fail "#{name} is not a class; cannot add code to it" unless type == :hostclass
     fail "#{other.name} is not a class; cannot add code from it" unless other.type == :hostclass
     fail "Cannot have code outside of a class/node/define because 'freeze_main' is enabled" if name == "" and Puppet.settings[:freeze_main]
 
     if parent and other.parent and parent != other.parent
       fail "Cannot merge classes with different parent classes (#{name} => #{parent} vs. #{other.name} => #{other.parent})"
     end
 
     # We know they're either equal or only one is set, so keep whichever parent is specified.
     self.parent ||= other.parent
 
     if other.doc
       self.doc ||= ""
       self.doc += other.doc
     end
 
     # This might just be an empty, stub class.
     return unless other.code
 
     unless self.code
       self.code = other.code
       return
     end
 
     array_class = Puppet::Parser::AST::ASTArray
     self.code = array_class.new(:children => [self.code]) unless self.code.is_a?(array_class)
 
     if other.code.is_a?(array_class)
       code.children += other.code.children
     else
       code.children << other.code
     end
   end
 
   # Make an instance of the resource type, and place it in the catalog
   # if it isn't in the catalog already.  This is only possible for
   # classes and nodes.  No parameters are be supplied--if this is a
   # parameterized class, then all parameters take on their default
   # values.
   def ensure_in_catalog(scope, parameters=nil)
     type == :definition and raise ArgumentError, "Cannot create resources for defined resource types"
     resource_type = type == :hostclass ? :class : :node
 
     # Do nothing if the resource already exists; this makes sure we don't
     # get multiple copies of the class resource, which helps provide the
     # singleton nature of classes.
     # we should not do this for classes with parameters
     # if parameters are passed, we should still try to create the resource
     # even if it exists so that we can fail
     # this prevents us from being able to combine param classes with include
     if resource = scope.catalog.resource(resource_type, name) and !parameters
       return resource
     end
     resource = Puppet::Parser::Resource.new(resource_type, name, :scope => scope, :source => self)
     if parameters
       parameters.each do |k,v|
         resource.set_parameter(k,v)
       end
     end
     instantiate_resource(scope, resource)
     scope.compiler.add_resource(scope, resource)
     resource
   end
 
   def instantiate_resource(scope, resource)
     # Make sure our parent class has been evaluated, if we have one.
     if parent && !scope.catalog.resource(resource.type, parent)
       parent_type(scope).ensure_in_catalog(scope)
     end
 
     if ['Class', 'Node'].include? resource.type
       scope.catalog.tag(*resource.tags)
     end
   end
 
   def name
     return @name unless @name.is_a?(Regexp)
     @name.source.downcase.gsub(/[^-\w:.]/,'').sub(/^\.+/,'')
   end
 
   def name_is_regex?
     @name.is_a?(Regexp)
   end
 
   # MQR TODO:
   #
   # The change(s) introduced by the fix for #4270 are mostly silly & should be 
   # removed, though we didn't realize it at the time.  If it can be established/
   # ensured that nodes never call parent_type and that resource_types are always
   # (as they should be) members of exactly one resource_type_collection the 
   # following method could / should be replaced with:
   #
   # def parent_type
   #   @parent_type ||= parent && (
   #     resource_type_collection.find_or_load([name],parent,type.to_sym) ||
   #     fail Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{resource_type_collection.environment}"
   #   )
   # end
   #
   # ...and then the rest of the changes around passing in scope reverted.
   #
   def parent_type(scope = nil)
     return nil unless parent
 
     unless @parent_type
       raise "Must pass scope to parent_type when called first time" unless scope
       unless @parent_type = scope.environment.known_resource_types.send("find_#{type}", [name], parent)
         fail Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{scope.environment}"
       end
     end
 
     @parent_type
   end
 
   # Set any arguments passed by the resource as variables in the scope.
   def set_resource_parameters(resource, scope)
     set = {}
     resource.to_hash.each do |param, value|
       param = param.to_sym
       fail Puppet::ParseError, "#{resource.ref} does not accept attribute #{param}" unless valid_parameter?(param)
 
       exceptwrap { scope.setvar(param.to_s, value) }
 
       set[param] = true
     end
 
     if @type == :hostclass
       scope.setvar("title", resource.title.to_s.downcase) unless set.include? :title
       scope.setvar("name",  resource.name.to_s.downcase ) unless set.include? :name
     else
       scope.setvar("title", resource.title              ) unless set.include? :title
       scope.setvar("name",  resource.name               ) unless set.include? :name
     end
     scope.setvar("module_name", module_name) if module_name and ! set.include? :module_name
 
     if caller_name = scope.parent_module_name and ! set.include?(:caller_module_name)
       scope.setvar("caller_module_name", caller_name)
     end
     scope.class_set(self.name,scope) if hostclass? or node?
     # Verify that all required arguments are either present or
     # have been provided with defaults.
     arguments.each do |param, default|
       param = param.to_sym
       next if set.include?(param)
 
       # Even if 'default' is a false value, it's an AST value, so this works fine
       fail Puppet::ParseError, "Must pass #{param} to #{resource.ref}" unless default
 
       value = default.safeevaluate(scope)
       scope.setvar(param.to_s, value)
 
       # Set it in the resource, too, so the value makes it to the client.
       resource[param] = value
     end
 
   end
 
   # Check whether a given argument is valid.
   def valid_parameter?(param)
     param = param.to_s
 
     return true if param == "name"
     return true if Puppet::Type.metaparam?(param)
     return false unless defined?(@arguments)
     return(arguments.include?(param) ? true : false)
   end
 
   def set_arguments(arguments)
     @arguments = {}
     return if arguments.nil?
 
     arguments.each do |arg, default|
       arg = arg.to_s
       warn_if_metaparam(arg, default)
       @arguments[arg] = default
     end
   end
 
   private
 
   def convert_from_ast(name)
     value = name.value
     if value.is_a?(Puppet::Parser::AST::Regex)
       name = value.value
     else
       name = value
     end
   end
 
   def evaluate_parent_type(resource)
     return unless klass = parent_type(resource.scope) and parent_resource = resource.scope.compiler.catalog.resource(:class, klass.name) || resource.scope.compiler.catalog.resource(:node, klass.name)
     parent_resource.evaluate unless parent_resource.evaluated?
     parent_scope(resource.scope, klass)
   end
 
   def evaluate_ruby_code(resource, scope)
     Puppet::DSL::ResourceAPI.new(resource, scope, ruby_code).evaluate
   end
 
   # Split an fq name into a namespace and name
   def namesplit(fullname)
     ary = fullname.split("::")
     n = ary.pop || ""
     ns = ary.join("::")
     return ns, n
   end
 
   def parent_scope(scope, klass)
     scope.class_scope(klass) || raise(Puppet::DevError, "Could not find scope for #{klass.name}")
   end
 
   def set_name_and_namespace(name)
     if name.is_a?(Regexp)
       @name = name
       @namespace = ""
     else
       @name = name.to_s.downcase
 
       # Note we're doing something somewhat weird here -- we're setting
       # the class's namespace to its fully qualified name.  This means
       # anything inside that class starts looking in that namespace first.
       @namespace, ignored_shortname = @type == :hostclass ? [@name, ''] : namesplit(@name)
     end
   end
 
   def warn_if_metaparam(param, default)
     return unless Puppet::Type.metaparamclass(param)
 
     if default
       warnonce "#{param} is a metaparam; this value will inherit to all contained resources"
     else
       raise Puppet::ParseError, "#{param} is a metaparameter; please choose another parameter name in the #{self.name} definition"
     end
   end
 end
 
diff --git a/spec/unit/parser/resource_spec.rb b/spec/unit/parser/resource_spec.rb
index 1190716d7..90ed4dba4 100755
--- a/spec/unit/parser/resource_spec.rb
+++ b/spec/unit/parser/resource_spec.rb
@@ -1,615 +1,659 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 # LAK: FIXME This is just new tests for resources; I have
 # not moved all tests over yet.
 
 describe Puppet::Parser::Resource do
   before do
     @node = Puppet::Node.new("yaynode")
     @known_resource_types = Puppet::Resource::TypeCollection.new("env")
     @compiler = Puppet::Parser::Compiler.new(@node)
     @compiler.environment.stubs(:known_resource_types).returns @known_resource_types
     @source = newclass ""
     @scope = @compiler.topscope
   end
 
   def mkresource(args = {})
     args[:source] ||= @source
     args[:scope] ||= @scope
 
     params = args[:parameters] || {:one => "yay", :three => "rah"}
     if args[:parameters] == :none
       args.delete(:parameters)
     elsif not args[:parameters].is_a? Array
       args[:parameters] = paramify(args[:source], params)
     end
 
     Puppet::Parser::Resource.new("resource", "testing", args)
   end
 
   def param(name, value, source)
     Puppet::Parser::Resource::Param.new(:name => name, :value => value, :source => source)
   end
 
   def paramify(source, hash)
     hash.collect do |name, value|
       Puppet::Parser::Resource::Param.new(
         :name => name, :value => value, :source => source
       )
     end
   end
 
   def newclass(name)
     @known_resource_types.add Puppet::Resource::Type.new(:hostclass, name)
   end
 
   def newdefine(name)
     @known_resource_types.add Puppet::Resource::Type.new(:definition, name)
   end
 
   def newnode(name)
     @known_resource_types.add Puppet::Resource::Type.new(:node, name)
   end
 
   it "should use the file lookup module" do
     Puppet::Parser::Resource.ancestors.should be_include(Puppet::FileCollection::Lookup)
   end
 
   it "should get its environment from its scope" do
     scope = stub 'scope', :source => stub("source"), :namespaces => nil
     scope.expects(:environment).returns("foo").at_least_once
     Puppet::Parser::Resource.new("file", "whatever", :scope => scope).environment.should == "foo"
   end
 
   it "should use the resource type collection helper module" do
     Puppet::Parser::Resource.ancestors.should be_include(Puppet::Resource::TypeCollectionHelper)
   end
 
   it "should use the scope's environment as its environment" do
     @scope.expects(:environment).returns("myenv").at_least_once
     Puppet::Parser::Resource.new("file", "whatever", :scope => @scope).environment.should == "myenv"
   end
 
   it "should be isomorphic if it is builtin and models an isomorphic type" do
     Puppet::Type.type(:file).expects(:isomorphic?).returns(true)
     @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
   end
 
   it "should not be isomorphic if it is builtin and models a non-isomorphic type" do
     Puppet::Type.type(:file).expects(:isomorphic?).returns(false)
     @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source).isomorphic?.should be_false
   end
 
   it "should be isomorphic if it is not builtin" do
     newdefine "whatever"
     @resource = Puppet::Parser::Resource.new("whatever", "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
   end
 
   it "should have a array-indexing method for retrieving parameter values" do
     @resource = mkresource
     @resource[:one].should == "yay"
   end
 
   it "should use a Puppet::Resource for converting to a ral resource" do
     trans = mock 'resource', :to_ral => "yay"
     @resource = mkresource
     @resource.expects(:to_resource).returns trans
     @resource.to_ral.should == "yay"
   end
 
   it "should be able to use the indexing operator to access parameters" do
     resource = Puppet::Parser::Resource.new("resource", "testing", :source => "source", :scope => @scope)
     resource["foo"] = "bar"
     resource["foo"].should == "bar"
   end
 
   it "should return the title when asked for a parameter named 'title'" do
     Puppet::Parser::Resource.new("resource", "testing", :source => @source, :scope => @scope)[:title].should == "testing"
   end
 
   describe "when initializing" do
     before do
       @arguments = {:scope => @scope}
     end
 
     it "should fail unless #{name.to_s} is specified", :'fails_on_ruby_1.9.2' => true do
       lambda { Puppet::Parser::Resource.new('file', '/my/file') }.should raise_error(ArgumentError)
     end
 
     it "should set the reference correctly" do
       res = Puppet::Parser::Resource.new("resource", "testing", @arguments)
       res.ref.should == "Resource[testing]"
     end
 
     it "should be tagged with user tags" do
       tags = [ "tag1", "tag2" ]
       @arguments[:parameters] = [ param(:tag, tags , :source) ]
       res = Puppet::Parser::Resource.new("resource", "testing", @arguments)
       (res.tags & tags).should == tags
     end
   end
 
   describe "when evaluating" do
     before do
       @node = Puppet::Node.new "test-node"
       @compiler = Puppet::Parser::Compiler.new @node
       @catalog = Puppet::Resource::Catalog.new
       source = stub('source')
       source.stubs(:module_name)
       @scope = Puppet::Parser::Scope.new(:compiler => @compiler, :source => source)
       @catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => @scope))
     end
 
     it "should evaluate the associated AST definition" do
       definition = newdefine "mydefine"
       res = Puppet::Parser::Resource.new("mydefine", "whatever", :scope => @scope, :source => @source, :catalog => @catalog)
       definition.expects(:evaluate_code).with(res)
 
       res.evaluate
     end
 
     it "should evaluate the associated AST class" do
       @class = newclass "myclass"
       res = Puppet::Parser::Resource.new("class", "myclass", :scope => @scope, :source => @source, :catalog => @catalog)
       @class.expects(:evaluate_code).with(res)
       res.evaluate
     end
 
     it "should evaluate the associated AST node" do
       nodedef = newnode("mynode")
       res = Puppet::Parser::Resource.new("node", "mynode", :scope => @scope, :source => @source, :catalog => @catalog)
       nodedef.expects(:evaluate_code).with(res)
       res.evaluate
     end
 
     it "should add an edge to any specified stage for class resources", :'fails_on_ruby_1.9.2' => true do
       @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", '')
 
       other_stage = Puppet::Parser::Resource.new(:stage, "other", :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, other_stage)
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       resource[:stage] = 'other'
       @compiler.add_resource(@scope, resource)
 
       resource.evaluate
 
       @compiler.catalog.edge?(other_stage, resource).should be_true
     end
 
     it "should fail if an unknown stage is specified", :'fails_on_ruby_1.9.2' => true do
       @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", '')
 
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       resource[:stage] = 'other'
 
       lambda { resource.evaluate }.should raise_error(ArgumentError, /Could not find stage other specified by/)
     end
 
     it "should add edges from the class resources to the parent's stage if no stage is specified", :'fails_on_ruby_1.9.2' => true do
       main      = @compiler.catalog.resource(:stage, :main)
       foo_stage = Puppet::Parser::Resource.new(:stage, :foo_stage, :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, foo_stage)
       @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", '')
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       resource[:stage] = 'foo_stage'
       @compiler.add_resource(@scope, resource)
 
       resource.evaluate
 
       @compiler.catalog.should be_edge(foo_stage, resource)
     end
 
+    it "should allow edges to propagate multiple levels down the scope hierarchy" do
+      Puppet[:code] = <<-MANIFEST
+        stage { before: before => Stage[main] }
+
+        class alpha {
+          include beta
+        }
+        class beta {
+          include gamma
+        }
+        class gamma { }
+        class { alpha: stage => before }
+      MANIFEST
+
+      catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new 'anyone')
+
+      # Stringify them to make for easier lookup
+      edges = catalog.edges.map {|e| [e.source.ref, e.target.ref]}
+
+      edges.should include(["Stage[before]", "Class[Alpha]"])
+      edges.should include(["Stage[before]", "Class[Beta]"])
+      edges.should include(["Stage[before]", "Class[Gamma]"])
+    end
+
+    it "should use the specified stage even if the parent scope specifies one" do
+      Puppet[:code] = <<-MANIFEST
+        stage { before: before => Stage[main], }
+        stage { after: require => Stage[main], }
+
+        class alpha {
+          class { beta: stage => after }
+        }
+        class beta { }
+        class { alpha: stage => before }
+      MANIFEST
+
+      catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new 'anyone')
+
+      edges = catalog.edges.map {|e| [e.source.ref, e.target.ref]}
+
+      edges.should include(["Stage[before]", "Class[Alpha]"])
+      edges.should include(["Stage[after]", "Class[Beta]"])
+    end
+
     it "should add edges from top-level class resources to the main stage if no stage is specified", :'fails_on_ruby_1.9.2' => true do
       main = @compiler.catalog.resource(:stage, :main)
       @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", '')
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, resource)
 
       resource.evaluate
 
       @compiler.catalog.should be_edge(main, resource)
     end
   end
 
   describe "when finishing" do
     before do
       @class = newclass "myclass"
       @nodedef = newnode("mynode")
 
       @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source)
     end
 
     it "should do nothing if it has already been finished" do
       @resource.finish
       @resource.expects(:add_metaparams).never
       @resource.finish
     end
 
     it "should add all defaults available from the scope" do
       @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => param(:owner, "default", @resource.source))
       @resource.finish
 
       @resource[:owner].should == "default"
     end
 
     it "should not replace existing parameters with defaults" do
       @resource.set_parameter :owner, "oldvalue"
       @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => :replaced)
       @resource.finish
 
       @resource[:owner].should == "oldvalue"
     end
 
     it "should add a copy of each default, rather than the actual default parameter instance" do
       newparam = param(:owner, "default", @resource.source)
       other = newparam.dup
       other.value = "other"
       newparam.expects(:dup).returns(other)
       @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => newparam)
       @resource.finish
 
       @resource[:owner].should == "other"
     end
 
     it "should be running in metaparam compatibility mode if running a version below 0.25" do
       catalog = stub 'catalog', :client_version => "0.24.8"
       @resource.stubs(:catalog).returns catalog
       @resource.should be_metaparam_compatibility_mode
     end
 
     it "should be running in metaparam compatibility mode if running no client version is available" do
       catalog = stub 'catalog', :client_version => nil
       @resource.stubs(:catalog).returns catalog
       @resource.should be_metaparam_compatibility_mode
     end
 
     it "should not be running in metaparam compatibility mode if running a version at or above 0.25" do
       catalog = stub 'catalog', :client_version => "0.25.0"
       @resource.stubs(:catalog).returns catalog
       @resource.should_not be_metaparam_compatibility_mode
     end
 
     it "should not copy relationship metaparams when not in metaparam compatibility mode" do
       @scope.setvar("require", "bar")
 
       @resource.stubs(:metaparam_compatibility_mode?).returns false
       @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
 
       @resource["require"].should be_nil
     end
 
     it "should copy relationship metaparams when in metaparam compatibility mode" do
       @scope.setvar("require", "bar")
 
       @resource.stubs(:metaparam_compatibility_mode?).returns true
       @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
 
       @resource["require"].should == "bar"
     end
 
     it "should stack relationship metaparams when in metaparam compatibility mode" do
       @resource.set_parameter("require", "foo")
       @scope.setvar("require", "bar")
 
       @resource.stubs(:metaparam_compatibility_mode?).returns true
       @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
 
       @resource["require"].should == ["foo", "bar"]
     end
   end
 
   describe "when being tagged" do
     before do
       @scope_resource = stub 'scope_resource', :tags => %w{srone srtwo}
       @scope.stubs(:resource).returns @scope_resource
       @resource = Puppet::Parser::Resource.new("file", "yay", :scope => @scope, :source => mock('source'))
     end
 
     it "should get tagged with the resource type" do
       @resource.tags.should be_include("file")
     end
 
     it "should get tagged with the title" do
       @resource.tags.should be_include("yay")
     end
 
     it "should get tagged with each name in the title if the title is a qualified class name" do
       resource = Puppet::Parser::Resource.new("file", "one::two", :scope => @scope, :source => mock('source'))
       resource.tags.should be_include("one")
       resource.tags.should be_include("two")
     end
 
     it "should get tagged with each name in the type if the type is a qualified class name" do
       resource = Puppet::Parser::Resource.new("one::two", "whatever", :scope => @scope, :source => mock('source'))
       resource.tags.should be_include("one")
       resource.tags.should be_include("two")
     end
 
     it "should not get tagged with non-alphanumeric titles" do
       resource = Puppet::Parser::Resource.new("file", "this is a test", :scope => @scope, :source => mock('source'))
       resource.tags.should_not be_include("this is a test")
     end
 
     it "should fail on tags containing '*' characters" do
       lambda { @resource.tag("bad*tag") }.should raise_error(Puppet::ParseError)
     end
 
     it "should fail on tags starting with '-' characters" do
       lambda { @resource.tag("-badtag") }.should raise_error(Puppet::ParseError)
     end
 
     it "should fail on tags containing ' ' characters" do
       lambda { @resource.tag("bad tag") }.should raise_error(Puppet::ParseError)
     end
 
     it "should allow alpha tags" do
       lambda { @resource.tag("good_tag") }.should_not raise_error(Puppet::ParseError)
     end
   end
 
   describe "when merging overrides" do
     before do
       @source = "source1"
       @resource = mkresource :source => @source
       @override = mkresource :source => @source
     end
 
     it "should fail when the override was not created by a parent class" do
       @override.source = "source2"
       @override.source.expects(:child_of?).with("source1").returns(false)
       lambda { @resource.merge(@override) }.should raise_error(Puppet::ParseError)
     end
 
     it "should succeed when the override was created in the current scope" do
       @resource.source = "source3"
       @override.source = @resource.source
       @override.source.expects(:child_of?).with("source3").never
       params = {:a => :b, :c => :d}
       @override.expects(:parameters).returns(params)
       @resource.expects(:override_parameter).with(:b)
       @resource.expects(:override_parameter).with(:d)
       @resource.merge(@override)
     end
 
     it "should succeed when a parent class created the override" do
       @resource.source = "source3"
       @override.source = "source4"
       @override.source.expects(:child_of?).with("source3").returns(true)
       params = {:a => :b, :c => :d}
       @override.expects(:parameters).returns(params)
       @resource.expects(:override_parameter).with(:b)
       @resource.expects(:override_parameter).with(:d)
       @resource.merge(@override)
     end
 
     it "should add new parameters when the parameter is not set" do
       @source.stubs(:child_of?).returns true
       @override.set_parameter(:testing, "value")
       @resource.merge(@override)
 
       @resource[:testing].should == "value"
     end
 
     it "should replace existing parameter values" do
       @source.stubs(:child_of?).returns true
       @resource.set_parameter(:testing, "old")
       @override.set_parameter(:testing, "value")
 
       @resource.merge(@override)
 
       @resource[:testing].should == "value"
     end
 
     it "should add values to the parameter when the override was created with the '+>' syntax" do
       @source.stubs(:child_of?).returns true
       param = Puppet::Parser::Resource::Param.new(:name => :testing, :value => "testing", :source => @resource.source)
       param.add = true
 
       @override.set_parameter(param)
 
       @resource.set_parameter(:testing, "other")
 
       @resource.merge(@override)
 
       @resource[:testing].should == %w{other testing}
     end
 
     it "should not merge parameter values when multiple resources are overriden with '+>' at once " do
       @resource_2 = mkresource :source => @source
 
       @resource.  set_parameter(:testing, "old_val_1")
       @resource_2.set_parameter(:testing, "old_val_2")
 
       @source.stubs(:child_of?).returns true
       param = Puppet::Parser::Resource::Param.new(:name => :testing, :value => "new_val", :source => @resource.source)
       param.add = true
       @override.set_parameter(param)
 
       @resource.  merge(@override)
       @resource_2.merge(@override)
 
       @resource  [:testing].should == %w{old_val_1 new_val}
       @resource_2[:testing].should == %w{old_val_2 new_val}
     end
 
     it "should promote tag overrides to real tags" do
       @source.stubs(:child_of?).returns true
       param = Puppet::Parser::Resource::Param.new(:name => :tag, :value => "testing", :source => @resource.source)
 
       @override.set_parameter(param)
 
       @resource.merge(@override)
 
       @resource.tagged?("testing").should be_true
     end
 
   end
 
   it "should be able to be converted to a normal resource" do
     @source = stub 'scope', :name => "myscope"
     @resource = mkresource :source => @source
     @resource.should respond_to(:to_resource)
   end
 
   it "should use its resource converter to convert to a transportable resource" do
     @source = stub 'scope', :name => "myscope"
     @resource = mkresource :source => @source
 
     newresource = Puppet::Resource.new(:file, "/my")
     Puppet::Resource.expects(:new).returns(newresource)
 
     newresource.expects(:to_trans).returns "mytrans"
 
     @resource.to_trans.should == "mytrans"
   end
 
   it "should return nil if converted to a transportable resource and it is virtual" do
     @source = stub 'scope', :name => "myscope"
     @resource = mkresource :source => @source
 
     @resource.expects(:virtual?).returns true
     @resource.to_trans.should be_nil
   end
 
   describe "when being converted to a resource" do
     before do
       @parser_resource = mkresource :scope => @scope, :parameters => {:foo => "bar", :fee => "fum"}
     end
 
     it "should create an instance of Puppet::Resource" do
       @parser_resource.to_resource.should be_instance_of(Puppet::Resource)
     end
 
     it "should set the type correctly on the Puppet::Resource" do
       @parser_resource.to_resource.type.should == @parser_resource.type
     end
 
     it "should set the title correctly on the Puppet::Resource" do
       @parser_resource.to_resource.title.should == @parser_resource.title
     end
 
     it "should copy over all of the parameters" do
       result = @parser_resource.to_resource.to_hash
 
       # The name will be in here, also.
       result[:foo].should == "bar"
       result[:fee].should == "fum"
     end
 
     it "should copy over the tags" do
       @parser_resource.tag "foo"
       @parser_resource.tag "bar"
 
       @parser_resource.to_resource.tags.should == @parser_resource.tags
     end
 
     it "should copy over the line" do
       @parser_resource.line = 40
       @parser_resource.to_resource.line.should == 40
     end
 
     it "should copy over the file" do
       @parser_resource.file = "/my/file"
       @parser_resource.to_resource.file.should == "/my/file"
     end
 
     it "should copy over the 'exported' value" do
       @parser_resource.exported = true
       @parser_resource.to_resource.exported.should be_true
     end
 
     it "should copy over the 'virtual' value" do
       @parser_resource.virtual = true
       @parser_resource.to_resource.virtual.should be_true
     end
 
     it "should convert any parser resource references to Puppet::Resource instances" do
       ref = Puppet::Resource.new("file", "/my/file")
       @parser_resource = mkresource :source => @source, :parameters => {:foo => "bar", :fee => ref}
       result = @parser_resource.to_resource
       result[:fee].should == Puppet::Resource.new(:file, "/my/file")
     end
 
     it "should convert any parser resource references to Puppet::Resource instances even if they are in an array" do
       ref = Puppet::Resource.new("file", "/my/file")
       @parser_resource = mkresource :source => @source, :parameters => {:foo => "bar", :fee => ["a", ref]}
       result = @parser_resource.to_resource
       result[:fee].should == ["a", Puppet::Resource.new(:file, "/my/file")]
     end
 
     it "should convert any parser resource references to Puppet::Resource instances even if they are in an array of array, and even deeper" do
       ref1 = Puppet::Resource.new("file", "/my/file1")
       ref2 = Puppet::Resource.new("file", "/my/file2")
       @parser_resource = mkresource :source => @source, :parameters => {:foo => "bar", :fee => ["a", [ref1,ref2]]}
       result = @parser_resource.to_resource
       result[:fee].should == ["a", Puppet::Resource.new(:file, "/my/file1"), Puppet::Resource.new(:file, "/my/file2")]
     end
 
     it "should fail if the same param is declared twice" do
       lambda do
         @parser_resource = mkresource :source => @source, :parameters => [
           Puppet::Parser::Resource::Param.new(
             :name => :foo, :value => "bar", :source => @source
           ),
           Puppet::Parser::Resource::Param.new(
             :name => :foo, :value => "baz", :source => @source
           )
         ]
       end.should raise_error(Puppet::ParseError)
     end
   end
 
   describe "when validating" do
     it "should check each parameter" do
       resource = Puppet::Parser::Resource.new :foo, "bar", :scope => @scope, :source => stub("source")
       resource[:one] = :two
       resource[:three] = :four
       resource.expects(:validate_parameter).with(:one)
       resource.expects(:validate_parameter).with(:three)
       resource.send(:validate)
     end
 
     it "should raise a parse error when there's a failure" do
       resource = Puppet::Parser::Resource.new :foo, "bar", :scope => @scope, :source => stub("source")
       resource[:one] = :two
       resource.expects(:validate_parameter).with(:one).raises ArgumentError
       lambda { resource.send(:validate) }.should raise_error(Puppet::ParseError)
     end
   end
 
   describe "when setting parameters" do
     before do
       @source = newclass "foobar"
       @resource = Puppet::Parser::Resource.new :foo, "bar", :scope => @scope, :source => @source
     end
 
     it "should accept Param instances and add them to the parameter list" do
       param = Puppet::Parser::Resource::Param.new :name => "foo", :value => "bar", :source => @source
       @resource.set_parameter(param)
       @resource["foo"].should == "bar"
     end
 
     it "should fail when provided a parameter name but no value" do
       lambda { @resource.set_parameter("myparam") }.should raise_error(ArgumentError)
     end
 
     it "should allow parameters to be set to 'false'" do
       @resource.set_parameter("myparam", false)
       @resource["myparam"].should be_false
     end
 
     it "should use its source when provided a parameter name and value" do
       @resource.set_parameter("myparam", "myvalue")
       @resource["myparam"].should == "myvalue"
     end
   end
 
   # part of #629 -- the undef keyword.  Make sure 'undef' params get skipped.
   it "should not include 'undef' parameters when converting itself to a hash" do
     resource = Puppet::Parser::Resource.new "file", "/tmp/testing", :source => mock("source"), :scope => mock("scope")
     resource[:owner] = :undef
     resource[:mode] = "755"
     resource.to_hash[:owner].should be_nil
   end
 end