diff --git a/lib/puppet/parser/compile.rb b/lib/puppet/parser/compile.rb
index e1e230d48..42d229867 100644
--- a/lib/puppet/parser/compile.rb
+++ b/lib/puppet/parser/compile.rb
@@ -1,511 +1,522 @@
 #  Created by Luke A. Kanies on 2007-08-13.
 #  Copyright (c) 2007. All rights reserved.
 
 require 'puppet/node'
 require 'puppet/node/catalog'
 require 'puppet/util/errors'
 
 # Maintain a graph of scopes, along with a bunch of data
 # about the individual catalog we're compiling.
 class Puppet::Parser::Compile
     include Puppet::Util
     include Puppet::Util::Errors
     attr_reader :parser, :node, :facts, :collections, :catalog, :node_scope
 
     # Add a collection to the global list.
     def add_collection(coll)
         @collections << coll
     end
 
     # Do we use nodes found in the code, vs. the external node sources?
     def ast_nodes?
         parser.nodes.length > 0
     end
 
     # Store the fact that we've evaluated a class, and store a reference to
     # the scope in which it was evaluated, so that we can look it up later.
     def class_set(name, scope)
         if existing = @class_scopes[name]
             if existing.nodescope? or scope.nodescope?
                 raise Puppet::ParseError, "Cannot have classes, nodes, or definitions with the same name"
             else
                 raise Puppet::DevError, "Somehow evaluated the same class twice"
             end
         end
         @class_scopes[name] = scope
         @catalog.add_class(name) unless name == ""
     end
 
     # Return the scope associated with a class.  This is just here so
     # that subclasses can set their parent scopes to be the scope of
     # their parent class, and it's also used when looking up qualified
     # variables.
     def class_scope(klass)
         # They might pass in either the class or class name
         if klass.respond_to?(:classname)
             @class_scopes[klass.classname]
         else
             @class_scopes[klass]
         end
     end
 
     # Return a list of all of the defined classes.
     def classlist
         return @catalog.classes
     end
 
     # Compile 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()
 
         evaluate_main()
 
         evaluate_ast_node()
 
         evaluate_node_classes()
 
         evaluate_generators()
 
-        fail_on_unevaluated()
-
         finish()
 
+        fail_on_unevaluated()
+
         if Puppet[:storeconfigs]
             store()
         end
 
         return @catalog
     end
 
     # LAK:FIXME There are no tests for this.
     def delete_collection(coll)
         @collections.delete(coll) if @collections.include?(coll)
     end
 
     # LAK:FIXME There are no tests for this.
     def delete_resource(resource)
         @resource_table.delete(resource.ref) if @resource_table.include?(resource.ref)
     end
 
     # Return the node's environment.
     def environment
         unless defined? @environment
             if node.environment and node.environment != ""
                 @environment = node.environment
             else
                 @environment = nil
             end
         end
         @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, just tag the catalog and move on.  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)
         unless scope.source
             raise Puppet::DevError, "No source for scope passed to evaluate_classes"
         end
         found = []
         classes.each do |name|
             # If we can find the class, then make a resource that will evaluate it.
             if klass = scope.findclass(name)
                 found << name and next if class_scope(klass)
 
                 # Create a resource to model this class, and then add it to the list
                 # of resources.
                 resource = Puppet::Parser::Resource.new(:type => "class", :title => klass.classname, :scope => scope, :source => scope.source)
 
                 store_resource(scope, resource)
 
                 # If they've disabled lazy evaluation (which the :include function does),
                 # then evaluate our resource immediately.
                 resource.evaluate unless lazy_evaluate
                 @catalog.tag(klass.classname)
                 found << name
             else
                 Puppet.info "Could not find class %s for %s" % [name, node.name]
                 @catalog.tag(name)
             end
         end
         found
     end
 
     # Return a resource by either its ref or its type and title.
     def findresource(string, name = nil)
         string = "%s[%s]" % [string.capitalize, name] if name
 
         @resource_table[string]
     end
 
     # Set up our compile.  We require a parser
     # and a node object; the parser is so we can look up classes
     # and AST nodes, and the node has all of the client's info,
     # like facts and environment.
     def initialize(node, parser, options = {})
         @node = node
         @parser = parser
 
         options.each do |param, value|
             begin
                 send(param.to_s + "=", value)
             rescue NoMethodError
                 raise ArgumentError, "Compile objects do not accept %s" % param
             end
         end
 
         initvars()
         init_main()
     end
 
     # Create a new scope, with either a specified parent scope or
     # using the top scope.  Adds an edge between the scope and
     # its parent to the graph.
     def newscope(parent, options = {})
         parent ||= topscope
         options[:compile] = self
         options[:parser] ||= self.parser
         scope = Puppet::Parser::Scope.new(options)
         @scope_graph.add_edge!(parent, scope)
         scope
     end
 
     # Find the parent of a given scope.  Assumes scopes only ever have
     # one in edge, which will always be true.
     def parent(scope)
         if ary = @scope_graph.adjacent(scope, :direction => :in) and ary.length > 0
             ary[0]
         else
             nil
         end
     end
 
     # Return any overrides for the given resource.
     def resource_overrides(resource)
         @resource_overrides[resource.ref]
     end
 
     # Return a list of all resources.
     def resources
         @resource_table.values
     end
 
     # Store a resource override.
     def store_override(override)
