diff --git a/lib/puppet/parser/compiler.rb b/lib/puppet/parser/compiler.rb
index 132ec15db..70cd6e11a 100644
--- a/lib/puppet/parser/compiler.rb
+++ b/lib/puppet/parser/compiler.rb
@@ -1,472 +1,471 @@
 #  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::Compiler
     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
 
     # 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)
         # Note that this will fail if the resource is not unique.
         @catalog.add_resource(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
 
     # 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? != scope.nodescope?
                 raise Puppet::ParseError, "Cannot have classes, nodes, or definitions with the same name"
             else
                 raise Puppet::DevError, "Somehow evaluated %s %s twice" % [ existing.nodescope? ? "node" : "class", name]
             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
 
     # 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()
 
         evaluate_main()
 
         evaluate_ast_node()
 
         evaluate_node_classes()
 
         evaluate_generators()
 
         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
 
     # 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)
 
                 resource = klass.evaluate(scope)
 
                 # If they've disabled lazy evaluation (which the :include function does),
                 # then evaluate our resource immediately.
                 resource.evaluate unless lazy_evaluate
                 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(*args)
         @catalog.resource(*args)
     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, "Compiler 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[:compiler] = 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
         @catalog.vertices
     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 = astnode.evaluate(topscope)
 
         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
                 evaluated = false
                 ary.each do |resource|
                     if not resource.virtual?
                         resource.evaluate
                         evaluated = true
                     end
                 end
                 # If we evaluated, let the loop know.
                 return evaluated
             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_resource(@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
-        @catalog.resources.each do |name|
-            resource = @catalog.resource(name)
-
+        #@catalog.resources.each do |name|
+        @catalog.vertices.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
     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(:compiler => 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 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 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, @catalog.vertices)
     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 = @catalog.vertices.reject { |resource| resource.builtin? or resource.evaluated?  }
 
         if ary.empty?
             return nil
         else
             return ary
         end
     end
 end
diff --git a/spec/unit/parser/compiler.rb b/spec/unit/parser/compiler.rb
index 9980f2c6a..ab430da62 100755
--- a/spec/unit/parser/compiler.rb
+++ b/spec/unit/parser/compiler.rb
@@ -1,532 +1,532 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Parser::Compiler do
     before :each do
         @node = Puppet::Node.new "testnode"
         @parser = Puppet::Parser::Parser.new :environment => "development"
 
-        @scope_resource = stub 'scope_resource', :builtin? => true
+        @scope_resource = stub 'scope_resource', :builtin? => true, :finish => nil, :ref => 'Class[main]'
         @scope = stub 'scope', :resource => @scope_resource, :source => mock("source")
         @compiler = Puppet::Parser::Compiler.new(@node, @parser)
     end
 
     describe Puppet::Parser::Compiler do
 
         it "should be able to store references to class scopes" do
             lambda { @compiler.class_set "myname", "myscope" }.should_not raise_error
         end
 
         it "should be able to retrieve class scopes by name" do
             @compiler.class_set "myname", "myscope"
             @compiler.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")
             @compiler.class_set "myname", "myscope"
             @compiler.class_scope(klass).should == "myscope"
         end
 
         it "should be able to return a class list containing all set classes" do
             @compiler.class_set "", "empty"
             @compiler.class_set "one", "yep"
             @compiler.class_set "two", "nope"
 
             @compiler.classlist.sort.should == %w{one two}.sort
         end
     end
 
     describe Puppet::Parser::Compiler, " when initializing" do
 
         it "should set its node attribute" do
             @compiler.node.should equal(@node)
         end
 
         it "should set its parser attribute" do
             @compiler.parser.should equal(@parser)
         end
 
         it "should detect when ast nodes are absent" do
             @compiler.ast_nodes?.should be_false
         end
 
         it "should detect when ast nodes are present" do
             @parser.nodes["testing"] = "yay"
             @compiler.ast_nodes?.should be_true
         end
     end
 
     describe Puppet::Parser::Compiler, "when managing scopes" do
 
         it "should create a top scope" do
             @compiler.topscope.should be_instance_of(Puppet::Parser::Scope)
         end
 
         it "should be able to create new scopes" do
             @compiler.newscope(@compiler.topscope).should be_instance_of(Puppet::Parser::Scope)
         end
 
         it "should correctly set the level of newly created scopes" do
             @compiler.newscope(@compiler.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 = @compiler.newscope(scope)
 
             @compiler.parent(newscope).should equal(scope)
         end
     end
 
     describe Puppet::Parser::Compiler, " when compiling" do
 
         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| @compiler.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)
             @compiler.compile
             @compiler.topscope.lookupvar("a").should == "b"
             @compiler.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)
 
             @compiler.expects(:evaluate_classes).with(classes, @compiler.topscope)
             @compiler.class.publicize_methods(:evaluate_node_classes) { @compiler.evaluate_node_classes }
         end
 
         it "should enable ast_nodes if the parser has any nodes" do
             @parser.expects(:nodes).returns(:one => :yay)
             @compiler.ast_nodes?.should be_true
         end
 
         it "should disable ast_nodes if the parser has no nodes" do
             @parser.expects(:nodes).returns({})
             @compiler.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) }
             @compiler.topscope.expects(:source=).with(main_class)
             @parser.stubs(:findclass).with("", "").returns(main_class)
 
             @compiler.compile
         end
 
         it "should evaluate any node classes" do
             @node.stubs(:classes).returns(%w{one two three four})
             @compiler.expects(:evaluate_classes).with(%w{one two three four}, @compiler.topscope)
             @compiler.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) }
 
             @compiler.add_collection(colls[0])
             @compiler.add_collection(colls[1])
 
             compile_stub(:evaluate_generators)
             @compiler.compile
         end
 
         it "should ignore builtin resources" do
             resource = stub 'builtin', :ref => "File[testing]", :builtin? => true
 
             @compiler.add_resource(@scope, resource)
             resource.expects(:evaluate).never
         
             @compiler.compile
         end
 
         it "should evaluate unevaluated resources" do
             resource = stub 'notevaluated', :ref => "File[testing]", :builtin? => false, :evaluated? => false, :virtual? => false
             @compiler.add_resource(@scope, resource)
 
             # We have to now mark the resource as evaluated
             resource.expects(:evaluate).with { |*whatever| resource.stubs(:evaluated?).returns true }
         
             @compiler.compile
         end
 
         it "should not evaluate already-evaluated resources" do
             resource = stub 'already_evaluated', :ref => "File[testing]", :builtin? => false, :evaluated? => true, :virtual? => false
             @compiler.add_resource(@scope, resource)
             resource.expects(:evaluate).never
         
             @compiler.compile
         end
 
         it "should evaluate unevaluated resources created by evaluating other resources" do
             resource = stub 'notevaluated', :ref => "File[testing]", :builtin? => false, :evaluated? => false, :virtual? => false
             @compiler.add_resource(@scope, resource)
 
             resource2 = stub 'created', :ref => "File[other]", :builtin? => false, :evaluated? => false, :virtual? => false
 
             # We have to now mark the resource as evaluated
             resource.expects(:evaluate).with { |*whatever| resource.stubs(:evaluated?).returns(true); @compiler.add_resource(@scope, resource2) }
             resource2.expects(:evaluate).with { |*whatever| resource2.stubs(:evaluated?).returns(true) }
 
         
             @compiler.compile
         end
 
         it "should call finish() on all resources" do
             # Add a resource that does respond to :finish
             resource = Puppet::Parser::Resource.new :scope => @scope, :type => "file", :title => "finish"
             resource.expects(:finish)
 
             @compiler.add_resource(@scope, resource)
 
             # And one that does not
             dnf = stub "dnf", :ref => "File[dnf]"
 
             @compiler.add_resource(@scope, dnf)
 
             @compiler.send(:finish)
         end
 
         it "should add resources that do not conflict with existing resources" do
             resource = stub "noconflict", :ref => "File[yay]"
             @compiler.add_resource(@scope, resource)
 
             @compiler.catalog.should be_vertex(resource)
         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
 
             @compiler.add_resource(@scope, resource1)
             lambda { @compiler.add_resource(@scope, resource2) }.should raise_error(ArgumentError)
         end
 
         it "should have a method for looking up resources" do
             resource = stub 'resource', :ref => "Yay[foo]"
             @compiler.add_resource(@scope, resource)
             @compiler.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]"
             @compiler.add_resource(@scope, resource)
             @compiler.findresource("Yay", "foo").should equal(resource)
         end
 
         it "should not evaluate virtual defined resources" do
             resource = stub 'notevaluated', :ref => "File[testing]", :builtin? => false, :evaluated? => false, :virtual? => true
             @compiler.add_resource(@scope, resource)
 
             resource.expects(:evaluate).never
         
             @compiler.compile
         end
     end
 
     describe Puppet::Parser::Compiler, " when evaluating collections" do
 
         it "should evaluate each collection" do
             2.times { |i|
                 coll = mock 'coll%s' % i
                 @compiler.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
                     @compiler.delete_collection(coll)
                 end
             }
 
             @compiler.class.publicize_methods(:evaluate_collections) { @compiler.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)
 
             @compiler.add_collection(coll)
 
             lambda { @compiler.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)
 
             @compiler.add_collection(coll)
 
             lambda { @compiler.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])
 
             @compiler.add_collection(coll)
 
             lambda { @compiler.compile }.should raise_error(Puppet::ParseError)
         end
     end
 
     describe Puppet::Parser::Compiler, "when told to evaluate missing classes" do
 
         it "should fail if there's no source listed for the scope" do
             scope = stub 'scope', :source => nil
             proc { @compiler.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
             @compiler.catalog.expects(:tag).with("notfound")
             @scope.expects(:findclass).with("notfound").returns(nil)
             @compiler.evaluate_classes(%w{notfound}, @scope)
         end
     end
 
     describe Puppet::Parser::Compiler, " when evaluating found classes" do
 
         before do
             @class = stub 'class', :classname => "my::class"
             @scope.stubs(:findclass).with("myclass").returns(@class)
 
             @resource = stub 'resource', :ref => "Class[myclass]"
         end
 
         it "should evaluate each class" do
             @compiler.catalog.stubs(:tag)
 
             @class.expects(:evaluate).with(@scope)
 
             @compiler.evaluate_classes(%w{myclass}, @scope)
         end
 
         it "should not evaluate the resources created for found classes unless asked" do
             @compiler.catalog.stubs(:tag)
 
             @resource.expects(:evaluate).never
 
             @class.expects(:evaluate).returns(@resource)
 
             @compiler.evaluate_classes(%w{myclass}, @scope)
         end
 
         it "should immediately evaluate the resources created for found classes when asked" do
             @compiler.catalog.stubs(:tag)
 
             @resource.expects(:evaluate)
             @class.expects(:evaluate).returns(@resource)
 
             @compiler.evaluate_classes(%w{myclass}, @scope, false)
         end
 
         it "should skip classes that have already been evaluated" do
             @compiler.catalog.stubs(:tag)
 
             @compiler.expects(:class_scope).with(@class).returns("something")
 
             @compiler.expects(:add_resource).never
 
             @resource.expects(:evaluate).never
 
             Puppet::Parser::Resource.expects(:new).never
             @compiler.evaluate_classes(%w{myclass}, @scope, false)
         end
 
         it "should return the list of found classes" do
             @compiler.catalog.stubs(:tag)
 
             @compiler.stubs(:add_resource)
             @scope.stubs(:findclass).with("notfound").returns(nil)
 
             Puppet::Parser::Resource.stubs(:new).returns(@resource)
             @class.stubs :evaluate
             @compiler.evaluate_classes(%w{myclass notfound}, @scope).should == %w{myclass}
         end
     end
 
     describe Puppet::Parser::Compiler, " when evaluating AST nodes with no AST nodes present" do
 
         it "should do nothing" do
             @compiler.expects(:ast_nodes?).returns(false)
             @compiler.parser.expects(:nodes).never
             Puppet::Parser::Resource.expects(:new).never
 
             @compiler.send(:evaluate_ast_node)
         end
     end
 
     describe Puppet::Parser::Compiler, " when evaluating AST nodes with AST nodes present" do
 
         before do
             @nodes = mock 'node_hash'
             @compiler.stubs(:ast_nodes?).returns(true)
             @compiler.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 { @compiler.send(:evaluate_ast_node) }.should raise_error(Puppet::ParseError)
         end
 
         it "should evaluate the first node class matching the node name" do
             node_class = stub 'node', :classname => "c", :evaluate_code => nil
             @nodes.stubs(:[]).with("c").returns(node_class)
 
             node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil
             node_class.expects(:evaluate).returns(node_resource)
 
             @compiler.compile
         end
 
         it "should match the default node if no matching node can be found" do
             node_class = stub 'node', :classname => "default", :evaluate_code => nil
             @nodes.stubs(:[]).with("default").returns(node_class)
 
             node_resource = stub 'node resource', :ref => "Node[default]", :evaluate => nil
             node_class.expects(:evaluate).returns(node_resource)
 
             @compiler.compile
         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]"
             node_class.expects(:evaluate).returns(node_resource)
 
             node_resource.expects(:evaluate)
 
             @compiler.send(:evaluate_ast_node)
         end
 
         it "should set the node's scope as the top scope" do
             node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil
             node_class = stub 'node', :classname => "c", :evaluate => node_resource
 
             @nodes.stubs(:[]).with("c").returns(node_class)
 
             # The #evaluate method normally does this.
             scope = stub 'scope', :source => "mysource"
             @compiler.class_set(node_class.classname, scope)
             node_resource.stubs(:evaluate)
 
             @compiler.compile
 
             @compiler.topscope.should equal(scope)
         end
     end
 
     describe Puppet::Parser::Compiler, "when storing compiled resources" do
 
         it "should store the resources" do
             Puppet.features.expects(:rails?).returns(true)
             Puppet::Rails.expects(:connect)
 
             @compiler.catalog.expects(:vertices).returns(:resources)
 
             @compiler.expects(:store_to_active_record).with(@node, :resources)
             @compiler.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)
             @compiler.send(:store_to_active_record, @node, :resources)
         end
     end
 
     describe Puppet::Parser::Compiler, "when managing resource overrides" do
 
         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 { @compiler.add_override(@override) }.should_not raise_error
         end
 
         it "should apply overrides to the appropriate resources" do
             @compiler.add_resource(@scope, @resource)
             @resource.expects(:merge).with(@override)
 
             @compiler.add_override(@override)
 
             @compiler.compile
         end
 
         it "should accept overrides before the related resource has been created" do
             @resource.expects(:merge).with(@override)
 
             # First store the override
             @compiler.add_override(@override)
 
             # Then the resource
             @compiler.add_resource(@scope, @resource)
 
             # And compile, so they get resolved
             @compiler.compile
         end
 
         it "should fail if the compile is finished and resource overrides have not been applied" do
             @compiler.add_override(@override)
 
             lambda { @compiler.compile }.should raise_error(Puppet::ParseError)
         end
     end
 
     # #620 - Nodes and classes should conflict, else classes don't get evaluated
     describe Puppet::Parser::Compiler, "when evaluating nodes and classes with the same name (#620)" do
 
         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
             @compiler.class_set("one", @node)
             lambda { @compiler.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
             @compiler.class_set("one", @class)
             lambda { @compiler.class_set("one", @node) }.should raise_error(Puppet::ParseError)
         end
     end
-end
\ No newline at end of file
+end