diff --git a/lib/puppet/resource/catalog.rb b/lib/puppet/resource/catalog.rb
index 88aa9517d..cb0ce0333 100644
--- a/lib/puppet/resource/catalog.rb
+++ b/lib/puppet/resource/catalog.rb
@@ -1,521 +1,535 @@
 require 'puppet/indirector'
 require 'puppet/simple_graph'
 require 'puppet/transaction'
 
 require 'puppet/util/cacher'
 
 require 'puppet/util/tagging'
 
 # This class models a node catalog.  It is the thing
 # meant to be passed from server to client, and it contains all
 # of the information in the catalog, including the resources
 # and the relationships between them.
 class Puppet::Resource::Catalog < Puppet::SimpleGraph
     class DuplicateResourceError < Puppet::Error; end
 
     extend Puppet::Indirector
     indirects :catalog, :terminus_class => :compiler
 
     include Puppet::Util::Tagging
     include Puppet::Util::Cacher::Expirer
 
     # The host name this is a catalog for.
     attr_accessor :name
 
     # The catalog version.  Used for testing whether a catalog
     # is up to date.
     attr_accessor :version
 
     # How long this catalog took to retrieve.  Used for reporting stats.
     attr_accessor :retrieval_duration
 
     # How we should extract the catalog for sending to the client.
     attr_reader :extraction_format
 
     # Whether this is a host catalog, which behaves very differently.
     # In particular, reports are sent, graphs are made, and state is
     # stored in the state database.  If this is set incorrectly, then you often
     # end up in infinite loops, because catalogs are used to make things
     # that the host catalog needs.
     attr_accessor :host_config
 
     # Whether this catalog was retrieved from the cache, which affects
     # whether it is written back out again.
     attr_accessor :from_cache
 
     # Add classes to our class list.
     def add_class(*classes)
         classes.each do |klass|
             @classes << klass
         end
 
         # Add the class names as tags, too.
         tag(*classes)
     end
 
     # Add one or more resources to our graph and to our resource table.
     # This is actually a relatively complicated method, because it handles multiple
     # aspects of Catalog behaviour:
     # * Add the resource to the resource table
     # * Add the resource to the resource graph
     # * Add the resource to the relationship graph
     # * Add any aliases that make sense for the resource (e.g., name != title)
     def add_resource(*resources)
         resources.each do |resource|
             unless resource.respond_to?(:ref)
                 raise ArgumentError, "Can only add objects that respond to :ref, not instances of %s" % resource.class
             end
         end.each { |resource| fail_unless_unique(resource) }.each do |resource|
             ref = resource.ref
 
             @transient_resources << resource if applying?
             @resource_table[ref] = resource
 
             # If the name and title differ, set up an alias
             #self.alias(resource, resource.name) if resource.respond_to?(:name) and resource.respond_to?(:title) and resource.name != resource.title
             if resource.respond_to?(:name) and resource.respond_to?(:title) and resource.name != resource.title
                 self.alias(resource, resource.name) if resource.isomorphic?
             end
 
             resource.catalog = self if resource.respond_to?(:catalog=)
 
             add_vertex(resource)
 
             if @relationship_graph
                 @relationship_graph.add_vertex(resource)
             end
 
             yield(resource) if block_given?
         end
     end
 
     # Create an alias for a resource.
     def alias(resource, name)
         #set $1 
         resource.ref =~ /^(.+)\[/
 
         newref = "%s[%s]" % [$1 || resource.class.name, name]
 
         # LAK:NOTE It's important that we directly compare the references,
         # because sometimes an alias is created before the resource is
         # added to the catalog, so comparing inside the below if block
         # isn't sufficient.
         return if newref == resource.ref
         if existing = @resource_table[newref]
             return if existing == resource
             raise(ArgumentError, "Cannot alias %s to %s; resource %s already exists" % [resource.ref, name, newref])
         end
         @resource_table[newref] = resource
         @aliases[resource.ref] ||= []
         @aliases[resource.ref] << newref
     end
 
     # Apply our catalog to the local host.  Valid options
     # are:
     #   :tags - set the tags that restrict what resources run
     #       during the transaction
     #   :ignoreschedules - tell the transaction to ignore schedules
     #       when determining the resources to run
     def apply(options = {})
         @applying = true
 
         # Expire all of the resource data -- this ensures that all
         # data we're operating against is entirely current.
         expire()
 
         Puppet::Util::Storage.load if host_config?
         transaction = Puppet::Transaction.new(self)
 
         transaction.tags = options[:tags] if options[:tags]
         transaction.ignoreschedules = true if options[:ignoreschedules]
 
         transaction.addtimes :config_retrieval => @retrieval_duration
 
 
         begin
             transaction.evaluate
         rescue Puppet::Error => detail
             puts detail.backtrace if Puppet[:trace]
             Puppet.err "Could not apply complete catalog: %s" % detail
         rescue => detail
             puts detail.backtrace if Puppet[:trace]
             Puppet.err "Got an uncaught exception of type %s: %s" % [detail.class, detail]
         ensure
             # Don't try to store state unless we're a host config
             # too recursive.
             Puppet::Util::Storage.store if host_config?
         end
 
         yield transaction if block_given?
         
         transaction.send_report if host_config and (Puppet[:report] or Puppet[:summarize])
 
         return transaction
     ensure
         @applying = false
         cleanup()
         transaction.cleanup if defined? transaction and transaction
     end
 
     # Are we in the middle of applying the catalog?
     def applying?
         @applying
     end
     
     def clear(remove_resources = true)
         super()
         # We have to do this so that the resources clean themselves up.
         @resource_table.values.each { |resource| resource.remove } if remove_resources
         @resource_table.clear
 
         if defined?(@relationship_graph) and @relationship_graph
             @relationship_graph.clear
             @relationship_graph = nil
         end
     end
 
     def classes
         @classes.dup
     end
 
     # Create a new resource and register it in the catalog.
     def create_resource(type, options)
         unless klass = Puppet::Type.type(type)
             raise ArgumentError, "Unknown resource type %s" % type
         end
         return unless resource = klass.new(options)
 
         add_resource(resource)
         resource
     end
 
     def expired?(ts)
         if applying?
             return super
         else
             return true
         end
     end
 
     # Make sure we support the requested extraction format.
     def extraction_format=(value)
         unless respond_to?("extract_to_%s" % value)
             raise ArgumentError, "Invalid extraction format %s" % value
         end
         @extraction_format = value
     end
 
     # Turn our catalog graph into whatever the client is expecting.
     def extract
         send("extract_to_%s" % extraction_format)
     end
 
     # Create the traditional TransBuckets and TransObjects from our catalog
     # graph.  LAK:NOTE(20081211): This is a  pre-0.25 backward compatibility method.
     # It can be removed as soon as xmlrpc is killed.
     def extract_to_transportable
         top = nil
         current = nil
         buckets = {}
 
         unless main = vertices.find { |res| res.type == "Class" and res.title == :main }
             raise Puppet::DevError, "Could not find 'main' class; cannot generate catalog"
         end
 
         # Create a proc for examining edges, which we'll use to build our tree
         # of TransBuckets and TransObjects.
         bucket = nil
         walk(main, :out) do |source, target|
             # The sources are always non-builtins.
             unless tmp = buckets[source.to_s]
                 if tmp = buckets[source.to_s] = source.to_trans
                     bucket = tmp
                 else
                     # This is because virtual resources return nil.  If a virtual
                     # container resource contains realized resources, we still need to get
                     # to them.  So, we keep a reference to the last valid bucket
                     # we returned and use that if the container resource is virtual.
                 end
             end
             bucket = tmp || bucket
             if child = target.to_trans
                 unless bucket
                     raise "No bucket created for %s" % source
                 end
                 bucket.push child
 
                 # It's important that we keep a reference to any TransBuckets we've created, so
                 # we don't create multiple buckets for children.
                 unless target.builtin?
                     buckets[target.to_s] = child
                 end
             end
         end
 
         # Retrieve the bucket for the top-level scope and set the appropriate metadata.
         unless result = buckets[main.to_s]
             # This only happens when the catalog is entirely empty.
             result = buckets[main.to_s] = main.to_trans
         end
 
         result.classes = classes
 
         # Clear the cache to encourage the GC
         buckets.clear
         return result
     end
 
     # Make sure all of our resources are "finished".
     def finalize
         make_default_resources
 
         @resource_table.values.each { |resource| resource.finish }
         
         write_graph(:resources)
     end
 
     def host_config?
         host_config || false
     end
 
     def initialize(name = nil)
         super()
         @name = name if name
         @extraction_format ||= :transportable
         @classes = []
         @resource_table = {}
         @transient_resources = []
         @applying = false
         @relationship_graph = nil
 
         @aliases = {}
 
         if block_given?
             yield(self)
             finalize()
         end
     end
 
     # Make the default objects necessary for function.
     def make_default_resources
         # We have to add the resources to the catalog, or else they won't get cleaned up after
         # the transaction.
 
         # First create the default scheduling objects
         Puppet::Type.type(:schedule).mkdefaultschedules.each { |res| add_resource(res) unless resource(res.ref) }
         
         # And filebuckets
         if bucket = Puppet::Type.type(:filebucket).mkdefaultbucket
             add_resource(bucket) unless resource(bucket.ref)
         end
     end
     
     # Create a graph of all of the relationships in our catalog.
     def relationship_graph
         unless defined? @relationship_graph and @relationship_graph
             # It's important that we assign the graph immediately, because
             # the debug messages below use the relationships in the
             # relationship graph to determine the path to the resources
             # spitting out the messages.  If this is not set,
             # then we get into an infinite loop.
             @relationship_graph = Puppet::SimpleGraph.new
             
             # First create the dependency graph
             self.vertices.each do |vertex|
                 @relationship_graph.add_vertex vertex
                 vertex.builddepends.each do |edge|
                     @relationship_graph.add_edge(edge)
                 end
             end
             
             # Lastly, add in any autorequires
             @relationship_graph.vertices.each do |vertex|
                 vertex.autorequire(self).each do |edge|
                     unless @relationship_graph.edge?(edge.source, edge.target) # don't let automatic relationships conflict with manual ones.
                         unless @relationship_graph.edge?(edge.target, edge.source)
                             vertex.debug "Autorequiring %s" % [edge.source]
                             @relationship_graph.add_edge(edge)
                         else
                             vertex.debug "Skipping automatic relationship with %s" % (edge.source == vertex ? edge.target : edge.source)
                         end
                     end
                 end
             end
             @relationship_graph.write_graph(:relationships) if host_config?
             
             # Then splice in the container information
             @relationship_graph.splice!(self, Puppet::Type::Component)
 
             @relationship_graph.write_graph(:expanded_relationships) if host_config?
         end
         @relationship_graph
     end
 
     # Remove the resource from our catalog.  Notice that we also call
     # 'remove' on the resource, at least until resource classes no longer maintain
     # references to the resource instances.
     def remove_resource(*resources)
         resources.each do |resource|
             @resource_table.delete(resource.ref)
             if aliases = @aliases[resource.ref]
                 aliases.each { |res_alias| @resource_table.delete(res_alias) }
                 @aliases.delete(resource.ref)
             end
             remove_vertex!(resource) if vertex?(resource)
             @relationship_graph.remove_vertex!(resource) if @relationship_graph and @relationship_graph.vertex?(resource)
             resource.remove
         end
     end
 
     # Look a resource up by its reference (e.g., File[/etc/passwd]).
     def resource(type, title = nil)
         # Always create a resource reference, so that it always canonizes how we
         # are referring to them.
         if title
             ref = Puppet::Resource::Reference.new(type, title).to_s
         else
             # If they didn't provide a title, then we expect the first
             # argument to be of the form 'Class[name]', which our
             # Reference class canonizes for us.
             ref = Puppet::Resource::Reference.new(nil, type).to_s
         end
         @resource_table[ref]
     end
 
     # Return an array of all resources.
     def resources
         @resource_table.keys
     end
 
     # Convert our catalog into a RAL catalog.
     def to_ral
         to_catalog :to_ral
     end
 
     # Convert our catalog into a catalog of Puppet::Resource instances.
     def to_resource
         to_catalog :to_resource
     end
 
     # Store the classes in the classfile.
     def write_class_file
         begin
             ::File.open(Puppet[:classfile], "w") do |f|
                 f.puts classes.join("\n")
             end
         rescue => detail
             Puppet.err "Could not create class file %s: %s" % [Puppet[:classfile], detail]
         end
     end
 
     # Produce the graph files if requested.
     def write_graph(name)
         # We only want to graph the main host catalog.
         return unless host_config?
 
         super
     end
 
+    def to_yaml_properties
+        result = instance_variables
+
+        # There's a ruby bug that hits us without this:
+        # http://rubyforge.org/tracker/?group_id=426&atid=1698&func=detail&aid=8886
+        # We need our resources to show up in as values in a hash
+        # before they show up as keys, because otherwise
+        # the loading fails.
+        result.delete "@resource_table"
+        result.unshift "@resource_table"
+
+        result
+    end
+
     private
 
     def cleanup
         unless @transient_resources.empty?
             remove_resource(*@transient_resources)
             @transient_resources.clear
             @relationship_graph = nil
         end
 
         # Expire any cached data the resources are keeping.
         expire()
     end
 
     # Verify that the given resource isn't defined elsewhere.
     def fail_unless_unique(resource)
         # Short-curcuit the common case, 
         return unless existing_resource = @resource_table[resource.ref]
 
         # If we've gotten this far, it's a real conflict
 
         # 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 DuplicateResourceError.new(msg)
     end
 
     # An abstracted method for converting one catalog into another type of catalog.
     # This pretty much just converts all of the resources from one class to another, using
     # a conversion method.
     def to_catalog(convert)
         result = self.class.new(self.name)
 
         result.version = self.version
 
         map = {}
         vertices.each do |resource|
             next if resource.respond_to?(:virtual?) and resource.virtual?
 
             #This is hackity hack for 1094
             #Aliases aren't working in the ral catalog because the current instance of the resource
             #has a reference to the catalog being converted. . . So, give it a reference to the new one
             #problem solved. . .
             if resource.is_a?(Puppet::Resource)
                 resource = resource.dup
                 resource.catalog = result
             elsif resource.is_a?(Puppet::TransObject)
                 resource = resource.dup
                 resource.catalog = result
             elsif resource.is_a?(Puppet::Parser::Resource)
                 resource = resource.to_resource
                 resource.catalog = result
             end
 
             if resource.is_a?(Puppet::Resource) and convert.to_s == "to_resource"
                 newres = resource
             else
                 newres = resource.send(convert)
             end
 
             # We can't guarantee that resources don't munge their names
             # (like files do with trailing slashes), so we have to keep track
             # of what a resource got converted to.
             map[resource.ref] = newres
 
             result.add_resource newres
         end
 
         message = convert.to_s.gsub "_", " "
         edges.each do |edge|
             # Skip edges between virtual resources.
             next if edge.source.respond_to?(:virtual?) and edge.source.virtual?
             next if edge.target.respond_to?(:virtual?) and edge.target.virtual?
 
             unless source = map[edge.source.ref]
                 raise Puppet::DevError, "Could not find resource %s when converting %s resources" % [edge.source.ref, message]
             end
 
             unless target = map[edge.target.ref]
                 raise Puppet::DevError, "Could not find resource %s when converting %s resources" % [edge.target.ref, message]
             end
 
             result.add_edge(source, target, edge.label)
         end
 
         map.clear
 
         result.add_class(*self.classes)
         result.tag(*self.tags)
 
         return result
     end
 end
diff --git a/spec/unit/resource/catalog.rb b/spec/unit/resource/catalog.rb
index 6a5922e2e..d51f8fbd7 100755
--- a/spec/unit/resource/catalog.rb
+++ b/spec/unit/resource/catalog.rb
@@ -1,828 +1,832 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Resource::Catalog, "when compiling" do
     it "should be an Expirer" do
         Puppet::Resource::Catalog.ancestors.should be_include(Puppet::Util::Cacher::Expirer)
     end
 
     it "should always be expired if it's not applying" do
         @catalog = Puppet::Resource::Catalog.new("host")
         @catalog.expects(:applying?).returns false
         @catalog.should be_expired(Time.now)
     end
 
     it "should not be expired if it's applying and the timestamp is late enough" do
         @catalog = Puppet::Resource::Catalog.new("host")
         @catalog.expire
         @catalog.expects(:applying?).returns true
         @catalog.should_not be_expired(Time.now)
     end
 
     it "should be able to write its list of classes to the class file" do
         @catalog = Puppet::Resource::Catalog.new("host")
 
         @catalog.add_class "foo", "bar"
 
         Puppet.settings.expects(:value).with(:classfile).returns "/class/file"
 
         fh = mock 'filehandle'
         File.expects(:open).with("/class/file", "w").yields fh
 
         fh.expects(:puts).with "foo\nbar"
 
         @catalog.write_class_file
     end
 
     describe "when compiling" do
         it "should accept tags" do
             config = Puppet::Resource::Catalog.new("mynode")
             config.tag("one")
             config.tags.should == %w{one}
         end
 
         it "should accept multiple tags at once" do
             config = Puppet::Resource::Catalog.new("mynode")
             config.tag("one", "two")
             config.tags.should == %w{one two}
         end
 
         it "should convert all tags to strings" do
             config = Puppet::Resource::Catalog.new("mynode")
             config.tag("one", :two)
             config.tags.should == %w{one two}
         end
 
         it "should tag with both the qualified name and the split name" do
             config = Puppet::Resource::Catalog.new("mynode")
             config.tag("one::two")
             config.tags.include?("one").should be_true
             config.tags.include?("one::two").should be_true
         end
 
         it "should accept classes" do
             config = Puppet::Resource::Catalog.new("mynode")
             config.add_class("one")
             config.classes.should == %w{one}
             config.add_class("two", "three")
             config.classes.should == %w{one two three}
         end
 
         it "should tag itself with passed class names" do
             config = Puppet::Resource::Catalog.new("mynode")
             config.add_class("one")
             config.tags.should == %w{one}
         end
     end
 
     describe "when extracting" do
         it "should return extraction result as the method result" do
             config = Puppet::Resource::Catalog.new("mynode")
             config.expects(:extraction_format).returns(:whatever)
             config.expects(:extract_to_whatever).returns(:result)
             config.extract.should == :result
         end
     end
 
     describe "when extracting transobjects" do
 
         def mkscope
             @parser = Puppet::Parser::Parser.new :Code => ""
             @node = Puppet::Node.new("mynode")
             @compiler = Puppet::Parser::Compiler.new(@node, @parser)
 
             # XXX This is ridiculous.
             @compiler.send(:evaluate_main)
             @scope = @compiler.topscope
         end
 
         def mkresource(type, name)
             Puppet::Parser::Resource.new(:type => type, :title => name, :source => @source, :scope => @scope)
         end
 
         it "should always create a TransBucket for the 'main' class" do
             config = Puppet::Resource::Catalog.new("mynode")
 
             @scope = mkscope
             @source = mock 'source'
 
             main = mkresource("class", :main)
             config.add_vertex(main)
 
             bucket = stub 'bucket', :file= => nil, :line= => nil, :classes= => nil
             bucket.expects(:type=).with("Class")
             bucket.expects(:name=).with(:main)
             main.stubs(:builtin?).returns(false)
             
             Puppet::TransBucket.expects(:new).returns bucket
 
             config.extract_to_transportable.should equal(bucket)
         end
 
         # Now try it with a more complicated graph -- a three tier graph, each tier
         it "should transform arbitrarily deep graphs into isomorphic trees" do
             config = Puppet::Resource::Catalog.new("mynode")
 
             @scope = mkscope
             @scope.stubs(:tags).returns([])
             @source = mock 'source'
 
             # Create our scopes.
             top = mkresource "class", :main
             topbucket = []
             topbucket.expects(:classes=).with([])
             top.expects(:to_trans).returns(topbucket)
             topres = mkresource "file", "/top"
             topres.expects(:to_trans).returns(:topres)
             config.add_edge top, topres
 
             middle = mkresource "class", "middle"
             middle.expects(:to_trans).returns([])
             config.add_edge top, middle
             midres = mkresource "file", "/mid"
             midres.expects(:to_trans).returns(:midres)
             config.add_edge middle, midres
 
             bottom = mkresource "class", "bottom"
             bottom.expects(:to_trans).returns([])
             config.add_edge middle, bottom
             botres = mkresource "file", "/bot"
             botres.expects(:to_trans).returns(:botres)
             config.add_edge bottom, botres
 
             toparray = config.extract_to_transportable
 
             # This is annoying; it should look like:
             #   [[[:botres], :midres], :topres]
             # but we can't guarantee sort order.
             toparray.include?(:topres).should be_true
 
             midarray = toparray.find { |t| t.is_a?(Array) }
             midarray.include?(:midres).should be_true
             botarray = midarray.find { |t| t.is_a?(Array) }
             botarray.include?(:botres).should be_true
         end
     end
 
     describe " when converting to a Puppet::Resource catalog" do
         before do
             @original = Puppet::Resource::Catalog.new("mynode")
             @original.tag(*%w{one two three})
             @original.add_class *%w{four five six}
 
             @top            = Puppet::TransObject.new 'top', "class"
             @topobject      = Puppet::TransObject.new '/topobject', "file"
             @middle         = Puppet::TransObject.new 'middle', "class"
             @middleobject   = Puppet::TransObject.new '/middleobject', "file"
             @bottom         = Puppet::TransObject.new 'bottom', "class"
             @bottomobject   = Puppet::TransObject.new '/bottomobject', "file"
 
             @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject]
 
             @original.add_resource(*@resources)
 
             @original.add_edge(@top, @topobject)
             @original.add_edge(@top, @middle)
             @original.add_edge(@middle, @middleobject)
             @original.add_edge(@middle, @bottom)
             @original.add_edge(@bottom, @bottomobject)
 
             @catalog = @original.to_resource
         end
 
         it "should copy over the version" do
             @original.version = "foo"
             @original.to_resource.version.should == "foo"
         end
 
         it "should add all resources as Puppet::Resource instances" do
             @resources.each { |resource| @catalog.resource(resource.ref).should be_instance_of(Puppet::Resource) }
         end
 
         it "should copy the tag list to the new catalog" do
             @catalog.tags.sort.should == @original.tags.sort
         end
 
         it "should copy the class list to the new catalog" do
             @catalog.classes.should == @original.classes
         end
 
         it "should duplicate the original edges" do
             @original.edges.each do |edge|
                 @catalog.edge?(@catalog.resource(edge.source.ref), @catalog.resource(edge.target.ref)).should be_true
             end
         end
 
         it "should set itself as the catalog for each converted resource" do
             @catalog.vertices.each { |v| v.catalog.object_id.should equal(@catalog.object_id) }
         end
     end
 
     describe "when converting to a RAL catalog" do
         before do
             @original = Puppet::Resource::Catalog.new("mynode")
             @original.tag(*%w{one two three})
             @original.add_class *%w{four five six}
 
             @top            = Puppet::Resource.new :class, 'top'
             @topobject      = Puppet::Resource.new :file, '/topobject'
             @middle         = Puppet::Resource.new :class, 'middle'
             @middleobject   = Puppet::Resource.new :file, '/middleobject'
             @bottom         = Puppet::Resource.new :class, 'bottom'
             @bottomobject   = Puppet::Resource.new :file, '/bottomobject'
 
             @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject]
 
             @original.add_resource(*@resources)
 
             @original.add_edge(@top, @topobject)
             @original.add_edge(@top, @middle)
             @original.add_edge(@middle, @middleobject)
             @original.add_edge(@middle, @bottom)
             @original.add_edge(@bottom, @bottomobject)
 
             @catalog = @original.to_ral
         end
 
         it "should add all resources as RAL instances" do
             @resources.each { |resource| @catalog.resource(resource.ref).should be_instance_of(Puppet::Type) }
         end
 
         it "should copy the tag list to the new catalog" do
             @catalog.tags.sort.should == @original.tags.sort
         end
 
         it "should copy the class list to the new catalog" do
             @catalog.classes.should == @original.classes
         end
 
         it "should duplicate the original edges" do
             @original.edges.each do |edge|
                 @catalog.edge?(@catalog.resource(edge.source.ref), @catalog.resource(edge.target.ref)).should be_true
             end
         end
 
         it "should set itself as the catalog for each converted resource" do
             @catalog.vertices.each { |v| v.catalog.object_id.should equal(@catalog.object_id) }
         end
 
         # This tests #931.
         it "should not lose track of resources whose names vary" do
             changer = Puppet::TransObject.new 'changer', 'test'
 
             config = Puppet::Resource::Catalog.new('test')
             config.add_resource(changer)
             config.add_resource(@top)
 
             config.add_edge(@top, changer)
 
             resource = stub 'resource', :name => "changer2", :title => "changer2", :ref => "Test[changer2]", :catalog= => nil, :remove => nil
 
             #changer is going to get duplicated as part of a fix for aliases 1094
             changer.expects(:dup).returns(changer)
             changer.expects(:to_ral).returns(resource)
 
             newconfig = nil
 
             proc { @catalog = config.to_ral }.should_not raise_error
             @catalog.resource("Test[changer2]").should equal(resource)
         end
 
         after do
             # Remove all resource instances.
             @catalog.clear(true)
         end
     end
 
     describe "when functioning as a resource container" do
         before do
             @catalog = Puppet::Resource::Catalog.new("host")
             @one = Puppet::Type.type(:notify).new :name => "one"
             @two = Puppet::Type.type(:notify).new :name => "two"
             @dupe = Puppet::Type.type(:notify).new :name => "one"
         end
 
         it "should provide a method to add one or more resources" do
             @catalog.add_resource @one, @two
             @catalog.resource(@one.ref).should equal(@one)
             @catalog.resource(@two.ref).should equal(@two)
         end
 
         it "should add resources to the relationship graph if it exists" do
             relgraph = @catalog.relationship_graph
             @catalog.add_resource @one
             relgraph.should be_vertex(@one)
         end
 
         it "should yield added resources if a block is provided" do
             yielded = []
             @catalog.add_resource(@one, @two) { |r| yielded << r }
             yielded.length.should == 2
         end
 
         it "should set itself as the resource's catalog if it is not a relationship graph" do
             @one.expects(:catalog=).with(@catalog)
             @catalog.add_resource @one
         end
 
         it "should make all vertices available by resource reference" do
             @catalog.add_resource(@one)
             @catalog.resource(@one.ref).should equal(@one)
             @catalog.vertices.find { |r| r.ref == @one.ref }.should equal(@one)
         end
 
         it "should canonize how resources are referred to during retrieval when both type and title are provided" do
             @catalog.add_resource(@one)
 
             @catalog.resource("notify", "one").should equal(@one)
         end
 
         it "should canonize how resources are referred to during retrieval when just the title is provided" do
             @catalog.add_resource(@one)
 
             @catalog.resource("notify[one]", nil).should equal(@one)
         end
 
         it "should not allow two resources with the same resource reference" do
             @catalog.add_resource(@one)
 
             proc { @catalog.add_resource(@dupe) }.should raise_error(Puppet::Resource::Catalog::DuplicateResourceError)
         end
 
         it "should not store objects that do not respond to :ref" do
             proc { @catalog.add_resource("thing") }.should raise_error(ArgumentError)
         end
 
         it "should remove all resources when asked" do
             @catalog.add_resource @one
             @catalog.add_resource @two
             @one.expects :remove
             @two.expects :remove
             @catalog.clear(true)
         end
 
         it "should support a mechanism for finishing resources" do
             @one.expects :finish
             @two.expects :finish
             @catalog.add_resource @one
             @catalog.add_resource @two
 
             @catalog.finalize
         end
 
         it "should make default resources when finalizing" do
             @catalog.expects(:make_default_resources)
             @catalog.finalize
         end
 
         it "should add default resources to the catalog upon creation" do
             @catalog.make_default_resources
             @catalog.resource(:schedule, "daily").should_not be_nil
         end
         
         it "should optionally support an initialization block and should finalize after such blocks" do
             @one.expects :finish
             @two.expects :finish
             config = Puppet::Resource::Catalog.new("host") do |conf|
                 conf.add_resource @one
                 conf.add_resource @two
             end
         end
 
         it "should inform the resource that it is the resource's catalog" do
             @one.expects(:catalog=).with(@catalog)
             @catalog.add_resource @one
         end
 
         it "should be able to find resources by reference" do
             @catalog.add_resource @one
             @catalog.resource(@one.ref).should equal(@one)
         end
 
         it "should be able to find resources by reference or by type/title tuple" do
             @catalog.add_resource @one
             @catalog.resource("notify", "one").should equal(@one)
         end
 
         it "should have a mechanism for removing resources" do
             @catalog.add_resource @one
             @one.expects :remove
             @catalog.remove_resource(@one)
             @catalog.resource(@one.ref).should be_nil
             @catalog.vertex?(@one).should be_false
         end
 
         it "should have a method for creating aliases for resources" do
             @catalog.add_resource @one
             @catalog.alias(@one, "other")
             @catalog.resource("notify", "other").should equal(@one)
         end
 
         it "should ignore conflicting aliases that point to the aliased resource" do
             @catalog.alias(@one, "other")
             lambda { @catalog.alias(@one, "other") }.should_not raise_error
         end
 
         it "should create aliases for resources isomorphic resources whose names do not match their titles" do
             resource = Puppet::Type::File.new(:title => "testing", :path => "/something")
 
             @catalog.add_resource(resource)
 
             @catalog.resource(:file, "/something").should equal(resource)
         end
 
         it "should not create aliases for resources non-isomorphic resources whose names do not match their titles" do
             resource = Puppet::Type.type(:exec).new(:title => "testing", :command => "echo", :path => %w{/bin /usr/bin /usr/local/bin})
 
             @catalog.add_resource(resource)
 
             # Yay, I've already got a 'should' method
             @catalog.resource(:exec, "echo").object_id.should == nil.object_id
         end
 
         # This test is the same as the previous, but the behaviour should be explicit.
         it "should alias using the class name from the resource reference, not the resource class name" do
             @catalog.add_resource @one
             @catalog.alias(@one, "other")
             @catalog.resource("notify", "other").should equal(@one)
         end
 
         it "should ignore conflicting aliases that point to the aliased resource" do
             @catalog.alias(@one, "other")
             lambda { @catalog.alias(@one, "other") }.should_not raise_error
         end
 
         it "should fail to add an alias if the aliased name already exists" do
             @catalog.add_resource @one
             proc { @catalog.alias @two, "one" }.should raise_error(ArgumentError)
         end
 
         it "should not fail when a resource has duplicate aliases created" do
             @catalog.add_resource @one
             proc { @catalog.alias @one, "one" }.should_not raise_error
         end
 
         it "should not create aliases that point back to the resource" do
             @catalog.alias(@one, "one")
             @catalog.resource(:notify, "one").should be_nil
         end
 
         it "should be able to look resources up by their aliases" do
             @catalog.add_resource @one
             @catalog.alias @one, "two"
             @catalog.resource(:notify, "two").should equal(@one)
         end
 
         it "should remove resource aliases when the target resource is removed" do
             @catalog.add_resource @one
             @catalog.alias(@one, "other")
             @one.expects :remove
             @catalog.remove_resource(@one)
             @catalog.resource("notify", "other").should be_nil
         end
 
         it "should add an alias for the namevar when the title and name differ on isomorphic resource types" do
             resource = Puppet::Type.type(:file).new :path => "/something", :title => "other", :content => "blah"
             resource.expects(:isomorphic?).returns(true)
             @catalog.add_resource(resource)
             @catalog.resource(:file, "other").should equal(resource)
             @catalog.resource(:file, "/something").ref.should == resource.ref
         end
 
         it "should not add an alias for the namevar when the title and name differ on non-isomorphic resource types" do
             resource = Puppet::Type.type(:file).new :path => "/something", :title => "other", :content => "blah"
             resource.expects(:isomorphic?).returns(false)
             @catalog.add_resource(resource)
             @catalog.resource(:file, resource.title).should equal(resource)
             # We can't use .should here, because the resources respond to that method.
             if @catalog.resource(:file, resource.name)
                 raise "Aliased non-isomorphic resource"
             end
         end
 
         it "should provide a method to create additional resources that also registers the resource" do
             args = {:name => "/yay", :ensure => :file}
             resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog, :title => "/yay", :[] => "/yay"
             Puppet::Type.type(:file).expects(:new).with(args).returns(resource)
             @catalog.create_resource :file, args
             @catalog.resource("File[/yay]").should equal(resource)
         end
     end
 
     describe "when applying" do
         before :each do
             @catalog = Puppet::Resource::Catalog.new("host")
 
             @catalog.retrieval_duration = Time.now
             @transaction = mock 'transaction'
             Puppet::Transaction.stubs(:new).returns(@transaction)
             @transaction.stubs(:evaluate)
             @transaction.stubs(:cleanup)
             @transaction.stubs(:addtimes)
         end
 
         it "should create and evaluate a transaction" do
             @transaction.expects(:evaluate)
             @catalog.apply
         end
 
         it "should provide the catalog time to the transaction" do
             @transaction.expects(:addtimes).with do |arg|
                 arg[:config_retrieval].should be_instance_of(Time)
                 true
             end
             @catalog.apply
         end
 
         it "should clean up the transaction" do
             @transaction.expects :cleanup
             @catalog.apply
         end
     
         it "should return the transaction" do
             @catalog.apply.should equal(@transaction)
         end
 
         it "should yield the transaction if a block is provided" do
             @catalog.apply do |trans|
                 trans.should equal(@transaction)
             end
         end
     
         it "should default to not being a host catalog" do
             @catalog.host_config.should be_nil
         end
 
         it "should pass supplied tags on to the transaction" do
             @transaction.expects(:tags=).with(%w{one two})
             @catalog.apply(:tags => %w{one two})
         end
 
         it "should set ignoreschedules on the transaction if specified in apply()" do
             @transaction.expects(:ignoreschedules=).with(true)
             @catalog.apply(:ignoreschedules => true)
         end
 
         it "should remove resources created mid-transaction" do
             args = {:name => "/yay", :ensure => :file}
             resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog, :title => "/yay", :[] => "/yay"
             @transaction = mock 'transaction'
             Puppet::Transaction.stubs(:new).returns(@transaction)
             @transaction.stubs(:evaluate)
             @transaction.stubs(:cleanup)
             @transaction.stubs(:addtimes)
             Puppet::Type.type(:file).expects(:new).with(args).returns(resource)
             resource.expects :remove
             @catalog.apply do |trans|
                 @catalog.create_resource :file, args
                 @catalog.resource("File[/yay]").should equal(resource)
             end
             @catalog.resource("File[/yay]").should be_nil
         end
 
         it "should remove resources added mid-transaction" do
             @transaction = mock 'transaction'
             Puppet::Transaction.stubs(:new).returns(@transaction)
             @transaction.stubs(:evaluate)
             @transaction.stubs(:cleanup)
             @transaction.stubs(:addtimes)
             file = Puppet::Type.type(:file).new(:name => "/yay", :ensure => :file)
             @catalog.apply do |trans|
                 @catalog.add_resource file 
                 @catalog.resource("File[/yay]").should_not be_nil
             end
             @catalog.resource("File[/yay]").should be_nil
         end
 
         it "should expire cached data in the resources both before and after the transaction" do
             @catalog.expects(:expire).times(2)
             @catalog.apply
         end
 
         describe "host catalogs" do
 
             # super() doesn't work in the setup method for some reason
             before do
                 @catalog.host_config = true
                 Puppet::Util::Storage.stubs(:store)
             end
 
             it "should send a report if reporting is enabled" do
                 Puppet[:report] = true
                 @transaction.expects :send_report
                 @transaction.stubs :any_failed? => false
                 @catalog.apply
             end
 
             it "should send a report if report summaries are enabled" do
                 Puppet[:summarize] = true
                 @transaction.expects :send_report
                 @transaction.stubs :any_failed? => false
                 @catalog.apply
             end
 
             it "should initialize the state database before applying a catalog" do
                 Puppet::Util::Storage.expects(:load)
 
                 # Short-circuit the apply, so we know we're loading before the transaction
                 Puppet::Transaction.expects(:new).raises ArgumentError
                 proc { @catalog.apply }.should raise_error(ArgumentError)
             end
 
             it "should sync the state database after applying" do
                 Puppet::Util::Storage.expects(:store)
                 @transaction.stubs :any_failed? => false
                 @catalog.apply
             end
 
             after { Puppet.settings.clear }
         end
 
         describe "non-host catalogs" do
 
             before do
                 @catalog.host_config = false
             end
         
             it "should never send reports" do
                 Puppet[:report] = true
                 Puppet[:summarize] = true
                 @transaction.expects(:send_report).never
                 @catalog.apply
             end
 
             it "should never modify the state database" do
                 Puppet::Util::Storage.expects(:load).never
                 Puppet::Util::Storage.expects(:store).never
                 @catalog.apply
             end
 
             after { Puppet.settings.clear }
         end
     end
 
     describe "when creating a relationship graph" do
         before do
             Puppet::Type.type(:component)
             @catalog = Puppet::Resource::Catalog.new("host")
             @compone = Puppet::Type::Component.new :name => "one"
             @comptwo = Puppet::Type::Component.new :name => "two", :require => "Class[one]"
             @file = Puppet::Type.type(:file)
             @one = @file.new :path => "/one"
             @two = @file.new :path => "/two"
             @sub = @file.new :path => "/two/subdir"
             @catalog.add_edge @compone, @one
             @catalog.add_edge @comptwo, @two
 
             @three = @file.new :path => "/three"
             @four = @file.new :path => "/four", :require => "File[/three]"
             @five = @file.new :path => "/five"
             @catalog.add_resource @compone, @comptwo, @one, @two, @three, @four, @five, @sub
 
             @relationships = @catalog.relationship_graph
         end
 
         it "should be able to create a relationship graph" do
             @relationships.should be_instance_of(Puppet::SimpleGraph)
         end
 
         it "should not have any components" do
             @relationships.vertices.find { |r| r.instance_of?(Puppet::Type::Component) }.should be_nil
         end
 
         it "should have all non-component resources from the catalog" do
             # The failures print out too much info, so i just do a class comparison
             @relationships.vertex?(@five).should be_true
         end
 
         it "should have all resource relationships set as edges" do
             @relationships.edge?(@three, @four).should be_true
         end
 
         it "should copy component relationships to all contained resources" do
             @relationships.edge?(@one, @two).should be_true
         end
 
         it "should add automatic relationships to the relationship graph" do
             @relationships.edge?(@two, @sub).should be_true
         end
 
         it "should get removed when the catalog is cleaned up" do
             @relationships.expects(:clear)
             @catalog.clear
             @catalog.instance_variable_get("@relationship_graph").should be_nil
         end
 
         it "should write :relationships and :expanded_relationships graph files if the catalog is a host catalog" do
             @catalog.clear
             graph = Puppet::SimpleGraph.new
             Puppet::SimpleGraph.expects(:new).returns graph
 
             graph.expects(:write_graph).with(:relationships)
             graph.expects(:write_graph).with(:expanded_relationships)
 
             @catalog.host_config = true
 
             @catalog.relationship_graph
         end
 
         it "should not write graph files if the catalog is not a host catalog" do
             @catalog.clear
             graph = Puppet::SimpleGraph.new
             Puppet::SimpleGraph.expects(:new).returns graph
 
             graph.expects(:write_graph).never
 
             @catalog.host_config = false
 
             @catalog.relationship_graph
         end
 
         it "should create a new relationship graph after clearing the old one" do
             @relationships.expects(:clear)
             @catalog.clear
             @catalog.relationship_graph.should be_instance_of(Puppet::SimpleGraph)
         end
 
         it "should remove removed resources from the relationship graph if it exists" do
             @catalog.remove_resource(@one)
             @catalog.relationship_graph.vertex?(@one).should be_false
         end
     end
 
     describe "when writing dot files" do
         before do
             @catalog = Puppet::Resource::Catalog.new("host")
             @name = :test
             @file = File.join(Puppet[:graphdir], @name.to_s + ".dot")
         end
 
         it "should only write when it is a host catalog" do
             File.expects(:open).with(@file).never
             @catalog.host_config = false
             Puppet[:graph] = true
             @catalog.write_graph(@name)
         end
 
         after do
             Puppet.settings.clear
         end
     end
 
     describe "when indirecting" do
         before do
             @indirection = stub 'indirection', :name => :catalog
 
             Puppet::Util::Cacher.expire
         end
 
         it "should redirect to the indirection for retrieval" do
             Puppet::Resource::Catalog.stubs(:indirection).returns(@indirection)
             @indirection.expects(:find)
             Puppet::Resource::Catalog.find(:myconfig)
         end
 
         it "should default to the 'compiler' terminus" do
             Puppet::Resource::Catalog.indirection.terminus_class.should == :compiler
         end
 
         after do
             Puppet::Util::Cacher.expire
         end
     end
 
     describe "when converting to yaml" do
         before do
             @catalog = Puppet::Resource::Catalog.new("me")
             @catalog.add_edge("one", "two")
         end
 
         it "should be able to be dumped to yaml" do
             YAML.dump(@catalog).should be_instance_of(String)
         end
+
+        it "should always have its resource table first in its yaml property list" do
+            @catalog.to_yaml_properties[0].should == "@resource_table"
+        end
     end
 
     describe "when converting from yaml" do
         before do
             @catalog = Puppet::Resource::Catalog.new("me")
             @catalog.add_edge("one", "two")
 
             text = YAML.dump(@catalog)
             @newcatalog = YAML.load(text)
         end
 
         it "should get converted back to a catalog" do
             @newcatalog.should be_instance_of(Puppet::Resource::Catalog)
         end
 
         it "should have all vertices" do
             @newcatalog.vertex?("one").should be_true
             @newcatalog.vertex?("two").should be_true
         end
 
         it "should have all edges" do
             @newcatalog.edge?("one", "two").should be_true
         end
     end
 end