-        override.override = true
-
         # If possible, merge the override in immediately.
         if resource = @resource_table[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 store_resource(scope, resource)
         # This might throw an exception
         verify_uniqueness(resource)
 
         # Store it in the global table.
         @resource_table[resource.ref] = resource
 
         # And in the resource graph.  At some point, this might supercede
         # the global resource table, but the table is a lot faster
         # so it makes sense to maintain for now.
         @catalog.add_edge!(scope.resource, resource)
     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 = @parser.nodes[name.to_s.downcase]
         end
 
         unless (astnode ||= @parser.nodes["default"])
             raise Puppet::ParseError, "Could not find default node or by name with '%s'" % node.names.join(", ")
         end
 
         # Create a resource to model this node, and then add it to the list
         # of resources.
         resource = Puppet::Parser::Resource.new(:type => "node", :title => astnode.classname, :scope => topscope, :source => topscope.source)
         store_resource(topscope, resource)
         @catalog.tag(astnode.classname)
 
         resource.evaluate
 
         # Now set the node scope appropriately, so that :topscope can
         # behave differently.
         @node_scope = 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
 
         return 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
             if ary = unevaluated_resources
                 ary.each do |resource|
                     resource.evaluate
                 end
                 # If we evaluated, let the loop know.
                 return true
             else
                 return false
             end
         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 = @parser.findclass("", "") || @parser.newclass("")
         @topscope.source = @main
         @main_resource = Puppet::Parser::Resource.new(:type => "class", :title => :main, :scope => @topscope, :source => @main)
         @topscope.resource = @main_resource
 
         @catalog.add_vertex!(@main_resource)
 
         @resource_table["Class[main]"] = @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 += overrides
         end
 
         unless remaining.empty?
             fail Puppet::ParseError,
                 "Could not find object(s) %s" % 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
 
         unless remaining.empty?
             raise Puppet::ParseError, "Failed to realize virtual resources %s" %
                 remaining.join(', ')
         end
     end
 
     # Make sure all of our resources and such have done any last work
     # necessary.
     def finish
-        @resource_table.each { |name, resource| resource.finish if resource.respond_to?(:finish) }
+        @resource_table.each do |name, 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
     end
 
     # Initialize the top-level scope, class, and resource.
     def init_main
         # Create our initial scope and a resource that will evaluate main.
         @topscope = Puppet::Parser::Scope.new(:compile => self, :parser => self.parser)
         @scope_graph.add_vertex!(@topscope)
     end
 
     # Set up all of our internal variables.
     def initvars
         # The table for storing class singletons.  This will only actually
         # be used by top scopes and node scopes.
         @class_scopes = {}
 
         # The table for all defined resources.
         @resource_table = {}
 
         # 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 = []
 
         # A list of tags we've generated; most class names.
         @tags = []
 
         # A graph for maintaining scope relationships.
         @scope_graph = Puppet::SimpleGraph.new
 
         # For maintaining the relationship between scopes and their resources.
         @catalog = Puppet::Node::Catalog.new(@node.name)
         @catalog.version = @parser.version
     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
     end
 
     # Store the catalog into the database.
     def store
         unless Puppet.features.rails?
             raise Puppet::Error,
                 "storeconfigs is enabled but rails is unavailable"
         end
 
         unless ActiveRecord::Base.connected?
             Puppet::Rails.connect
         end
 
         # We used to have hooks here for forking and saving, but I don't
         # think it's worth retaining at this point.
         store_to_active_record(@node, @resource_table.values)
     end
 
     # Do the actual storage.
     def store_to_active_record(node, resources)
         begin
             # We store all of the objects, even the collectable ones
             benchmark(:info, "Stored catalog for #{node.name}") do
                 Puppet::Rails::Host.transaction do
                     Puppet::Rails::Host.store(node, resources)
                 end
             end
         rescue => detail
             if Puppet[:trace]
                 puts detail.backtrace
             end
             Puppet.err "Could not store configs: %s" % detail.to_s
         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
         ary = @resource_table.find_all do |name, object|
             ! object.builtin? and ! object.evaluated?
         end.collect { |name, object| object }
 
         if ary.empty?
             return nil
         else
             return ary
         end
     end
 
     # Verify that the given resource isn't defined elsewhere.
     def verify_uniqueness(resource)
         # Short-curcuit the common case, 
         unless existing_resource = @resource_table[resource.ref]
             return true
         end
 
         if typeclass = Puppet::Type.type(resource.type) and ! typeclass.isomorphic?
             Puppet.info "Allowing duplicate %s" % typeclass.name
             return true
         end
 
         # Either it's a defined type, which are never
         # isomorphic, or it's a non-isomorphic type, so
         # we should throw an exception.
         msg = "Duplicate definition: %s is already defined" % resource.ref
 
         if existing_resource.file and existing_resource.line
             msg << " in file %s at line %s" %
                 [existing_resource.file, existing_resource.line]
         end
 
         if resource.line or resource.file
             msg << "; cannot redefine"
         end
 
         raise Puppet::ParseError.new(msg)
     end
 end
diff --git a/lib/puppet/parser/resource.rb b/lib/puppet/parser/resource.rb
index f8701578c..67428d5f3 100644
--- a/lib/puppet/parser/resource.rb
+++ b/lib/puppet/parser/resource.rb
@@ -1,449 +1,435 @@
 # A resource that we're managing.  This handles making sure that only subclasses
 # can set parameters.
 class Puppet::Parser::Resource
     require 'puppet/parser/resource/param'
     require 'puppet/parser/resource/reference'
     require 'puppet/util/tagging'
     include Puppet::Util
     include Puppet::Util::MethodHelper
     include Puppet::Util::Errors
     include Puppet::Util::Logging
     include Puppet::Util::Tagging
 
     attr_accessor :source, :line, :file, :scope, :rails_id
     attr_accessor :virtual, :override, :translated
 
     attr_reader :exported, :evaluated, :params
 
     # Determine whether the provided parameter name is a relationship parameter.
     def self.relationship_parameter?(name)
         unless defined?(@relationship_names)
             @relationship_names = Puppet::Type.relationship_params.collect { |p| p.name }
         end
         @relationship_names.include?(name)
     end
 
     # Proxy a few methods to our @ref object.
     [:builtin?, :type, :title].each do |method|
         define_method(method) do
             @ref.send(method)
         end
     end
 
     # Set up some boolean test methods
     [:exported, :translated, :override, :virtual, :evaluated].each do |method|
         newmeth = (method.to_s + "?").intern
         define_method(newmeth) do
             self.send(method)
         end
     end
 
     def [](param)
         param = symbolize(param)
         if param == :title
             return self.title
         end
         if @params.has_key?(param)
             @params[param].value
         else
             nil
         end
     end
 
     def builtin=(bool)
         @ref.builtin = bool
     end
 
     # Retrieve the associated definition and evaluate it.
     def evaluate
         if klass = @ref.definedtype
             finish()
             scope.compile.delete_resource(self)
             return klass.evaluate_code(self)
         elsif builtin?
             devfail "Cannot evaluate a builtin type"
         else
             self.fail "Cannot find definition %s" % self.type
         end
     ensure
         @evaluated = true
     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
-        add_overrides()
         add_defaults()
         add_metaparams()
         add_scope_tags()
         validate()
     end
 
     def initialize(options)
         # Set all of the options we can.
         options.each do |option, value|
             if respond_to?(option.to_s + "=")
                 send(option.to_s + "=", value)
                 options.delete(option)
             end
         end
 
         unless self.scope
             raise ArgumentError, "Resources require a scope"
         end
         @source ||= scope.source
 
         options = symbolize_options(options)
 
         # Set up our reference.
         if type = options[:type] and title = options[:title]
             options.delete(:type)
             options.delete(:title)
         else
             raise ArgumentError, "Resources require a type and title"
         end
 
         @ref = Reference.new(:type => type, :title => title, :scope => self.scope)
 
         @params = {}
 
         # Define all of the parameters
         if params = options[:params]
             options.delete(:params)
             params.each do |param|
                 set_parameter(param)
             end
         end
 
         # Throw an exception if we've got any arguments left to set.
         unless options.empty?
             raise ArgumentError, "Resources do not accept %s" % options.keys.collect { |k| k.to_s }.join(", ")
         end
 
         tag(@ref.type)
         tag(@ref.title) if valid_tag?(@ref.title.to_s)
     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.params.each do |name, param|
             override_parameter(param)
         end
     end
 
     # Modify this resource in the Rails database.  Poor design, yo.
     def modify_rails(db_resource)
         args = rails_args
         args.each do |param, value|
             db_resource[param] = value unless db_resource[param] == value
         end
 
         # Handle file specially
         if (self.file and  
             (!db_resource.file or db_resource.file != self.file))
             db_resource.file = self.file
         end
         
         updated_params = @params.inject({}) do |hash, ary|
             hash[ary[0].to_s] = ary[1]
             hash
         end
         
         db_resource.ar_hash_merge(db_resource.get_params_hash(db_resource.param_values), updated_params,
                                   :create => Proc.new { |name, parameter|
                                       parameter.to_rails(db_resource)
                                   }, :delete => Proc.new { |values|
                                       values.each { |value| db_resource.param_values.delete(value) }
                                   }, :modify => Proc.new { |db, mem|
                                       mem.modify_rails_values(db)
                                   })
         
         updated_tags = tags.inject({}) { |hash, tag| 
             hash[tag] = tag
             hash
         }
             
         db_resource.ar_hash_merge(db_resource.get_tag_hash(), 
                                   updated_tags,
                                   :create => Proc.new { |name, tag|
                                       db_resource.add_resource_tag(name)
                                   }, :delete => Proc.new { |tag|
                                       db_resource.resource_tags.delete(tag)
                                   }, :modify => Proc.new { |db, mem|
                                       # nothing here
                                   })
     end
 
     # Return the resource name, or the title if no name
     # was specified.
     def name
         unless defined? @name
             @name = self[:name] || self.title
         end
         @name
     end
 
     # This *significantly* reduces the number of calls to Puppet.[].
     def paramcheck?
         unless defined? @@paramcheck
             @@paramcheck = Puppet[:paramcheck]
         end
         @@paramcheck
     end
 
     # A temporary occasion, until I get paths in the scopes figured out.
     def path
         to_s
     end
 
     # Return the short version of our name.
     def ref
         @ref.to_s
     end
 
     def to_hash
         @params.inject({}) do |hash, ary|
             param = ary[1]
             # Skip "undef" values.
             if param.value != :undef
                 hash[param.name] = param.value
             end
             hash
         end
     end
 
     # Turn our parser resource into a Rails resource.  
     def to_rails(host)
         args = rails_args
 
         db_resource = host.resources.build(args)
 
         # Handle file specially
         db_resource.file = self.file
 
         db_resource.save
 
         @params.each { |name, param|
             param.to_rails(db_resource)
         }
         
         tags.each { |tag| db_resource.add_resource_tag(tag) }
 
         return db_resource
     end
 
     def to_s
         self.ref
     end
 
     # Translate our object to a transportable object.
     def to_trans
         return nil if virtual?
 
         if builtin?
             to_transobject
         else
             to_transbucket
         end
     end
 
     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.
         return bucket
     end
 
     def to_transobject
         # Now convert to a transobject
         obj = Puppet::TransObject.new(@ref.title, @ref.type)
         to_hash.each do |p, v|
             if v.is_a?(Reference)
                 v = v.to_ref
             elsif v.is_a?(Array)
                 v = v.collect { |av|
                     if av.is_a?(Reference)
                         av = av.to_ref
                     end
                     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.
             obj[p.to_s] = if v.is_a?(Array) and v.length == 1
                               v[0]
                           else
                               v
                           end
         end
 
         obj.file = self.file
         obj.line = self.line
 
         obj.tags = self.tags
 
         return obj
     end
     
     private
 
     # Add default values from our definition.
     def add_defaults
         scope.lookupdefaults(self.type).each do |name, param|
             unless @params.include?(name)
                 self.debug "Adding default for %s" % name
 
                 @params[name] = param
             end
         end
     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
         Puppet::Type.eachmetaparam do |name|
             # Skip metaparams that we already have defined, unless they're relationship metaparams.
             # LAK:NOTE Relationship metaparams get treated specially -- we stack them, instead of
             # overriding.
             next if @params[name] and not self.class.relationship_parameter?(name)
 
             # Skip metaparams for which we get no value.
             next unless val = scope.lookupvar(name.to_s, false) and val != :undefined
 
             # The default case: just set the value
             return set_parameter(name, val) unless @params[name]
 
             # For relationship params, though, join the values (a la #446).
             @params[name].value = [@params[name].value, val].flatten
         end
     end
 
-    # Add any overrides for this object.
-    def add_overrides
-        if overrides = scope.compile.resource_overrides(self)
-            overrides.each do |over|
-                self.merge(over)
-            end
-
-            # Remove the overrides, so that the configuration knows there
-            # are none left.
-            overrides.clear
-        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.
         (@params[param.name] = param and return) unless current = @params[param.name]
 
         # The parameter is already set.  Fail if they're not allowed to override it.
         unless param.source.child_of?(current.source)
             if Puppet[:trace]
                 puts caller
             end
             msg = "Parameter '%s' is already set on %s" % 
                 [param.name, self.to_s]
             if current.source.to_s != ""
                 msg += " by %s" % current.source
             end
             if current.file or current.line
                 fields = []
                 fields << current.file if current.file
                 fields << current.line.to_s if current.line
                 msg += " at %s" % 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 the new param instance here, not the old one,
         # so that the source is registered correctly for later overrides.
         param.value = [current.value, param.value].flatten if param.add
 
         @params[param.name] = param
     end
 
     # Verify that all passed parameters are valid.  This throws an error if
     #  there's a problem, so we don't have to worry about the return value.
     def paramcheck(param)
         param = param.to_s
         # Now make sure it's a valid argument to our class.  These checks
         # are organized in order of commonhood -- most types, it's a valid 
         # argument and paramcheck is enabled.
         if @ref.typeclass.validattr?(param)
             true
         elsif %w{name title}.include?(param) # always allow these
             true
         elsif paramcheck?
             self.fail Puppet::ParseError, "Invalid parameter '%s' for type '%s'" %
                     [param, @ref.type]
         end
     end
 
     def rails_args
         return [:type, :title, :line, :exported].inject({}) do |hash, param|
             # 'type' isn't a valid column name, so we have to use another name.
             to = (param == :type) ? :restype : param
             if value = self.send(param)
                 hash[to] = value 
             end
             hash
         end
     end
 
     # Define a parameter in our resource.
     def set_parameter(param, value = nil)
         if value
             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
 
         # And store it in our parameter hash.
         @params[param.name] = param
     end
 
     # Make sure the resource's parameters are all valid for the type.
     def validate
         @params.each do |name, param|
             # Make sure it's a valid parameter.
             paramcheck(name)
         end
     end
 end
diff --git a/lib/puppet/parser/resource/reference.rb b/lib/puppet/parser/resource/reference.rb
index 6e70d23b7..ea53b421a 100644
--- a/lib/puppet/parser/resource/reference.rb
+++ b/lib/puppet/parser/resource/reference.rb
@@ -1,85 +1,85 @@
 require 'puppet/resource_reference'
 
 # A reference to a resource.  Mostly just the type and title.
 class Puppet::Parser::Resource::Reference < Puppet::ResourceReference
     include Puppet::Util::MethodHelper
     include Puppet::Util::Errors
 
     attr_accessor :builtin, :file, :line, :scope
 
     # Are we a builtin type?
     def builtin?
         unless defined? @builtin
             if builtintype()
                 @builtin = true
             else
                 @builtin = false
             end
         end
 
         @builtin
     end
 
     def builtintype
         if t = Puppet::Type.type(self.type.downcase) and t.name != :component
             t
         else
             nil
         end
     end
 
     # Return the defined type for our obj.  This can return classes,
     # definitions or nodes.
     def definedtype
         unless defined? @definedtype
             case self.type
             when "Class": # look for host classes
                 if self.title == :main
                     tmp = @scope.findclass("")
                 else
                     tmp = @scope.findclass(self.title)
                 end
             when "Node": # look for node definitions
                 tmp = @scope.parser.nodes[self.title]
             else # normal definitions
                 # We have to swap these variables around so the errors are right.
                 tmp = @scope.finddefine(self.type)
             end
 
             if tmp
                 @definedtype = tmp
             else
-                fail Puppet::ParseError, "Could not find resource '%s'" % self
+                fail Puppet::ParseError, "Could not find resource type '%s'" % self.type
             end
         end
 
         @definedtype
     end
 
     def initialize(hash)
         set_options(hash)
         requiredopts(:type, :title)
     end
 
     def to_ref
         # We have to return different cases to provide backward compatibility
         # from 0.24.x to 0.23.x.
         if builtin?
             return [type.to_s.downcase, title.to_s]
         else
             return [type.to_s, title.to_s]
         end
     end
 
     def typeclass
         unless defined? @typeclass
             if tmp = builtintype || definedtype
                 @typeclass = tmp
             else
                 fail Puppet::ParseError, "Could not find type %s" % self.type
             end
         end
 
         @typeclass
     end
 end
diff --git a/spec/unit/parser/compile.rb b/spec/unit/parser/compile.rb
index 092bece0c..a72713360 100755
--- a/spec/unit/parser/compile.rb
+++ b/spec/unit/parser/compile.rb
@@ -1,281 +1,583 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe Puppet::Parser::Compile, " when compiling" do
-    before do
-        @node = stub 'node', :name => 'mynode'
-        @parser = stub 'parser', :version => "1.0"
+module CompileTesting
+    def setup
+        @node = Puppet::Node.new "testnode"
+        @parser = Puppet::Parser::Parser.new :environment => "development"
+
+        @scope = stub 'scope', :resource => stub("scope_resource"), :source => mock("source")
         @compile = Puppet::Parser::Compile.new(@node, @parser)
     end
+end
+
+describe Puppet::Parser::Compile, " when compiling" do
+    include CompileTesting
 
     def compile_methods
         [:set_node_parameters, :evaluate_main, :evaluate_ast_node, :evaluate_node_classes, :evaluate_generators, :fail_on_unevaluated,
             :finish, :store, :extract]
     end
 
     # Stub all of the main compile methods except the ones we're specifically interested in.
     def compile_stub(*except)
         (compile_methods - except).each { |m| @compile.stubs(m) }
     end
 
     it "should set node parameters as variables in the top scope" do
         params = {"a" => "b", "c" => "d"}
         @node.stubs(:parameters).returns(params)
         compile_stub(:set_node_parameters)
         @compile.compile
         @compile.topscope.lookupvar("a").should == "b"
         @compile.topscope.lookupvar("c").should == "d"
     end
 
     it "should evaluate any existing classes named in the node" do
         classes = %w{one two three four}
         main = stub 'main'
         one = stub 'one', :classname => "one"
         three = stub 'three', :classname => "three"
         @node.stubs(:name).returns("whatever")
         @node.stubs(:classes).returns(classes)
 
         @compile.expects(:evaluate_classes).with(classes, @compile.topscope)
-        @compile.send :evaluate_node_classes
+        @compile.class.publicize_methods(:evaluate_node_classes) { @compile.evaluate_node_classes }
     end
 
     it "should enable ast_nodes if the parser has any nodes" do
         @parser.expects(:nodes).returns(:one => :yay)
         @compile.ast_nodes?.should be_true
     end
 
     it "should disable ast_nodes if the parser has no nodes" do
         @parser.expects(:nodes).returns({})
         @compile.ast_nodes?.should be_false
     end
+
+    it "should evaluate the main class if it exists" do
+        compile_stub(:evaluate_main)
+        main_class = mock 'main_class'
+        main_class.expects(:evaluate_code).with { |r| r.is_a?(Puppet::Parser::Resource) }
+        @compile.topscope.expects(:source=).with(main_class)
+        @parser.stubs(:findclass).with("", "").returns(main_class)
+
+        @compile.compile
+    end
+
+    it "should evaluate any node classes" do
+        @node.stubs(:classes).returns(%w{one two three four})
+        @compile.expects(:evaluate_classes).with(%w{one two three four}, @compile.topscope)
+        @compile.send(:evaluate_node_classes)
+    end
+
+    it "should evaluate all added collections" do
+        colls = []
+        # And when the collections fail to evaluate.
+        colls << mock("coll1-false")
+        colls << mock("coll2-false")
+        colls.each { |c| c.expects(:evaluate).returns(false) }
+
+        @compile.add_collection(colls[0])
+        @compile.add_collection(colls[1])
+
+        compile_stub(:evaluate_generators)
+        @compile.compile
+    end
+
+    it "should ignore builtin resources" do
+        resource = stub 'builtin', :ref => "File[testing]", :builtin? => true
+
+        scope = stub 'scope', :resource => stub("scope_resource")
+        @compile.store_resource(scope, resource)
+        resource.expects(:evaluate).never
+        
+        @compile.compile
+    end
+
+    it "should evaluate unevaluated resources" do
+        resource = stub 'notevaluated', :ref => "File[testing]", :builtin? => false, :evaluated? => false
+        scope = stub 'scope', :resource => stub("scope_resource")
+        @compile.store_resource(scope, resource)
+
+        # We have to now mark the resource as evaluated
+        resource.expects(:evaluate).with { |*whatever| resource.stubs(:evaluated?).returns true }
+        
+        @compile.compile
+    end
+
+    it "should not evaluate already-evaluated resources" do
+        resource = stub 'already_evaluated', :ref => "File[testing]", :builtin? => false, :evaluated? => true
+        scope = stub 'scope', :resource => stub("scope_resource")
+        @compile.store_resource(scope, resource)
+        resource.expects(:evaluate).never
+        
+        @compile.compile
+    end
+
+    it "should evaluate unevaluated resources created by evaluating other resources" do
+        resource = stub 'notevaluated', :ref => "File[testing]", :builtin? => false, :evaluated? => false
+        scope = stub 'scope', :resource => stub("scope_resource")
+        @compile.store_resource(scope, resource)
+
+        resource2 = stub 'created', :ref => "File[other]", :builtin? => false, :evaluated? => false
+
+        # We have to now mark the resource as evaluated
+        resource.expects(:evaluate).with { |*whatever| resource.stubs(:evaluated?).returns(true); @compile.store_resource(scope, resource2) }
+        resource2.expects(:evaluate).with { |*whatever| resource2.stubs(:evaluated?).returns(true) }
+
+        
+        @compile.compile
+    end
+
+    it "should call finish() on all resources" do
+        # Add a resource that does respond to :finish
+        yep = stub "finisher", :ref => "File[finish]"
+        yep.expects(:respond_to?).with(:finish).returns(true)
+        yep.expects(:finish)
+
+        @compile.store_resource(@scope, yep)
+
+        # And one that does not
+        dnf = stub "dnf", :ref => "File[dnf]"
+        dnf.expects(:respond_to?).with(:finish).returns(false)
+
+        @compile.store_resource(@scope, dnf)
+
+        @compile.send(:finish)
+    end
+
+    it "should add resources that do not conflict with existing resources" do
+        resource = stub "noconflict", :ref => "File[yay]"
+        @compile.store_resource(@scope, resource)
+
+        @compile.catalog.should be_vertex(resource)
+    end
+
+    it "should not fail when conflicting resources are non-isormphic" do
+        type = stub 'faketype', :isomorphic? => false, :name => "mytype"
+        Puppet::Type.stubs(:type).with("mytype").returns(type)
+
+        resource1 = stub "iso1conflict", :ref => "Mytype[yay]", :type => "mytype"
+        resource2 = stub "iso2conflict", :ref => "Mytype[yay]", :type => "mytype"
+
+        @compile.store_resource(@scope, resource1)
+        lambda { @compile.store_resource(@scope, resource2) }.should_not raise_error
+    end
+
+    it "should fail to add resources that conflict with existing resources" do
+        type = stub 'faketype', :isomorphic? => true, :name => "mytype"
+        Puppet::Type.stubs(:type).with("mytype").returns(type)
+
+        resource1 = stub "iso1conflict", :ref => "Mytype[yay]", :type => "mytype", :file => "eh", :line => 0
+        resource2 = stub "iso2conflict", :ref => "Mytype[yay]", :type => "mytype", :file => "eh", :line => 0
+
+        @compile.store_resource(@scope, resource1)
+        lambda { @compile.store_resource(@scope, resource2) }.should raise_error(Puppet::ParseError)
+    end
+
+    it "should have a method for looking up resources" do
+        resource = stub 'resource', :ref => "Yay[foo]"
+        @compile.store_resource(@scope, resource)
+        @compile.findresource("Yay[foo]").should equal(resource)
+    end
+
+    it "should be able to look resources up by type and title" do
+        resource = stub 'resource', :ref => "Yay[foo]"
+        @compile.store_resource(@scope, resource)
+        @compile.findresource("Yay", "foo").should equal(resource)
+    end
 end
 
 describe Puppet::Parser::Compile, " when evaluating classes" do
-    before do
-        @node = stub 'node', :name => 'mynode'
-        @parser = stub 'parser', :version => "1.0"
-        @scope = stub 'scope', :source => mock("source")
-        @compile = Puppet::Parser::Compile.new(@node, @parser)
-    end
+    include CompileTesting
 
     it "should fail if there's no source listed for the scope" do
         scope = stub 'scope', :source => nil
         proc { @compile.evaluate_classes(%w{one two}, scope) }.should raise_error(Puppet::DevError)
     end
 
     it "should tag the catalog with the name of each not-found class" do
         @compile.catalog.expects(:tag).with("notfound")
         @scope.expects(:findclass).with("notfound").returns(nil)
         @compile.evaluate_classes(%w{notfound}, @scope)
     end
 end
 
 describe Puppet::Parser::Compile, " when evaluating collections" do
-    before do
-        @node = stub 'node', :name => 'mynode'
-        @parser = stub 'parser', :version => "1.0"
-        @scope = stub 'scope', :source => mock("source")
-        @compile = Puppet::Parser::Compile.new(@node, @parser)
-    end
+    include CompileTesting
 
     it "should evaluate each collection" do
         2.times { |i|
             coll = mock 'coll%s' % i
             @compile.add_collection(coll)
             
             # This is the hard part -- we have to emulate the fact that
             # collections delete themselves if they are done evaluating.
             coll.expects(:evaluate).with do
                 @compile.delete_collection(coll)
             end
         }
 
         @compile.class.publicize_methods(:evaluate_collections) { @compile.evaluate_collections }
     end
+
+    it "should not fail when there are unevaluated resource collections that do not refer to specific resources" do
+        coll = stub 'coll', :evaluate => false
+        coll.expects(:resources).returns(nil)
+
+        @compile.add_collection(coll)
+
+        lambda { @compile.compile }.should_not raise_error
+    end
+
+    it "should fail when there are unevaluated resource collections that refer to a specific resource" do
+        coll = stub 'coll', :evaluate => false
+        coll.expects(:resources).returns(:something)
+
+        @compile.add_collection(coll)
+
+        lambda { @compile.compile }.should raise_error(Puppet::ParseError)
+    end
+
+    it "should fail when there are unevaluated resource collections that refer to multiple specific resources" do
+        coll = stub 'coll', :evaluate => false
+        coll.expects(:resources).returns([:one, :two])
+
+        @compile.add_collection(coll)
+
+        lambda { @compile.compile }.should raise_error(Puppet::ParseError)
+    end
 end
 
 
 describe Puppet::Parser::Compile, " when evaluating found classes" do
-    before do
-        @node = stub 'node', :name => 'mynode'
-        @parser = stub 'parser', :version => "1.0"
-        @scope = stub 'scope', :source => mock("source")
-        @compile = Puppet::Parser::Compile.new(@node, @parser)
+    include CompileTesting
 
+    before do
         @class = stub 'class', :classname => "my::class"
         @scope.stubs(:findclass).with("myclass").returns(@class)
 
         @resource = stub 'resource', :ref => 'Class[myclass]'
     end
 
     it "should create a resource for each found class" do
         @compile.catalog.stubs(:tag)
 
         @compile.stubs :store_resource
 
         Puppet::Parser::Resource.expects(:new).with(:scope => @scope, :source => @scope.source, :title => "my::class", :type => "class").returns(@resource)
         @compile.evaluate_classes(%w{myclass}, @scope)
     end
 
     it "should store each created resource in the compile" do
         @compile.catalog.stubs(:tag)
 
         @compile.expects(:store_resource).with(@scope, @resource)
 
         Puppet::Parser::Resource.stubs(:new).returns(@resource)
         @compile.evaluate_classes(%w{myclass}, @scope)
     end
 
     it "should tag the catalog with the fully-qualified name of each found class" do
         @compile.catalog.expects(:tag).with("my::class")
 
         @compile.stubs(:store_resource)
 
         Puppet::Parser::Resource.stubs(:new).returns(@resource)
         @compile.evaluate_classes(%w{myclass}, @scope)
     end
 
     it "should not evaluate the resources created for found classes unless asked" do
         @compile.catalog.stubs(:tag)
 
         @compile.stubs(:store_resource)
         @resource.expects(:evaluate).never
 
         Puppet::Parser::Resource.stubs(:new).returns(@resource)
         @compile.evaluate_classes(%w{myclass}, @scope)
     end
 
     it "should immediately evaluate the resources created for found classes when asked" do
         @compile.catalog.stubs(:tag)
 
         @compile.stubs(:store_resource)
         @resource.expects(:evaluate)
 
         Puppet::Parser::Resource.stubs(:new).returns(@resource)
         @compile.evaluate_classes(%w{myclass}, @scope, false)
     end
 
     it "should skip classes that have already been evaluated" do
         @compile.catalog.stubs(:tag)
 
         @compile.expects(:class_scope).with(@class).returns("something")
 
         @compile.expects(:store_resource).never
 
         @resource.expects(:evaluate).never
 
         Puppet::Parser::Resource.expects(:new).never
         @compile.evaluate_classes(%w{myclass}, @scope, false)
     end
 
     it "should return the list of found classes" do
         @compile.catalog.stubs(:tag)
 
         @compile.stubs(:store_resource)
         @scope.stubs(:findclass).with("notfound").returns(nil)
 
         Puppet::Parser::Resource.stubs(:new).returns(@resource)
         @compile.evaluate_classes(%w{myclass notfound}, @scope).should == %w{myclass}
     end
 end
 
 describe Puppet::Parser::Compile, " when evaluating AST nodes with no AST nodes present" do
-    before do
-        @node = stub 'node', :name => "foo"
-        @parser = stub 'parser', :version => "1.0", :nodes => {}
-        @compile = Puppet::Parser::Compile.new(@node, @parser)
-    end
+    include CompileTesting
 
     it "should do nothing" do
         @compile.expects(:ast_nodes?).returns(false)
         @compile.parser.expects(:nodes).never
         Puppet::Parser::Resource.expects(:new).never
 
         @compile.send(:evaluate_ast_node)
     end
 end
 
 describe Puppet::Parser::Compile, " when evaluating AST nodes with AST nodes present" do
-    before do
-        @node = stub 'node', :name => "foo"
-        @parser = stub 'parser', :version => "1.0", :nodes => {}
-        @compile = Puppet::Parser::Compile.new(@node, @parser)
+    include CompileTesting
 
+    before do
         @nodes = mock 'node_hash'
         @compile.stubs(:ast_nodes?).returns(true)
         @compile.parser.stubs(:nodes).returns(@nodes)
 
         # Set some names for our test
         @node.stubs(:names).returns(%w{a b c})
         @nodes.stubs(:[]).with("a").returns(nil)
         @nodes.stubs(:[]).with("b").returns(nil)
         @nodes.stubs(:[]).with("c").returns(nil)
 
         # It should check this last, of course.
         @nodes.stubs(:[]).with("default").returns(nil)
     end
 
     it "should fail if the named node cannot be found" do
         proc { @compile.send(:evaluate_ast_node) }.should raise_error(Puppet::ParseError)
     end
 
     it "should create a resource for the first node class matching the node name" do
         node_class = stub 'node', :classname => "c"
         @nodes.stubs(:[]).with("c").returns(node_class)
 
         node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil
         Puppet::Parser::Resource.expects(:new).with { |args| args[:title] == "c" and args[:type] == "node" }.returns(node_resource)
 
         @compile.send(:evaluate_ast_node)
     end
 
     it "should match the default node if no matching node can be found" do
         node_class = stub 'node', :classname => "default"
         @nodes.stubs(:[]).with("default").returns(node_class)
 
         node_resource = stub 'node resource', :ref => "Node[default]", :evaluate => nil
         Puppet::Parser::Resource.expects(:new).with { |args| args[:title] == "default" and args[:type] == "node" }.returns(node_resource)
 
         @compile.send(:evaluate_ast_node)
     end
 
     it "should tag the catalog with the found node name" do
         node_class = stub 'node', :classname => "c"
         @nodes.stubs(:[]).with("c").returns(node_class)
 
         node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil
         Puppet::Parser::Resource.stubs(:new).returns(node_resource)
 
         @compile.catalog.expects(:tag).with("c")
         @compile.send(:evaluate_ast_node)
     end
 
     it "should evaluate the node resource immediately rather than using lazy evaluation" do
         node_class = stub 'node', :classname => "c"
         @nodes.stubs(:[]).with("c").returns(node_class)
 
         node_resource = stub 'node resource', :ref => "Node[c]"
         Puppet::Parser::Resource.stubs(:new).returns(node_resource)
 
         node_resource.expects(:evaluate)
 
         @compile.send(:evaluate_ast_node)
     end
 
     it "should set the node's scope as the top scope" do
         node_class = stub 'node', :classname => "c"
         @nodes.stubs(:[]).with("c").returns(node_class)
 
         node_resource = stub 'node resource', :ref => "Node[c]"
         Puppet::Parser::Resource.stubs(:new).returns(node_resource)
 
         # The #evaluate method normally does this.
         @compile.class_set(node_class.classname, :my_node_scope)
         node_resource.stubs(:evaluate)
 
         @compile.send(:evaluate_ast_node)
 
         @compile.topscope.should == :my_node_scope
     end
 end
+
+describe Puppet::Parser::Compile, " when initializing" do
+    include CompileTesting
+
+    it "should set its node attribute" do
+        @compile.node.should equal(@node)
+    end
+
+    it "should set its parser attribute" do
+        @compile.parser.should equal(@parser)
+    end
+
+    it "should detect when ast nodes are absent" do
+        @compile.ast_nodes?.should be_false
+    end
+
+    it "should detect when ast nodes are present" do
+        @parser.nodes["testing"] = "yay"
+        @compile.ast_nodes?.should be_true
+    end
+end
+
+describe Puppet::Parser::Compile do
+    include CompileTesting
+
+    it "should be able to store references to class scopes" do
+        lambda { @compile.class_set "myname", "myscope" }.should_not raise_error
+    end
+
+    it "should be able to retrieve class scopes by name" do
+        @compile.class_set "myname", "myscope"
+        @compile.class_scope("myname").should == "myscope"
+    end
+
+    it "should be able to retrieve class scopes by object" do
+        klass = mock 'ast_class'
+        klass.expects(:classname).returns("myname")
+        @compile.class_set "myname", "myscope"
+        @compile.class_scope(klass).should == "myscope"
+    end
+
+    it "should be able to return a class list containing all set classes" do
+        @compile.class_set "", "empty"
+        @compile.class_set "one", "yep"
+        @compile.class_set "two", "nope"
+
+        @compile.classlist.sort.should == %w{one two}.sort
+    end
+end
+
+describe Puppet::Parser::Compile, "when managing scopes" do
+    include CompileTesting
+
+    it "should create a top scope" do
+        @compile.topscope.should be_instance_of(Puppet::Parser::Scope)
+    end
+
+    it "should be able to create new scopes" do
+        @compile.newscope(@compile.topscope).should be_instance_of(Puppet::Parser::Scope)
+    end
+
+    it "should correctly set the level of newly created scopes" do
+        @compile.newscope(@compile.topscope, :level => 5).level.should == 5
+    end
+
+    it "should set the parent scope of the new scope to be the passed-in parent" do
+        scope = mock 'scope'
+        newscope = @compile.newscope(scope)
+
+        @compile.parent(newscope).should equal(scope)
+    end
+end
+
+describe Puppet::Parser::Compile, "when storing compiled resources" do
+    include CompileTesting
+
+    it "should store the resources" do
+        Puppet.features.expects(:rails?).returns(true)
+        Puppet::Rails.expects(:connect)
+
+        resource_table = mock 'resources'
+        resource_table.expects(:values).returns(:resources)
+        @compile.instance_variable_set("@resource_table", resource_table)
+        @compile.expects(:store_to_active_record).with(@node, :resources)
+        @compile.send(:store)
+    end
+
+    it "should store to active_record" do
+        @node.expects(:name).returns("myname")
+        Puppet::Rails::Host.stubs(:transaction).yields
+        Puppet::Rails::Host.expects(:store).with(@node, :resources)
+        @compile.send(:store_to_active_record, @node, :resources)
+    end
+end
+
+describe Puppet::Parser::Compile, "when managing resource overrides" do
+    include CompileTesting
+
+    before do
+        @override = stub 'override', :ref => "My[ref]"
+        @resource = stub 'resource', :ref => "My[ref]", :builtin? => true
+    end
+
+    it "should be able to store overrides" do
+        lambda { @compile.store_override(@override) }.should_not raise_error
+    end
+
+    it "should apply overrides to the appropriate resources" do
+        @compile.store_resource(@scope, @resource)
+        @resource.expects(:merge).with(@override)
+
+        @compile.store_override(@override)
+
+        @compile.compile
+    end
+
+    it "should accept overrides before the related resource has been created" do
+        @resource.expects(:merge).with(@override)
+
+        # First store the override
+        @compile.store_override(@override)
+
+        # Then the resource
+        @compile.store_resource(@scope, @resource)
+
+        # And compile, so they get resolved
+        @compile.compile
+    end
+
+    it "should fail if the compile is finished and resource overrides have not been applied" do
+        @compile.store_override(@override)
+
+        lambda { @compile.compile }.should raise_error(Puppet::ParseError)
+    end
+end
+
+# #620 - Nodes and classes should conflict, else classes don't get evaluated
+describe Puppet::Parser::Compile, "when evaluating nodes and classes with the same name (#620)" do
+    include CompileTesting
+
+    before do
+        @node = stub :nodescope? => true
+        @class = stub :nodescope? => false
+    end
+
+    it "should fail if a node already exists with the same name as the class being evaluated" do
+        @compile.class_set("one", @node)
+        lambda { @compile.class_set("one", @class) }.should raise_error(Puppet::ParseError)
+    end
+
+    it "should fail if a class already exists with the same name as the node being evaluated" do
+        @compile.class_set("one", @class)
+        lambda { @compile.class_set("one", @node) }.should raise_error(Puppet::ParseError)
+    end
+end
diff --git a/test/language/resource.rb b/test/language/resource.rb
index 3aa9dcf6a..f129023eb 100755
--- a/test/language/resource.rb
+++ b/test/language/resource.rb
@@ -1,492 +1,459 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppettest'
 require 'puppettest/resourcetesting'
 
 class TestResource < PuppetTest::TestCase
 	include PuppetTest
     include PuppetTest::ParserTesting
     include PuppetTest::ResourceTesting
     Parser = Puppet::Parser
     AST = Parser::AST
     Resource = Puppet::Parser::Resource
     Reference = Puppet::Parser::Resource::Reference
 
     def setup
         super
         Puppet[:trace] = false
     end
 
     def teardown
         mocha_verify
     end
 
     def test_initialize
         args = {:type => "resource", :title => "testing",
             :scope => mkscope}
         # Check our arg requirements
         args.each do |name, value|
             try = args.dup
             try.delete(name)
             assert_raise(ArgumentError, "Did not fail when %s was missing" % name) do
                 Parser::Resource.new(try)
             end
         end
 
         res = nil
         assert_nothing_raised do
             res = Parser::Resource.new(args)
         end
 
         ref = res.instance_variable_get("@ref")
         assert_equal("Resource", ref.type, "did not set resource type")
         assert_equal("testing", ref.title, "did not set resource title")
     end
 
     def test_merge
         res = mkresource
         other = mkresource
 
         # First try the case where the resource is not allowed to override
         res.source = "source1"
         other.source = "source2"
         other.source.expects(:child_of?).with("source1").returns(false)
         assert_raise(Puppet::ParseError, "Allowed unrelated resources to override") do
             res.merge(other)
         end
 
         # Next try it when the sources are equal.
         res.source = "source3"
         other.source = res.source
         other.source.expects(:child_of?).with("source3").never
         params = {:a => :b, :c => :d}
         other.expects(:params).returns(params)
         res.expects(:override_parameter).with(:b)
         res.expects(:override_parameter).with(:d)
         res.merge(other)
 
         # And then parentage is involved
         other = mkresource
         res.source = "source3"
         other.source = "source4"
         other.source.expects(:child_of?).with("source3").returns(true)
         params = {:a => :b, :c => :d}
         other.expects(:params).returns(params)
         res.expects(:override_parameter).with(:b)
         res.expects(:override_parameter).with(:d)
         res.merge(other)
     end
 
     # the [] method
     def test_array_accessors
         res = mkresource
         params = res.instance_variable_get("@params")
         assert_nil(res[:missing], "Found a missing parameter somehow")
         params[:something] = stub(:value => "yay")
         assert_equal("yay", res[:something], "Did not correctly call value on the parameter")
 
         res.expects(:title).returns(:mytitle)
         assert_equal(:mytitle, res[:title], "Did not call title when asked for it as a param")
     end
 
     # Make sure any defaults stored in the scope get added to our resource.
     def test_add_defaults
         res = mkresource
         params = res.instance_variable_get("@params")
         params[:a] = :b
         res.scope.expects(:lookupdefaults).with(res.type).returns(:a => :replaced, :c => :d)
         res.expects(:debug)
 
         res.send(:add_defaults)
         assert_equal(:d, params[:c], "Did not set default")
         assert_equal(:b, params[:a], "Replaced parameter with default")
     end
 
     def test_finish
         res = mkresource
-        res.expects(:add_overrides)
         res.expects(:add_defaults)
         res.expects(:add_metaparams)
         res.expects(:validate)
         res.finish
     end
 
     # Make sure we paramcheck our params
     def test_validate
         res = mkresource
         params = res.instance_variable_get("@params")
         params[:one] = :two
         params[:three] = :four
         res.expects(:paramcheck).with(:one)
         res.expects(:paramcheck).with(:three)
         res.send(:validate)
     end
 
     def test_override_parameter
         res = mkresource
         params = res.instance_variable_get("@params")
 
         # There are three cases, with the second having two options:
 
         # No existing parameter.
         param = stub(:name => "myparam")
         res.send(:override_parameter, param)
         assert_equal(param, params["myparam"], "Override was not added to param list")
 
         # An existing parameter that we can override.
         source = stub(:child_of? => true)
         # Start out without addition
         params["param2"] = stub(:source => :whatever)
         param = stub(:name => "param2", :source => source, :add => false)
         res.send(:override_parameter, param)
         assert_equal(param, params["param2"], "Override was not added to param list")
 
         # Try with addition.
         params["param2"] = stub(:value => :a, :source => :whatever)
         param = stub(:name => "param2", :source => source, :add => true, :value => :b)
         param.expects(:value=).with([:a, :b])
         res.send(:override_parameter, param)
         assert_equal(param, params["param2"], "Override was not added to param list")
 
         # And finally, make sure we throw an exception when the sources aren't related
         source = stub(:child_of? => false)
         params["param2"] = stub(:source => :whatever, :file => :f, :line => :l)
         old = params["param2"]
         param = stub(:name => "param2", :source => source, :file => :f, :line => :l)
         assert_raise(Puppet::ParseError, "Did not fail when params conflicted") do
             res.send(:override_parameter, param)
         end
         assert_equal(old, params["param2"], "Param was replaced irrespective of conflict")
     end
 
     def test_set_parameter
         res = mkresource
         params = res.instance_variable_get("@params")
 
         # First test the simple case:  It's already a parameter
         param = mock('param')
         param.expects(:is_a?).with(Resource::Param).returns(true)
         param.expects(:name).returns("pname")
         res.send(:set_parameter, param)
         assert_equal(param, params["pname"], "Parameter was not added to hash")
 
         # Now the case where there's no value but it's not a param
         param = mock('param')
         param.expects(:is_a?).with(Resource::Param).returns(false)
         assert_raise(ArgumentError, "Did not fail when a non-param was passed") do
             res.send(:set_parameter, param)
         end
 
         # and the case where a value is passed in
         param = stub :name => "pname", :value => "whatever"
         Resource::Param.expects(:new).with(:name => "pname", :value => "myvalue", :source => res.source).returns(param)
         res.send(:set_parameter, "pname", "myvalue")
         assert_equal(param, params["pname"], "Did not put param in hash")
     end
 
     def test_paramcheck
         # There are three cases here:
 
         # It's a valid parameter
         res = mkresource
         ref = mock('ref')
         res.instance_variable_set("@ref", ref)
         klass = mock("class")
         ref.expects(:typeclass).returns(klass).times(4)
         klass.expects(:validattr?).with("good").returns(true)
         assert(res.send(:paramcheck, :good), "Did not allow valid param")
 
         # It's name or title
         klass.expects(:validattr?).with("name").returns(false)
         assert(res.send(:paramcheck, :name), "Did not allow name")
         klass.expects(:validattr?).with("title").returns(false)
         assert(res.send(:paramcheck, :title), "Did not allow title")
 
         # It's not actually allowed
         klass.expects(:validattr?).with("other").returns(false)
         res.expects(:fail)
         ref.expects(:type)
         res.send(:paramcheck, :other)
     end
 
     def test_to_transobject
         # First try translating a builtin resource.  Make sure we use some references
         # and arrays, to make sure they translate correctly.
         source = mock("source")
         scope = mkscope
         scope.stubs(:tags).returns([])
         refs = []
         4.times { |i| refs << Puppet::Parser::Resource::Reference.new(:title => "file%s" % i, :type => "file") }
         res = Parser::Resource.new :type => "file", :title => "/tmp",
             :source => source, :scope => scope,
             :params => paramify(source, :owner => "nobody", :group => %w{you me},
             :require => refs[0], :ignore => %w{svn},
             :subscribe => [refs[1], refs[2]], :notify => [refs[3]])
 
         obj = nil
         assert_nothing_raised do
             obj = res.to_trans
         end
 
         assert_instance_of(Puppet::TransObject, obj)
 
         assert_equal(obj.type, res.type.downcase)
         assert_equal(obj.name, res.title)
 
         # TransObjects use strings, resources use symbols
         assert_equal("nobody", obj["owner"], "Single-value string was not passed correctly")
         assert_equal(%w{you me}, obj["group"], "Array of strings was not passed correctly")
         assert_equal("svn", obj["ignore"], "Array with single string was not turned into single value")
         assert_equal(["file", refs[0].title], obj["require"], "Resource reference was not passed correctly")
         assert_equal([["file", refs[1].title], ["file", refs[2].title]], obj["subscribe"], "Array of resource references was not passed correctly")
         assert_equal(["file", refs[3].title], obj["notify"], "Array with single resource reference was not turned into single value")
     end
 
     # FIXME This isn't a great test, but I need to move on.
     def test_to_transbucket
         bucket = mock("transbucket")
         source = mock("source")
         scope = mkscope
         res = Parser::Resource.new :type => "mydefine", :title => "yay",
             :source => source, :scope => scope
 
 
         result = res.to_trans
         assert_equal("yay", result.name, "did not set bucket name correctly")
         assert_equal("Mydefine", result.type, "did not set bucket type correctly")
     end
 
     def test_evaluate
         # First try the most common case, we're not a builtin type.
         res = mkresource
         ref = res.instance_variable_get("@ref")
         type = mock("type")
         ref.expects(:definedtype).returns(type)
         res.expects(:finish)
         res.scope = mock("scope")
         config = mock("config")
         res.scope.expects(:compile).returns(config)
         config.expects(:delete_resource).with(res)
 
         type.expects(:evaluate_code).with(res)
 
         res.evaluate
     end
 
-    def test_add_overrides
-        # Try it with nil
-        res = mkresource
-        res.scope = mock('scope')
-        config = mock("config")
-        res.scope.expects(:compile).returns(config)
-        config.expects(:resource_overrides).with(res).returns(nil)
-        res.expects(:merge).never
-        res.send(:add_overrides)
-
-        # And an empty array
-        res = mkresource
-        res.scope = mock('scope')
-        config = mock("config")
-        res.scope.expects(:compile).returns(config)
-        config.expects(:resource_overrides).with(res).returns([])
-        res.expects(:merge).never
-        res.send(:add_overrides)
-
-        # And with some overrides
-        res = mkresource
-        res.scope = mock('scope')
-        config = mock("config")
-        res.scope.expects(:compile).returns(config)
-        returns = %w{a b}
-        config.expects(:resource_overrides).with(res).returns(returns)
-        res.expects(:merge).with("a")
-        res.expects(:merge).with("b")
-        res.send(:add_overrides)
-        assert(returns.empty?, "Did not clear overrides")
-    end
-
     def test_proxymethods
         res = Parser::Resource.new :type => "evaltest", :title => "yay",
             :source => mock("source"), :scope => mkscope
 
         assert_equal("Evaltest", res.type)
         assert_equal("yay", res.title)
         assert_equal(false, res.builtin?)
     end
 
     def test_reference_conversion
         # First try it as a normal string
         ref = Parser::Resource::Reference.new(:type => "file", :title => "/tmp/ref1")
 
         # Now create an obj that uses it
         res = mkresource :type => "file", :title => "/tmp/resource",
             :params => {:require => ref}
         res.scope = mkscope
 
         trans = nil
         assert_nothing_raised do
             trans = res.to_trans
         end
 
         assert_instance_of(Array, trans["require"])
         assert_equal(["file", "/tmp/ref1"], trans["require"])
 
         # Now try it when using an array of references.
         two = Parser::Resource::Reference.new(:type => "file", :title => "/tmp/ref2")
         res = mkresource :type => "file", :title => "/tmp/resource2",
             :params => {:require => [ref, two]}
         res.scope = mkscope
 
         trans = nil
         assert_nothing_raised do
             trans = res.to_trans
         end
 
         assert_instance_of(Array, trans["require"][0])
         trans["require"].each do |val|
             assert_instance_of(Array, val)
             assert_equal("file", val[0])
             assert(val[1] =~ /\/tmp\/ref[0-9]/,
                 "Was %s instead of the file name" % val[1])
         end
     end
 
     # This is a bit of a weird one -- the user should not actually know
     # that components exist, so we want references to act like they're not
     # builtin
     def test_components_are_not_builtin
         ref = Parser::Resource::Reference.new(:type => "component", :title => "yay")
 
         assert_nil(ref.builtintype, "Definition was considered builtin")
     end
 
     # The second part of #539 - make sure resources pass the arguments
     # correctly.
     def test_title_with_definitions
         parser = mkparser
         define = parser.newdefine "yayness",
             :code => resourcedef("file", "/tmp",
                 "owner" => varref("name"), "mode" => varref("title"))
 
 
         klass = parser.findclass("", "")
         should = {:name => :owner, :title => :mode}
         [
         {:name => "one", :title => "two"},
         {:title => "three"},
         ].each do |hash|
             config = mkcompile parser
             args = {:type => "yayness", :title => hash[:title],
                 :source => klass, :scope => config.topscope}
             if hash[:name]
                 args[:params] = {:name => hash[:name]}
             else
                 args[:params] = {} # override the defaults
             end
 
             res = nil
             assert_nothing_raised("Could not create res with %s" % hash.inspect) do
                 res = mkresource(args)
             end
             assert_nothing_raised("Could not eval res with %s" % hash.inspect) do
                 res.evaluate
             end
 
             made = config.topscope.findresource("File[/tmp]")
             assert(made, "Did not create resource with %s" % hash.inspect)
             should.each do |orig, param|
                 assert_equal(hash[orig] || hash[:title], made[param],
                     "%s was not set correctly with %s" % [param, hash.inspect])
             end
         end
     end
 
     # part of #629 -- the undef keyword.  Make sure 'undef' params get skipped.
     def test_undef_and_to_hash
         res = mkresource :type => "file", :title => "/tmp/testing",
             :source => mock("source"), :scope => mkscope,
             :params => {:owner => :undef, :mode => "755"}
 
         hash = nil
         assert_nothing_raised("Could not convert resource with undef to hash") do
             hash = res.to_hash
         end
 
         assert_nil(hash[:owner], "got a value for an undef parameter")
     end
 
     # #643 - Make sure virtual defines result in virtual resources
     def test_virtual_defines
         parser = mkparser
         define = parser.newdefine("yayness",
             :code => resourcedef("file", varref("name"),
                 "mode" => "644"))
 
         config = mkcompile(parser)
 
         res = mkresource :type => "yayness", :title => "foo", :params => {}, :scope => config.topscope
         res.virtual = true
 
         result = nil
         assert_nothing_raised("Could not evaluate defined resource") do
             result = res.evaluate
         end
 
         scope = res.scope
         newres = scope.findresource("File[foo]")
         assert(newres, "Could not find resource")
 
         assert(newres.virtual?, "Virtual defined resource generated non-virtual resources")
 
         # Now try it with exported resources
         res = mkresource :type => "yayness", :title => "bar", :params => {}, :scope => config.topscope
         res.exported = true
 
         result = nil
         assert_nothing_raised("Could not evaluate exported resource") do
             result = res.evaluate
         end
 
         scope = res.scope
         newres = scope.findresource("File[bar]")
         assert(newres, "Could not find resource")
 
         assert(newres.exported?, "Exported defined resource generated non-exported resources")
         assert(newres.virtual?, "Exported defined resource generated non-virtual resources")
     end
 
     # Make sure tags behave appropriately.
     def test_tags
         scope_resource = stub 'scope_resource', :tags => %w{srone srtwo}
         scope = stub 'scope', :resource => scope_resource
         resource = Puppet::Parser::Resource.new(:type => "file", :title => "yay", :scope => scope, :source => mock('source'))
 
         # Make sure we get the type and title
         %w{yay file}.each do |tag|
             assert(resource.tags.include?(tag), "Did not tag resource with %s" % tag)
         end
 
         # make sure we can only set legal tags
         ["an invalid tag", "-anotherinvalid", "bad*tag"].each do |tag|
             assert_raise(Puppet::ParseError, "Tag #{tag} was considered valid") do
                 resource.tag tag
             end
         end
 
         # make sure good tags make it through.
         tags = %w{good-tag yaytag GoodTag another_tag a ab A}
         tags.each do |tag|
             assert_nothing_raised("Tag #{tag} was considered invalid") do
                 resource.tag tag
             end
         end
 
         # make sure we get each of them.
         ptags = resource.tags
         tags.each do |tag|
             assert(ptags.include?(tag.downcase), "missing #{tag}")
         end
     end
 end