diff --git a/lib/puppet/node/catalog.rb b/lib/puppet/node/catalog.rb
index 96f60b179..b74947107 100644
--- a/lib/puppet/node/catalog.rb
+++ b/lib/puppet/node/catalog.rb
@@ -1,500 +1,500 @@
 require 'puppet/indirector'
 
 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::Node::Catalog < Puppet::PGraph
     extend Puppet::Indirector
     indirects :catalog, :terminus_class => :compiler
 
     include Puppet::Util::Tagging
 
     # 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
 
     # We need the ability to set this externally, so we can yaml-dump the
     # catalog.
     attr_accessor :edgelist_class
 
     # 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 graph is another catalog's relationship graph.
     # We don't want to accidentally create a relationship graph for another
     # relationship graph.
     attr_accessor :is_relationship_graph
 
     # 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.
     def add_resource(*resources)
         resources.each do |resource|
             unless resource.respond_to?(:ref)
                 raise ArgumentError, "Can only add objects that respond to :ref"
             end
 
             fail_unless_unique(resource)
 
             ref = resource.ref
 
             @resource_table[ref] = resource
 
             resource.catalog = self if resource.respond_to?(:catalog=) and ! is_relationship_graph
-            add_vertex!(resource)
+            add_vertex(resource)
         end
     end
 
     # Create an alias for a resource.
     def alias(resource, name)
         resource.ref =~ /^(.+)\[/
 
         newref = "%s[%s]" % [$1 || resource.class.name, name]
         raise(ArgumentError, "Cannot alias %s to %s; resource %s already exists" % [resource.ref, name, newref]) if @resource_table[newref]
         @resource_table[newref] = resource
         @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
 
         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
             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(false)
             @relationship_graph = nil
         end
     end
 
     def classes
         @classes.dup
     end
 
     # Create an implicit resource, meaning that it will lose out
     # to any explicitly defined resources.  This method often returns
     # nil.
     #  The quirk of this method is that it's not possible to create
     # an implicit resource before an explicit resource of the same name,
     # because all explicit resources are created before any generate()
     # methods are called on the individual resources.  Thus, this
     # method can safely just check if an explicit resource already exists
     # and toss this implicit resource if so.
     def create_implicit_resource(type, options)
         unless options.include?(:implicit)
             options[:implicit] = true
         end
 
         # This will return nil if an equivalent explicit resource already exists.
         # When resource classes no longer retain references to resource instances,
         # this will need to be modified to catch that conflict and discard
         # implicit resources.
         if resource = create_resource(type, options)
             resource.implicit = true
 
             return resource
         else
             return nil
         end
     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.create(options)
 
         @transient_resources << resource if applying?
         add_resource(resource)
         if @relationship_graph
             @relationship_graph.add_resource(resource) unless @relationship_graph.resource(resource.ref)
         end
         resource
     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.  This will hopefully be deprecated soon.
     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 = Hash.new { |hash, key| hash[key] = [] }
 
         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)
         end
     end
     
     # Create a graph of all of the relationships in our catalog.
     def relationship_graph
         raise(Puppet::DevError, "Tried get a relationship graph for a relationship graph") if self.is_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::Node::Catalog.new
             @relationship_graph.host_config = host_config?
             @relationship_graph.is_relationship_graph = true
             
             # First create the dependency graph
             self.vertices.each do |vertex|
-                @relationship_graph.add_vertex! vertex
+                @relationship_graph.add_vertex vertex
                 vertex.builddepends.each do |edge|
-                    @relationship_graph.add_edge!(edge)
+                    @relationship_graph.add_edge(edge)
                 end
             end
             
             # Lastly, add in any autorequires
             @relationship_graph.vertices.each do |vertex|
                 vertex.autorequire.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)
+                            @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)
             
             # Then splice in the container information
             @relationship_graph.splice!(self, Puppet::Type::Component)
 
             @relationship_graph.write_graph(:expanded_relationships)
         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)
             @aliases[resource.ref].each { |res_alias| @resource_table.delete(res_alias) }
             @aliases[resource.ref].clear
             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::ResourceReference.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::ResourceReference.new(nil, type).to_s
         end
         if resource = @resource_table[ref]
             return resource
         elsif defined?(@relationship_graph) and @relationship_graph
             @relationship_graph.resource(ref)
         end
     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_type
     end
 
     # Turn our parser catalog into a transportable catalog.
     def to_transportable
         to_catalog :to_transobject
     end
 
     # Produce the graph files if requested.
     def write_graph(name)
         # We only want to graph the main host catalog.
         return unless host_config?
         
         return unless Puppet[:graph]
 
         Puppet.settings.use(:graphing)
 
         file = File.join(Puppet[:graphdir], "%s.dot" % name.to_s)
         File.open(file, "w") { |f|
             f.puts to_dot("name" => name.to_s.capitalize)
         }
     end
 
     # LAK:NOTE We cannot yaml-dump the class in the edgelist_class, because classes cannot be
     # dumped by default, nor does yaml-dumping # the edge-labels work at this point (I don't
     # know why).
     #  Neither of these matters right now, but I suppose it could at some point.
     # We also have to have the vertex_dict dumped after the resource table, because yaml can't
     # seem to handle the output of yaml-dumping the vertex_dict.
     def to_yaml_properties
         props = instance_variables.reject { |v| %w{@edgelist_class @edge_labels @vertex_dict}.include?(v) }
         props << "@vertex_dict"
         props
     end
 
     private
 
     def cleanup
         unless @transient_resources.empty?
             remove_resource(*@transient_resources)
             @transient_resources.clear
             @relationship_graph = nil
         end
     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]
 
         # 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 ArgumentError.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)
 
         map = {}
         vertices.each do |resource|
             next if resource.respond_to?(:virtual?) and resource.virtual?
 
             newres = resource.send(convert)
 
             # 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)
+            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/lib/puppet/parser/compiler.rb b/lib/puppet/parser/compiler.rb
index 27860487a..26fdd3743 100644
--- a/lib/puppet/parser/compiler.rb
+++ b/lib/puppet/parser/compiler.rb
@@ -1,467 +1,467 @@
 #  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)
         @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)
+        @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? 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
 
     # 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_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
                 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_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)
 
             # 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)
+        @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/lib/puppet/pgraph.rb b/lib/puppet/pgraph.rb
index 54b815b45..71547802e 100644
--- a/lib/puppet/pgraph.rb
+++ b/lib/puppet/pgraph.rb
@@ -1,158 +1,150 @@
 #  Created by Luke A. Kanies on 2006-11-24.
 #  Copyright (c) 2006. All rights reserved.
 
 require 'puppet/relationship'
 require 'puppet/simple_graph'
 
 # This class subclasses a graph class in order to handle relationships
 # among resources.
 class Puppet::PGraph < Puppet::SimpleGraph
-    # This is the type used for splicing.
-    attr_accessor :container_type
-
     include Puppet::Util
 
-    def add_edge!(*args)
+    def add_edge(*args)
         @reversal = nil
         super
     end
 
-    def add_vertex!(*args)
+    def add_vertex(*args)
         @reversal = nil
         super
     end
 
     # Make sure whichever edge has a label keeps the label
     def copy_label(source, target, label)
         # 'require' relationships will not have a label,
         # and all 'subscribe' relationships have the same
         # label, at least for now.
 
         # Labels default to {}, so we can't just test for nil.
         newlabel = label || {}
         oldlabel = edge_label(source, target) || {}
         if ! newlabel.empty? and oldlabel.empty?
             edge_label_set(source, target, label)
             # We should probably check to see if the labels both exist
             # and don't match, but we'd just throw an error which the user
             # couldn't do anyting about.
         end
     end
 
     # Which resources a given resource depends upon.
     def dependents(resource)
         tree_from_vertex(resource).keys
     end
     
     # Which resources depend upon the given resource.
     def dependencies(resource)
         # Cache the reversal graph, because it's somewhat expensive
         # to create.
         unless defined? @reversal and @reversal
             @reversal = reversal
         end
         # Strangely, it's significantly faster to search a reversed
         # tree in the :out direction than to search a normal tree
         # in the :in direction.
         @reversal.tree_from_vertex(resource, :out).keys
     end
     
-    # Override this method to use our class instead.
-    def edge_class()
-        Puppet::Relationship
-    end
-    
     # Determine all of the leaf nodes below a given vertex.
     def leaves(vertex, direction = :out)
         tree = tree_from_vertex(vertex, direction)
         l = tree.keys.find_all { |c| adjacent(c, :direction => direction).empty? }
         return l
     end
     
     # Collect all of the edges that the passed events match.  Returns
     # an array of edges.
     def matching_edges(events, base = nil)
         events.collect do |event|
             source = base || event.source
 
             unless vertex?(source)
                 Puppet.warning "Got an event from invalid vertex %s" % source.ref
                 next
             end
             # Get all of the edges that this vertex should forward events
             # to, which is the same thing as saying all edges directly below
             # This vertex in the graph.
             adjacent(source, :direction => :out, :type => :edges).find_all do |edge|
                 edge.match?(event.event)
             end
         end.compact.flatten
     end
     
     # Take container information from another graph and use it
     # to replace any container vertices with their respective leaves.
     # This creates direct relationships where there were previously
     # indirect relationships through the containers. 
     def splice!(other, type)
         # We have to get the container list via a topological sort on the
         # configuration graph, because otherwise containers that contain
         # other containers will add those containers back into the
         # graph.  We could get a similar affect by only setting relationships
         # to container leaves, but that would result in many more
         # relationships.
         containers = other.topsort.find_all { |v| v.is_a?(type) and vertex?(v) }
         containers.each do |container|
             # Get the list of children from the other graph.
             children = other.adjacent(container, :direction => :out)
 
             # Just remove the container if it's empty.
             if children.empty?
                 remove_vertex!(container)
                 next
             end
             
             # First create new edges for each of the :in edges
             [:in, :out].each do |dir|
                 edges = adjacent(container, :direction => dir, :type => :edges)
                 edges.each do |edge|
                     children.each do |child|
                         if dir == :in
                             s = edge.source
                             t = child
                         else
                             s = child
                             t = edge.target
                         end
 
                         # We don't want to add multiple copies of the
                         # same edge, but we *do* want to make sure we
                         # keep labels around.
                         # XXX This will *not* work when we support multiple
                         # types of labels, and only works now because
                         # you can only do simple subscriptions.
                         if edge?(s, t)
                             copy_label(s, t, edge.label)
                             next
                         end
-                        add_edge!(s, t, edge.label)
+                        add_edge(s, t, edge.label)
                     end
 
                     # Now get rid of the edge, so remove_vertex! works correctly.
                     remove_edge!(edge)
                     Puppet.debug "%s: %s => %s: %s" % [container,
                         edge.source, edge.target, edge?(edge.source, edge.target)]
                 end
             end
             remove_vertex!(container)
         end
     end
 
     # A different way of walking a tree, and a much faster way than the
     # one that comes with GRATR.
     def tree_from_vertex(start, direction = :out)
         predecessor={}
         walk(start, direction) do |parent, child|
             predecessor[child] = parent
         end
         predecessor       
     end
 end
diff --git a/lib/puppet/simple_graph.rb b/lib/puppet/simple_graph.rb
index 11542ad53..503e4814c 100644
--- a/lib/puppet/simple_graph.rb
+++ b/lib/puppet/simple_graph.rb
@@ -1,315 +1,315 @@
 #  Created by Luke A. Kanies on 2007-11-07.
 #  Copyright (c) 2007. All rights reserved.
 
 require 'puppet/external/dot'
 require 'puppet/relationship'
 
 # A hopefully-faster graph class to replace the use of GRATR.
 class Puppet::SimpleGraph
     # An internal class for handling a vertex's edges.
     class VertexWrapper
         attr_accessor :in, :out, :vertex
 
         # Remove all references to everything.
         def clear
             @adjacencies[:in].clear
             @adjacencies[:out].clear
             @vertex = nil
         end
 
         def initialize(vertex)
             @vertex = vertex
             @adjacencies = {:in => Hash.new { |h,k| h[k] = [] }, :out => Hash.new { |h,k| h[k] = [] }}
             #@adjacencies = {:in => [], :out => []}
         end
 
         # Find adjacent vertices or edges.
         def adjacent(options)
             direction = options[:direction] || :out
             options[:type] ||= :vertices
 
             return @adjacencies[direction].values.flatten if options[:type] == :edges
 
             return @adjacencies[direction].keys
         end
 
         # Add an edge to our list.
         def add_edge(direction, edge)
             @adjacencies[direction][other_vertex(direction, edge)] << edge
         end
 
         # Return all known edges.
         def edges
             [:in, :out].collect { |dir| @adjacencies[dir].values }.flatten
         end
 
         # Test whether we share an edge with a given vertex.
         def has_edge?(direction, vertex)
             return true if @adjacencies[direction][vertex].length > 0
             return false
         end
 
         # Create methods for returning the degree and edges.
         [:in, :out].each do |direction|
             define_method("%s_degree" % direction) do
                 @adjacencies[direction].length
             end
 
             define_method("%s_edges" % direction) do
                 @adjacencies[direction].values.flatten
             end
         end
 
         # The other vertex in the edge.
         def other_vertex(direction, edge)
             case direction
             when :in: edge.source
             else
                 edge.target
             end
         end
 
         # Remove an edge from our list.  Assumes that we've already checked
         # that the edge is valid.
         def remove_edge(direction, edge)
             @adjacencies[direction][other_vertex(direction, edge)].delete(edge)
         end
 
         def to_s
             vertex.to_s
         end
     end
 
     def initialize
         @vertices = {}
         @edges = []
     end
 
     # Clear our graph.
     def clear
         @vertices.each { |vertex, wrapper| wrapper.clear }
         @vertices.clear
         @edges.clear
     end
 
     # Whether our graph is directed.  Always true.  Used to produce dot files.
     def directed?
         true
     end
 
     # Return a reversed version of this graph.
     def reversal
         result = self.class.new
-        vertices.each { |vertex| result.add_vertex!(vertex) }
+        vertices.each { |vertex| result.add_vertex(vertex) }
         edges.each do |edge|
             newedge = edge.class.new(edge.target, edge.source, edge.label)
-            result.add_edge!(newedge)
+            result.add_edge(newedge)
         end
         result
     end
 
     # Return the size of the graph.
     def size
         @vertices.length
     end
 
     # Return the graph as an array.
     def to_a
         @vertices.keys
     end
 
     # Provide a topological sort.
     def topsort
         degree = {}
         zeros = []
         result = []
 
         # Collect each of our vertices, with the number of in-edges each has.
         @vertices.each do |name, wrapper|
             zeros << wrapper if wrapper.in_degree == 0
             degree[wrapper.vertex] = wrapper.in_edges
         end
 
         # Iterate over each 0-degree vertex, decrementing the degree of
         # each of its out-edges.
         while wrapper = zeros.pop do
             result << wrapper.vertex
             wrapper.out_edges.each do |edge|
                 degree[edge.target].delete(edge)
                 zeros << @vertices[edge.target] if degree[edge.target].length == 0
             end
         end
 
         # If we have any vertices left with non-zero in-degrees, then we've found a cycle.
         if cycles = degree.find_all { |vertex, edges| edges.length > 0 } and cycles.length > 0
             message = cycles.collect { |vertex, edges| edges.collect { |e| e.to_s }.join(", ") }.join(", ")
             raise Puppet::Error, "Found dependency cycles in the following relationships: %s" % message
         end
 
         return result
     end
 
     # Add a new vertex to the graph.
-    def add_vertex!(vertex)
+    def add_vertex(vertex)
         return false if vertex?(vertex)
         setup_vertex(vertex)
         true # don't return the VertexWrapper instance.
     end
 
     # Remove a vertex from the graph.
     def remove_vertex!(vertex)
         return nil unless vertex?(vertex)
         @vertices[vertex].edges.each { |edge| remove_edge!(edge) }
         @vertices[vertex].clear
         @vertices.delete(vertex)
     end
 
     # Test whether a given vertex is in the graph.
     def vertex?(vertex)
         @vertices.include?(vertex)
     end
 
     # Return a list of all vertices.
     def vertices
         @vertices.keys
     end
 
     # Add a new edge.  The graph user has to create the edge instance,
     # since they have to specify what kind of edge it is.
-    def add_edge!(source, target = nil, label = nil)
+    def add_edge(source, target = nil, label = nil)
         if target
             edge = Puppet::Relationship.new(source, target, label)
         else
             edge = source
         end
         [edge.source, edge.target].each { |vertex| setup_vertex(vertex) unless vertex?(vertex) }
         @vertices[edge.source].add_edge :out, edge
         @vertices[edge.target].add_edge :in, edge
         @edges << edge
         true
     end
 
     # Find a matching edge.  Note that this only finds the first edge,
     # not all of them or whatever.
     def edge(source, target)
         @edges.each_with_index { |test_edge, index| return test_edge if test_edge.source == source and test_edge.target == target }
     end
 
     def edge_label(source, target)
         return nil unless edge = edge(source, target)
         edge.label
     end
 
     # Is there an edge between the two vertices?
     def edge?(source, target)
         return false unless vertex?(source) and vertex?(target)
 
         @vertices[source].has_edge?(:out, target)
     end
 
     def edges
         @edges.dup
     end
 
     # Remove an edge from our graph.
     def remove_edge!(edge)
         @vertices[edge.source].remove_edge(:out, edge)
         @vertices[edge.target].remove_edge(:in, edge)
         
         # Here we are looking for an exact edge, so we don't want to use ==, because
         # it's too darn expensive (in testing, deleting 3000 edges went from 6 seconds to
         # 0.05 seconds with this change).
         @edges.each_with_index { |test_edge, index| @edges.delete_at(index) and break if edge.equal?(test_edge) }
         nil
     end
 
     # Find adjacent edges.
     def adjacent(vertex, options = {})
         return [] unless wrapper = @vertices[vertex]
         return wrapper.adjacent(options)
     end
 
     private
 
     # An internal method that skips the validation, so we don't have
     # duplicate validation calls.
     def setup_vertex(vertex)
         @vertices[vertex] = VertexWrapper.new(vertex)
     end
  
     public
     
 #    # For some reason, unconnected vertices do not show up in
 #    # this graph.
 #    def to_jpg(path, name)
 #        gv = vertices()
 #        Dir.chdir(path) do
 #            induced_subgraph(gv).write_to_graphic_file('jpg', name)
 #        end
 #    end
 
     def to_yaml_properties
         instance_variables
     end
 
     # Just walk the tree and pass each edge.
     def walk(source, direction, &block)
         adjacent(source, :direction => direction).each do |target|
             yield source, target
             walk(target, direction, &block)
         end
     end
 
     # LAK:FIXME This is just a paste of the GRATR code with slight modifications.
 
     # Return a DOT::DOTDigraph for directed graphs or a DOT::DOTSubgraph for an
     # undirected Graph.  _params_ can contain any graph property specified in
     # rdot.rb. If an edge or vertex label is a kind of Hash then the keys
     # which match +dot+ properties will be used as well.
     def to_dot_graph (params = {})
       params['name'] ||= self.class.name.gsub(/:/,'_')
       fontsize   = params['fontsize'] ? params['fontsize'] : '8'
       graph      = (directed? ? DOT::DOTDigraph : DOT::DOTSubgraph).new(params)
       edge_klass = directed? ? DOT::DOTDirectedEdge : DOT::DOTEdge
       vertices.each do |v|
         name = v.to_s
         params = {'name'     => '"'+name+'"',
                   'fontsize' => fontsize,
                   'label'    => name}
         v_label = v.to_s
         params.merge!(v_label) if v_label and v_label.kind_of? Hash
         graph << DOT::DOTNode.new(params)
       end
       edges.each do |e|
         params = {'from'     => '"'+ e.source.to_s + '"',
                   'to'       => '"'+ e.target.to_s + '"',
                   'fontsize' => fontsize }
         e_label = e.to_s
         params.merge!(e_label) if e_label and e_label.kind_of? Hash
         graph << edge_klass.new(params)
       end
       graph
     end
     
     # Output the dot format as a string
     def to_dot (params={}) to_dot_graph(params).to_s; end
 
     # Call +dotty+ for the graph which is written to the file 'graph.dot'
     # in the # current directory.
     def dotty (params = {}, dotfile = 'graph.dot')
       File.open(dotfile, 'w') {|f| f << to_dot(params) }
       system('dotty', dotfile)
     end
 
     # Use +dot+ to create a graphical representation of the graph.  Returns the
     # filename of the graphics file.
     def write_to_graphic_file (fmt='png', dotfile='graph')
       src = dotfile + '.dot'
       dot = dotfile + '.' + fmt
       
       File.open(src, 'w') {|f| f << self.to_dot << "\n"}
       
       system( "dot -T#{fmt} #{src} -o #{dot}" )
       dot
     end
 end
diff --git a/lib/puppet/transaction.rb b/lib/puppet/transaction.rb
index f304cadc6..976bf7c68 100644
--- a/lib/puppet/transaction.rb
+++ b/lib/puppet/transaction.rb
@@ -1,737 +1,737 @@
 # the class that actually walks our resource/property tree, collects the changes,
 # and performs them
 
 require 'puppet'
 require 'puppet/propertychange'
 
 module Puppet
 class Transaction
     attr_accessor :component, :catalog, :ignoreschedules
     attr_accessor :sorted_resources, :configurator
 
     # The report, once generated.
     attr_reader :report
 
     # The list of events generated in this transaction.
     attr_reader :events
     
     attr_writer :tags
 
     include Puppet::Util
 
     # Add some additional times for reporting
     def addtimes(hash)
         hash.each do |name, num|
             @timemetrics[name] = num
         end
     end
 
     # Check to see if we should actually allow processing, but this really only
     # matters when a resource is getting deleted.
     def allow_processing?(resource, changes)
         # If a resource is going to be deleted but it still has
         # dependencies, then don't delete it unless it's implicit or the
         # dependency is itself being deleted.
         if resource.purging? and resource.deleting?
             if deps = relationship_graph.dependents(resource) and ! deps.empty? and deps.detect { |d| ! d.deleting? }
                 resource.warning "%s still depend%s on me -- not purging" %
                     [deps.collect { |r| r.ref }.join(","), deps.length > 1 ? "":"s"] 
                 return false
             end
         end
 
         return true
     end
 
     # Are there any failed resources in this transaction?
     def any_failed?
         failures = @failures.inject(0) { |failures, array| failures += array[1]; failures }
         if failures > 0
             failures
         else
             false
         end
     end
 
     # Apply all changes for a resource, returning a list of the events
     # generated.
     def apply(resource)
         begin
             changes = resource.evaluate
         rescue => detail
             if Puppet[:trace]
                 puts detail.backtrace
             end
 
             resource.err "Failed to retrieve current state of resource: %s" % detail
 
             # Mark that it failed
             @failures[resource] += 1
 
             # And then return
             return []
         end
 
         changes = [changes] unless changes.is_a?(Array)
 
         if changes.length > 0
             @resourcemetrics[:out_of_sync] += 1
         end
 
         return [] if changes.empty? or ! allow_processing?(resource, changes)
 
         resourceevents = apply_changes(resource, changes)
 
         # If there were changes and the resource isn't in noop mode...
         unless changes.empty? or resource.noop
             # Record when we last synced
             resource.cache(:synced, Time.now)
 
             # Flush, if appropriate
             if resource.respond_to?(:flush)
                 resource.flush
             end
             
             # And set a trigger for refreshing this resource if it's a
             # self-refresher
             if resource.self_refresh? and ! resource.deleting?
                 # Create an edge with this resource as both the source and
                 # target.  The triggering method treats these specially for
                 # logging.
                 events = resourceevents.collect { |e| e.event }
                 set_trigger(Puppet::Relationship.new(resource, resource, :callback => :refresh, :event => events))
             end
         end
 
         resourceevents
     end
 
     # Apply each change in turn.
     def apply_changes(resource, changes)
         changes.collect { |change|
             @changes << change
             @count += 1
             change.transaction = self
             events = nil
             begin
                 # use an array, so that changes can return more than one
                 # event if they want
                 events = [change.forward].flatten.reject { |e| e.nil? }
             rescue => detail
                 if Puppet[:trace]
                     puts detail.backtrace
                 end
                 change.property.err "change from %s to %s failed: %s" %
                     [change.property.is_to_s(change.is), change.property.should_to_s(change.should), detail]
                 @failures[resource] += 1
                 next
                 # FIXME this should support using onerror to determine
                 # behaviour; or more likely, the client calling us
                 # should do so
             end
 
             # Mark that our change happened, so it can be reversed
             # if we ever get to that point
             unless events.nil? or (events.is_a?(Array) and (events.empty?) or events.include?(:noop))
                 change.changed = true
                 @resourcemetrics[:applied] += 1
             end
 
             events
         }.flatten.reject { |e| e.nil? }
     end
 
     # Find all of the changed resources.
     def changed?
         @changes.find_all { |change| change.changed }.collect { |change|
             unless change.property.resource
                 raise "No resource for %s" % change.inspect
             end
             change.property.resource
         }.uniq
     end
     
     # Do any necessary cleanup.  If we don't get rid of the graphs, the
     # contained resources might never get cleaned up.
     def cleanup
         if defined? @generated
             relationship_graph.remove_resource(*@generated)
         end
     end
 
     # Copy an important relationships from the parent to the newly-generated
     # child resource.
     def copy_relationships(resource, children)
         depthfirst = resource.depthfirst?
         
         children.each do |gen_child|
             if depthfirst
                 edge = [gen_child, resource]
             else
                 edge = [resource, gen_child]
             end
             relationship_graph.add_resource(gen_child) unless relationship_graph.resource(gen_child.ref)
 
             unless relationship_graph.edge?(edge[1], edge[0])
-                relationship_graph.add_edge!(*edge)
+                relationship_graph.add_edge(*edge)
             else
                 resource.debug "Skipping automatic relationship to %s" % gen_child
             end
         end
     end
 
     # Are we deleting this resource?
     def deleting?(changes)
         changes.detect { |change|
             change.property.name == :ensure and change.should == :absent
         }
     end
 
     # See if the resource generates new resources at evaluation time.
     def eval_generate(resource)
         if resource.respond_to?(:eval_generate)
             begin
                 children = resource.eval_generate
             rescue => detail
                 if Puppet[:trace]
                     puts detail.backtrace
                 end
                 resource.err "Failed to generate additional resources during transaction: %s" %
                     detail
                 return nil
             end
             
             if children
                 children.each { |child| child.finish }
                 @generated += children
                 return children
             end
         end
     end
     
     # Evaluate a single resource.
     def eval_resource(resource, checkskip = true)
         events = []
         
         if resource.is_a?(Puppet::Type::Component)
             raise Puppet::DevError, "Got a component to evaluate"
         end
         
         if checkskip and skip?(resource)
             @resourcemetrics[:skipped] += 1
         else
             @resourcemetrics[:scheduled] += 1
             
             changecount = @changes.length
             
             # We need to generate first regardless, because the recursive
             # actions sometimes change how the top resource is applied.
             children = eval_generate(resource)
             
             if children and resource.depthfirst?
                 children.each do |child|
                     # The child will never be skipped when the parent isn't
                     events += eval_resource(child, false)
                 end
             end
 
             # Perform the actual changes
             seconds = thinmark do
                 events += apply(resource)
             end
 
             if children and ! resource.depthfirst?
                 children.each do |child|
                     events += eval_resource(child, false)
                 end
             end
 
             # Create a child/parent relationship.  We do this after everything else because
             # we want explicit relationships to be able to override automatic relationships,
             # including this one.
             if children
                 copy_relationships(resource, children)
             end
             
             # A bit of hackery here -- if skipcheck is true, then we're the
             # top-level resource.  If that's the case, then make sure all of
             # the changes list this resource as a proxy.  This is really only
             # necessary for rollback, since we know the generating resource
             # during forward changes.
             if children and checkskip
                 @changes[changecount..-1].each { |change| change.proxy = resource }
             end
 
             # Keep track of how long we spend in each type of resource
             @timemetrics[resource.class.name] += seconds
         end
 
         # Check to see if there are any events for this resource
         if triggedevents = trigger(resource)
             events += triggedevents
         end
 
         # Collect the targets of any subscriptions to those events.  We pass
         # the parent resource in so it will override the source in the events,
         # since eval_generated children can't have direct relationships.
         relationship_graph.matching_edges(events, resource).each do |orig_edge|
             # We have to dup the label here, else we modify the original edge label,
             # which affects whether a given event will match on the next run, which is,
             # of course, bad.
             edge = orig_edge.class.new(orig_edge.source, orig_edge.target)
             label = orig_edge.label.dup
             label[:event] = events.collect { |e| e.event }
             edge.label = label
             set_trigger(edge)
         end
 
         # And return the events for collection
         events
     end
 
     # This method does all the actual work of running a transaction.  It
     # collects all of the changes, executes them, and responds to any
     # necessary events.
     def evaluate
         @count = 0
 
         # Start logging.
         Puppet::Util::Log.newdestination(@report)
         
         prepare()
 
         begin
             allevents = @sorted_resources.collect { |resource|
                 if resource.is_a?(Puppet::Type::Component)
                     Puppet.warning "Somehow left a component in the relationship graph"
                     next
                 end
                 ret = nil
                 seconds = thinmark do
                     ret = eval_resource(resource)
                 end
 
                 if Puppet[:evaltrace] and @catalog.host_config?
                     resource.info "Evaluated in %0.2f seconds" % seconds
                 end
                 ret
             }.flatten.reject { |e| e.nil? }
         ensure
             # And then close the transaction log.
             Puppet::Util::Log.close(@report)
         end
 
         Puppet.debug "Finishing transaction %s with %s changes" %
             [self.object_id, @count]
 
         @events = allevents
         allevents
     end
 
     # Determine whether a given resource has failed.
     def failed?(obj)
         if @failures[obj] > 0
             return @failures[obj]
         else
             return false
         end
     end
 
     # Does this resource have any failed dependencies?
     def failed_dependencies?(resource)
         # First make sure there are no failed dependencies.  To do this,
         # we check for failures in any of the vertexes above us.  It's not
         # enough to check the immediate dependencies, which is why we use
         # a tree from the reversed graph.
         skip = false
         deps = relationship_graph.dependencies(resource)
         deps.each do |dep|
             if fails = failed?(dep)
                 resource.notice "Dependency %s[%s] has %s failures" %
                     [dep.class.name, dep.name, @failures[dep]]
                 skip = true
             end
         end
         
         return skip
     end
     
     # Collect any dynamically generated resources.
     def generate
         list = @catalog.vertices
         
         # Store a list of all generated resources, so that we can clean them up
         # after the transaction closes.
         @generated = []
         
         newlist = []
         while ! list.empty?
             list.each do |resource|
                 if resource.respond_to?(:generate)
                     begin
                         made = resource.generate
                     rescue => detail
                         resource.err "Failed to generate additional resources: %s" %
                             detail
                     end
                     next unless made
                     unless made.is_a?(Array)
                         made = [made]
                     end
                     made.uniq!
                     made.each do |res|
                         @catalog.add_resource(res)
                         res.catalog = catalog
                         newlist << res
                         @generated << res
                         res.finish
                     end
                 end
             end
             list.clear
             list = newlist
             newlist = []
         end
     end
 
     # Generate a transaction report.
     def generate_report
         @resourcemetrics[:failed] = @failures.find_all do |name, num|
             num > 0
         end.length
 
         # Get the total time spent
         @timemetrics[:total] = @timemetrics.inject(0) do |total, vals|
             total += vals[1]
             total
         end
 
         # Add all of the metrics related to resource count and status
         @report.newmetric(:resources, @resourcemetrics)
 
         # Record the relative time spent in each resource.
         @report.newmetric(:time, @timemetrics)
 
         # Then all of the change-related metrics
         @report.newmetric(:changes,
             :total => @changes.length
         )
 
         @report.time = Time.now
 
         return @report
     end
 
     # Should we ignore tags?
     def ignore_tags?
         ! (@catalog.host_config? or Puppet[:name] == "puppet")
     end
 
     # this should only be called by a Puppet::Type::Component resource now
     # and it should only receive an array
     def initialize(resources)
         if resources.is_a?(Puppet::Node::Catalog)
             @catalog = resources
         elsif resources.is_a?(Puppet::PGraph)
             raise "Transactions should get catalogs now, not PGraph"
         else
             raise "Transactions require catalogs"
         end
 
         @resourcemetrics = {
             :total => @catalog.vertices.length,
             :out_of_sync => 0,    # The number of resources that had changes
             :applied => 0,        # The number of resources fixed
             :skipped => 0,      # The number of resources skipped
             :restarted => 0,    # The number of resources triggered
             :failed_restarts => 0, # The number of resources that fail a trigger
             :scheduled => 0     # The number of resources scheduled
         }
 
         # Metrics for distributing times across the different types.
         @timemetrics = Hash.new(0)
 
         # The number of resources that were triggered in this run
         @triggered = Hash.new { |hash, key|
             hash[key] = Hash.new(0)
         }
 
         # Targets of being triggered.
         @targets = Hash.new do |hash, key|
             hash[key] = []
         end
 
         # The changes we're performing
         @changes = []
 
         # The resources that have failed and the number of failures each.  This
         # is used for skipping resources because of failed dependencies.
         @failures = Hash.new do |h, key|
             h[key] = 0
         end
 
         @report = Report.new
         @count = 0
     end
 
     # Prefetch any providers that support it.  We don't support prefetching
     # types, just providers.
     def prefetch
         prefetchers = {}
         @catalog.vertices.each do |resource|
             if provider = resource.provider and provider.class.respond_to?(:prefetch)
                 prefetchers[provider.class] ||= {}
                 prefetchers[provider.class][resource.title] = resource
             end
         end
 
         # Now call prefetch, passing in the resources so that the provider instances can be replaced.
         prefetchers.each do |provider, resources|
             Puppet.debug "Prefetching %s resources for %s" % [provider.name, provider.resource_type.name]
             begin
                 provider.prefetch(resources)
             rescue => detail
                 if Puppet[:trace]
                     puts detail.backtrace
                 end
                 Puppet.err "Could not prefetch %s provider '%s': %s" % [provider.resource_type.name, provider.name, detail]
             end
         end
     end
     
     # Prepare to evaluate the resources in a transaction.
     def prepare
         prefetch()
     
         # Now add any dynamically generated resources
         generate()
         
         # This will throw an error if there are cycles in the graph.
         @sorted_resources = relationship_graph.topsort
     end
 
     def relationship_graph
         catalog.relationship_graph
     end
     
     # Send off the transaction report.
     def send_report
         begin
             report = generate_report()
         rescue => detail
             Puppet.err "Could not generate report: %s" % detail
             return
         end
 
         if Puppet[:rrdgraph] == true
             report.graph()
         end
 
         if Puppet[:summarize]
             puts report.summary
         end
         
         if Puppet[:report]
             begin
                 reportclient().report(report)
             rescue => detail
                 Puppet.err "Reporting failed: %s" % detail
             end
         end
     end
 
     def reportclient
         unless defined? @reportclient
             @reportclient = Puppet::Network::Client.report.new(
                 :Server => Puppet[:reportserver]
             )
         end
 
         @reportclient
     end
 
     # Roll all completed changes back.
     def rollback
         @targets.clear
         @triggered.clear
         allevents = @changes.reverse.collect { |change|
             # skip changes that were never actually run
             unless change.changed
                 Puppet.debug "%s was not changed" % change.to_s
                 next
             end
             begin
                 events = change.backward
             rescue => detail
                 Puppet.err("%s rollback failed: %s" % [change,detail])
                 if Puppet[:trace]
                     puts detail.backtrace
                 end
                 next
                 # at this point, we would normally do error handling
                 # but i haven't decided what to do for that yet
                 # so just record that a sync failed for a given resource
                 #@@failures[change.property.parent] += 1
                 # this still could get hairy; what if file contents changed,
                 # but a chmod failed?  how would i handle that error? dern
             end
             
             # FIXME This won't work right now.
             relationship_graph.matching_edges(events).each do |edge|
                 @targets[edge.target] << edge
             end
 
             # Now check to see if there are any events for this child.
             # Kind of hackish, since going backwards goes a change at a
             # time, not a child at a time.
             trigger(change.property.resource)
 
             # And return the events for collection
             events
         }.flatten.reject { |e| e.nil? }
     end
     
     # Is the resource currently scheduled?
     def scheduled?(resource)
         self.ignoreschedules or resource.scheduled?
     end
 
     # Set an edge to be triggered when we evaluate its target.
     def set_trigger(edge)
         return unless method = edge.callback
         return unless edge.target.respond_to?(method)
         if edge.target.respond_to?(:ref)
             unless edge.source == edge.target
                 edge.source.info "Scheduling %s of %s" % [edge.callback, edge.target.ref]
             end
         end
         @targets[edge.target] << edge
     end
     
     # Should this resource be skipped?
     def skip?(resource)
         skip = false
         if missing_tags?(resource)
             resource.debug "Not tagged with %s" % tags.join(", ")
         elsif ! scheduled?(resource)
             resource.debug "Not scheduled"
         elsif failed_dependencies?(resource)
             resource.warning "Skipping because of failed dependencies"
         else
             return false
         end
         return true
     end
     
     # The tags we should be checking.
     def tags
         unless defined? @tags
             tags = Puppet[:tags]
             if tags.nil? or tags == ""
                 @tags = []
             else
                 @tags = tags.split(/\s*,\s*/)
             end
         end
         
         @tags
     end
     
     # Is this resource tagged appropriately?
     def missing_tags?(resource)
         return false if self.ignore_tags? or tags.empty?
         return true unless resource.tagged?(tags)
     end
     
     # Are there any edges that target this resource?
     def targeted?(resource)
         # The default value is a new array so we have to test the length of it.
         @targets.include?(resource) and @targets[resource].length > 0
     end
 
     # Trigger any subscriptions to a child.  This does an upwardly recursive
     # search -- it triggers the passed resource, but also the resource's parent
     # and so on up the tree.
     def trigger(resource)
         return nil unless targeted?(resource)
         callbacks = Hash.new { |hash, key| hash[key] = [] }
 
         trigged = []
         @targets[resource].each do |edge|
             # Collect all of the subs for each callback
             callbacks[edge.callback] << edge
         end
 
         callbacks.each do |callback, subs|
             noop = true
             subs.each do |edge|
                 if edge.event.nil? or ! edge.event.include?(:noop)
                     noop = false
                 end
             end
 
             if noop
                 resource.notice "Would have triggered %s from %s dependencies" %
                     [callback, subs.length]
 
                 # And then add an event for it.
                 return [Puppet::Event.new(
                     :event => :noop,
                     :transaction => self,
                     :source => resource
                 )]
             end
 
             if subs.length == 1 and subs[0].source == resource
                 message = "Refreshing self"
             else
                 message = "Triggering '%s' from %s dependencies" %
                     [callback, subs.length]
             end
             resource.notice message
             
             # At this point, just log failures, don't try to react
             # to them in any way.
             begin
                 resource.send(callback)
                 @resourcemetrics[:restarted] += 1
             rescue => detail
                 resource.err "Failed to call %s on %s: %s" %
                     [callback, resource, detail]
 
                 @resourcemetrics[:failed_restarts] += 1
 
                 if Puppet[:trace]
                     puts detail.backtrace
                 end
             end
 
             # And then add an event for it.
             trigged << Puppet::Event.new(
                 :event => :triggered,
                 :transaction => self,
                 :source => resource
             )
 
             triggered(resource, callback)
         end
 
         if trigged.empty?
             return nil
         else
             return trigged
         end
     end
 
     def triggered(resource, method)
         @triggered[resource][method] += 1
     end
 
     def triggered?(resource, method)
         @triggered[resource][method]
     end
 end
 end
 
 require 'puppet/transaction/report'
 
diff --git a/lib/puppet/transportable.rb b/lib/puppet/transportable.rb
index c1d68a881..f686fbb78 100644
--- a/lib/puppet/transportable.rb
+++ b/lib/puppet/transportable.rb
@@ -1,247 +1,247 @@
 require 'puppet'
 require 'puppet/resource_reference'
 require 'yaml'
 
 module Puppet
     # The transportable objects themselves.  Basically just a hash with some
     # metadata and a few extra methods.  I used to have the object actually
     # be a subclass of Hash, but I could never correctly dump them using
     # YAML.
     class TransObject
         include Enumerable
         attr_accessor :type, :name, :file, :line, :catalog
 
         attr_writer :tags
 
         %w{has_key? include? length delete empty? << [] []=}.each { |method|
             define_method(method) do |*args|
                 @params.send(method, *args)
             end
         }
 
         def each
             @params.each { |p,v| yield p, v }
         end
 
         def initialize(name,type)
             @type = type.to_s.downcase
             @name = name
             @params = {}
             @tags = []
         end
 
         def longname
             return [@type,@name].join('--')
         end
 
         def ref
             unless defined? @ref
                 @ref = Puppet::ResourceReference.new(@type, @name)
             end
             @ref.to_s
         end
 
         def tags
             return @tags
         end
 
         # Convert a defined type into a component.
         def to_component
             trans = TransObject.new(ref, :component)
             @params.each { |param,value|
                 next unless Puppet::Type::Component.validattr?(param)
                 Puppet.debug "Defining %s on %s" % [param, ref]
                 trans[param] = value
             }
             Puppet::Type::Component.create(trans)
         end
 
         def to_hash
             @params.dup
         end
 
         def to_s
             return "%s(%s) => %s" % [@type,@name,super]
         end
 
         def to_manifest
             "#{self.type.to_s} { \'#{self.name}\':\n%s\n}" % @params.collect { |p, v|
                 if v.is_a? Array
                     "    #{p} => [\'#{v.join("','")}\']"
                 else
                     "    #{p} => \'#{v}\'"
                 end
             }.join(",\n")
         end
 
         def to_yaml_properties
             instance_variables.reject { |v| %w{@ref}.include?(v) }
         end
 
         def to_ref
             ref
         end
 
         def to_type
             retobj = nil
             if typeklass = Puppet::Type.type(self.type)
                 return typeklass.create(self)
             else
                 return to_component
             end
 
             return retobj
         end
     end
 
     # Just a linear container for objects.  Behaves mostly like an array, except
     # that YAML will correctly dump them even with their instance variables.
     class TransBucket
         include Enumerable
 
         attr_accessor :name, :type, :file, :line, :classes, :keyword, :top, :catalog
 
         %w{delete shift include? length empty? << []}.each { |method|
             define_method(method) do |*args|
                 #Puppet.warning "Calling %s with %s" % [method, args.inspect]
                 @children.send(method, *args)
                 #Puppet.warning @params.inspect
             end
         }
 
         # Recursively yield everything.
         def delve(&block)
             @children.each do |obj|
                 block.call(obj)
                 if obj.is_a? self.class
                     obj.delve(&block)
                 else
                     obj
                 end
             end
         end
 
         def each
             @children.each { |c| yield c }
         end
 
         # Turn our heirarchy into a flat list
         def flatten
             @children.collect do |obj|
                 if obj.is_a? Puppet::TransBucket
                     obj.flatten
                 else
                     obj
                 end
             end.flatten
         end
 
         def initialize(children = [])
             @children = children
         end
 
         def push(*args)
             args.each { |arg|
                 case arg
                 when Puppet::TransBucket, Puppet::TransObject
                     # nada
                 else
                     raise Puppet::DevError,
                         "TransBuckets cannot handle objects of type %s" %
                             arg.class
                 end
             }
             @children += args
         end
 
         # Convert to a parseable manifest
         def to_manifest
             unless self.top
                 unless defined? @keyword and @keyword
                     raise Puppet::DevError, "No keyword; cannot convert to manifest"
                 end
             end
 
             str = "#{@keyword} #{@name} {\n%s\n}"
             str % @children.collect { |child|
                 child.to_manifest
             }.collect { |str|
                 if self.top
                     str
                 else
                     str.gsub(/^/, "    ") # indent everything once
                 end
             }.join("\n\n") # and throw in a blank line
         end
 
         def to_yaml_properties
             instance_variables
         end
 
         # Create a resource graph from our structure.
         def to_catalog
             catalog = Puppet::Node::Catalog.new(Facter.value("hostname")) do |config|
                 delver = proc do |obj|
                     obj.catalog = config
                     unless container = config.resource(obj.to_ref)
                         container = obj.to_type
                         config.add_resource container
                     end
                     obj.each do |child|
                         child.catalog = config
                         unless resource = config.resource(child.to_ref)
                             next unless resource = child.to_type
                             config.add_resource resource
                         end
-                        config.add_edge!(container, resource)
+                        config.add_edge(container, resource)
                         if child.is_a?(self.class)
                             delver.call(child)
                         end
                     end
                 end
                 
                 delver.call(self)
             end
             
             return catalog
         end
 
         def to_ref
             unless defined? @ref
                 if self.type and self.name
                     @ref = Puppet::ResourceReference.new(self.type, self.name)
                 elsif self.type and ! self.name # This is old-school node types
                     @ref = Puppet::ResourceReference.new("node", self.type)
                 elsif ! self.type and self.name
                     @ref = Puppet::ResourceReference.new("component", self.name)
                 else
                     @ref = nil
                 end
             end
             @ref.to_s if @ref
         end
 
         def to_type
             Puppet.debug("TransBucket '%s' has no type" % @name) unless defined? @type
 
             # Nodes have the same name and type
             trans = TransObject.new(to_ref, :component)
             if defined? @parameters
                 @parameters.each { |param,value|
                     Puppet.debug "Defining %s on %s" % [param, to_ref]
                     trans[param] = value
                 }
             end
             return Puppet::Type::Component.create(trans)
         end
 
         def param(param,value)
             unless defined? @parameters
                 @parameters = {}
             end
             @parameters[param] = value
         end
 
     end
 end
 
diff --git a/lib/puppet/type/pfile.rb b/lib/puppet/type/pfile.rb
index 7d928d959..c32a4d474 100644
--- a/lib/puppet/type/pfile.rb
+++ b/lib/puppet/type/pfile.rb
@@ -1,1171 +1,1171 @@
 require 'digest/md5'
 require 'cgi'
 require 'etc'
 require 'uri'
 require 'fileutils'
 require 'puppet/network/handler'
 require 'puppet/util/diff'
 
 module Puppet
     newtype(:file) do
         include Puppet::Util::MethodHelper
         @doc = "Manages local files, including setting ownership and
             permissions, creation of both files and directories, and
             retrieving entire files from remote servers.  As Puppet matures, it
             expected that the ``file`` resource will be used less and less to
             manage content, and instead native resources will be used to do so.
             
             If you find that you are often copying files in from a central
             location, rather than using native resources, please contact
             Reductive Labs and we can hopefully work with you to develop a
             native resource to support what you are doing."
 
         newparam(:path) do
             desc "The path to the file to manage.  Must be fully qualified."
             isnamevar
 
             validate do |value|
                 unless value =~ /^#{File::SEPARATOR}/
                     raise Puppet::Error, "File paths must be fully qualified"
                 end
             end
         end
 
         newparam(:backup) do
             desc "Whether files should be backed up before
                 being replaced.  The preferred method of backing files up is via
                 a ``filebucket``, which stores files by their MD5 sums and allows
                 easy retrieval without littering directories with backups.  You
                 can specify a local filebucket or a network-accessible
                 server-based filebucket by setting ``backup => bucket-name``.
                 Alternatively, if you specify any value that begins with a ``.``
                 (e.g., ``.puppet-bak``), then Puppet will use copy the file in
                 the same directory with that value as the extension of the
                 backup. Setting ``backup => false`` disables all backups of the
                 file in question.
                 
                 Puppet automatically creates a local filebucket named ``puppet`` and
                 defaults to backing up there.  To use a server-based filebucket,
                 you must specify one in your configuration::
                     
                     filebucket { main:
                         server => puppet
                     }
 
                 The ``puppetmasterd`` daemon creates a filebucket by default,
                 so you can usually back up to your main server with this
                 configuration.  Once you've described the bucket in your
                 configuration, you can use it in any file::
 
                     file { \"/my/file\":
                         source => \"/path/in/nfs/or/something\",
                         backup => main
                     }
 
                 This will back the file up to the central server.
 
                 At this point, the benefits of using a filebucket are that you do not
                 have backup files lying around on each of your machines, a given
                 version of a file is only backed up once, and you can restore
                 any given file manually, no matter how old.  Eventually,
                 transactional support will be able to automatically restore
                 filebucketed files.
                 "
 
             defaultto { "puppet" }
             
             munge do |value|
                 # I don't really know how this is happening.
                 if value.is_a?(Array)
                     value = value.shift
                 end
                 case value
                 when false, "false", :false:
                     false
                 when true, "true", ".puppet-bak", :true:
                     ".puppet-bak"
                 when /^\./
                     value
                 when String:
                     # We can't depend on looking this up right now,
                     # we have to do it after all of the objects
                     # have been instantiated.
                     if bucketobj = Puppet::Type.type(:filebucket)[value]
                         @resource.bucket = bucketobj.bucket
                         bucketobj.title
                     else
                         # Set it to the string; finish() turns it into a
                         # filebucket.
                         @resource.bucket = value
                         value
                     end
                 when Puppet::Network::Client.client(:Dipper):
                     @resource.bucket = value
                     value.name
                 else
                     self.fail "Invalid backup type %s" %
                         value.inspect
                 end
             end
         end
 
         newparam(:recurse) do
             desc "Whether and how deeply to do recursive
                 management."
 
             newvalues(:true, :false, :inf, /^[0-9]+$/)
 
             # Replace the validation so that we allow numbers in
             # addition to string representations of them.
             validate { |arg| }
             munge do |value|
                 newval = super(value)
                 case newval
                 when :true, :inf: true
                 when :false: false
                 when Integer, Fixnum, Bignum: value
                 when /^\d+$/: Integer(value)
                 else
                     raise ArgumentError, "Invalid recurse value %s" % value.inspect
                 end
             end
         end
 
         newparam(:replace, :boolean => true) do
             desc "Whether or not to replace a file that is
                 sourced but exists.  This is useful for using file sources
                 purely for initialization."
             newvalues(:true, :false)
             aliasvalue(:yes, :true)
             aliasvalue(:no, :false)
             defaultto :true
         end
 
         newparam(:force, :boolean => true) do
             desc "Force the file operation.  Currently only used when replacing
                 directories with links."
             newvalues(:true, :false)
             defaultto false
         end
 
         newparam(:ignore) do
             desc "A parameter which omits action on files matching
                 specified patterns during recursion.  Uses Ruby's builtin globbing
                 engine, so shell metacharacters are fully supported, e.g. ``[a-z]*``.
                 Matches that would descend into the directory structure are ignored,
                 e.g., ``*/*``."
        
             defaultto false
 
             validate do |value|
                 unless value.is_a?(Array) or value.is_a?(String) or value == false
                     self.devfail "Ignore must be a string or an Array"
                 end
             end
         end
 
         newparam(:links) do
             desc "How to handle links during file actions.  During file copying,
                 ``follow`` will copy the target file instead of the link, ``manage``
                 will copy the link itself, and ``ignore`` will just pass it by.
                 When not copying, ``manage`` and ``ignore`` behave equivalently
                 (because you cannot really ignore links entirely during local
                 recursion), and ``follow`` will manage the file to which the
                 link points."
 
             newvalues(:follow, :manage, :ignore)
 
             # :ignore and :manage behave equivalently on local files,
             # but don't copy remote links
             defaultto :ignore
         end
 
         newparam(:purge, :boolean => true) do
             desc "Whether unmanaged files should be purged.  If you have a filebucket
                 configured the purged files will be uploaded, but if you do not,
                 this will destroy data.  Only use this option for generated
                 files unless you really know what you are doing.  This option only
                 makes sense when recursively managing directories.
                 
                 Note that when using ``purge`` with ``source``, Puppet will purge any files
                 that are not on the remote system."
 
             defaultto :false
 
             newvalues(:true, :false)
         end
 
         newparam(:sourceselect) do
             desc "Whether to copy all valid sources, or just the first one.  This parameter
                 is only used in recursive copies; by default, the first valid source is the
                 only one used as a recursive source, but if this parameter is set to ``all``,
                 then all valid sources will have all of their contents copied to the local host,
                 and for sources that have the same file, the source earlier in the list will
                 be used."
 
             defaultto :first
 
             newvalues(:first, :all)
         end
         
         attr_accessor :bucket
 
         # Autorequire any parent directories.
         autorequire(:file) do
             if self[:path]
                 File.dirname(self[:path])
             else
                 Puppet.err "no path for %s, somehow; cannot setup autorequires" % self.ref
                 nil
             end
         end
 
         # Autorequire the owner and group of the file.
         {:user => :owner, :group => :group}.each do |type, property|
             autorequire(type) do
                 if @parameters.include?(property)
                     # The user/group property automatically converts to IDs
                     next unless should = @parameters[property].shouldorig
                     val = should[0]
                     if val.is_a?(Integer) or val =~ /^\d+$/
                         nil
                     else
                         val
                     end
                 end
             end
         end
         
         CREATORS = [:content, :source, :target]
 
         validate do
             count = 0
             CREATORS.each do |param|
                 count += 1 if self.should(param)
             end
             if count > 1
                 self.fail "You cannot specify more than one of %s" % CREATORS.collect { |p| p.to_s}.join(", ")
             end
         end
         
         def self.[](path)
             return nil unless path
             super(path.gsub(/\/+/, '/').sub(/\/$/, ''))
         end
 
         # List files, but only one level deep.
         def self.instances(base = "/")
             unless FileTest.directory?(base)
                 return []
             end
 
             files = []
             Dir.entries(base).reject { |e|
                 e == "." or e == ".."
             }.each do |name|
                 path = File.join(base, name)
                 if obj = self[path]
                     obj[:check] = :all
                     files << obj
                 else
                     files << self.create(
                         :name => path, :check => :all
                     )
                 end
             end
             files
         end
 
         @depthfirst = false
 
 
         def argument?(arg)
             @arghash.include?(arg)
         end
 
         # Determine the user to write files as.
         def asuser
             if self.should(:owner) and ! self.should(:owner).is_a?(Symbol)
                 writeable = Puppet::Util::SUIDManager.asuser(self.should(:owner)) {
                     FileTest.writable?(File.dirname(self[:path]))
                 }
 
                 # If the parent directory is writeable, then we execute
                 # as the user in question.  Otherwise we'll rely on
                 # the 'owner' property to do things.
                 if writeable
                     asuser = self.should(:owner)
                 end
             end
 
             return asuser
         end
 
         # We have to do some extra finishing, to retrieve our bucket if
         # there is one.
         def finish
             # Let's cache these values, since there should really only be
             # a couple of these buckets
             @@filebuckets ||= {}
 
             # Look up our bucket, if there is one
             if bucket = self.bucket
                 case bucket
                 when String:
                     if obj = @@filebuckets[bucket]
                         # This sets the @value on :backup, too
                         self.bucket = obj
                     elsif bucket == "puppet"
                         obj = Puppet::Network::Client.client(:Dipper).new(
                             :Path => Puppet[:clientbucketdir]
                         )
                         self.bucket = obj
                         @@filebuckets[bucket] = obj
                     elsif obj = Puppet::Type.type(:filebucket).bucket(bucket)
                         @@filebuckets[bucket] = obj
                         self.bucket = obj
                     else
                         self.fail "Could not find filebucket %s" % bucket
                     end
                 when Puppet::Network::Client.client(:Dipper): # things are hunky-dorey
                 else
                     self.fail "Invalid bucket type %s" % bucket.class
                 end
             end
             super
         end
         
         # Create any children via recursion or whatever.
         def eval_generate
             recurse()
         end
 
         # Deal with backups.
         def handlebackup(file = nil)
             # let the path be specified
             file ||= self[:path]
             # if they specifically don't want a backup, then just say
             # we're good
             unless FileTest.exists?(file)
                 return true
             end
 
             unless self[:backup]
                 return true
             end
 
             case File.stat(file).ftype
             when "directory":
                 if self[:recurse]
                     # we don't need to backup directories when recurse is on
                     return true
                 else
                     backup = self.bucket || self[:backup]
                     case backup
                     when Puppet::Network::Client.client(:Dipper):
                         notice "Recursively backing up to filebucket"
                         require 'find'
                         Find.find(self[:path]) do |f|
                             if File.file?(f)
                                 sum = backup.backup(f)
                                 self.info "Filebucketed %s to %s with sum %s" %
                                     [f, backup.name, sum]
                             end
                         end
 
                         return true
                     when String:
                         newfile = file + backup
                         # Just move it, since it's a directory.
                         if FileTest.exists?(newfile)
                             remove_backup(newfile)
                         end
                         begin
                             bfile = file + backup
 
                             # Ruby 1.8.1 requires the 'preserve' addition, but
                             # later versions do not appear to require it.
                             FileUtils.cp_r(file, bfile, :preserve => true)
                             return true
                         rescue => detail
                             # since they said they want a backup, let's error out
                             # if we couldn't make one
                             self.fail "Could not back %s up: %s" %
                                 [file, detail.message]
                         end
                     else
                         self.err "Invalid backup type %s" % backup.inspect
                         return false
                     end
                 end
             when "file":
                 backup = self.bucket || self[:backup]
                 case backup
                 when Puppet::Network::Client.client(:Dipper):
                     sum = backup.backup(file)
                     self.info "Filebucketed to %s with sum %s" %
                         [backup.name, sum]
                     return true
                 when String:
                     newfile = file + backup
                     if FileTest.exists?(newfile)
                         remove_backup(newfile)
                     end
                     begin
                         # FIXME Shouldn't this just use a Puppet object with
                         # 'source' specified?
                         bfile = file + backup
 
                         # Ruby 1.8.1 requires the 'preserve' addition, but
                         # later versions do not appear to require it.
                         FileUtils.cp(file, bfile, :preserve => true)
                         return true
                     rescue => detail
                         # since they said they want a backup, let's error out
                         # if we couldn't make one
                         self.fail "Could not back %s up: %s" %
                             [file, detail.message]
                     end
                 else
                     self.err "Invalid backup type %s" % backup.inspect
                     return false
                 end
             when "link": return true
             else
                 self.notice "Cannot backup files of type %s" %
                     File.stat(file).ftype
                 return false
             end
         end
         
         def handleignore(children)
             return children unless self[:ignore]
             self[:ignore].each { |ignore|
                 ignored = []
                 Dir.glob(File.join(self[:path],ignore), File::FNM_DOTMATCH) {
                     |match| ignored.push(File.basename(match))
                 }
                 children = children - ignored
             }
             return children
         end
           
         def initialize(hash)
             # Store a copy of the arguments for later.
             tmphash = hash.to_hash
 
             # Used for caching clients
             @clients = {}
 
             super
 
             # Get rid of any duplicate slashes, and remove any trailing slashes.
             @title = @title.gsub(/\/+/, "/")
             
             @title.sub!(/\/$/, "") unless @title == "/"
 
             # Clean out as many references to any file paths as possible.
             # This was the source of many, many bugs.
             @arghash = tmphash
             @arghash.delete(self.class.namevar)
 
             [:source, :parent].each do |param|
                 if @arghash.include?(param)
                     @arghash.delete(param)
                 end
             end
 
             @stat = nil
         end
 
         # Build a recursive map of a link source
         def linkrecurse(recurse)
             target = @parameters[:target].should
 
             method = :lstat
             if self[:links] == :follow
                 method = :stat
             end
 
             targetstat = nil
             unless FileTest.exist?(target)
                 return
             end
             # Now stat our target
             targetstat = File.send(method, target)
             unless targetstat.ftype == "directory"
                 return
             end
 
             # Now that we know our corresponding target is a directory,
             # change our type
             self[:ensure] = :directory
 
             unless FileTest.readable? target
                 self.notice "Cannot manage %s: permission denied" % self.name
                 return
             end
 
             children = Dir.entries(target).reject { |d| d =~ /^\.+$/ }
          
             # Get rid of ignored children
             if @parameters.include?(:ignore)
                 children = handleignore(children)
             end
 
             added = []
             children.each do |file|
                 Dir.chdir(target) do
                     longname = File.join(target, file)
 
                     # Files know to create directories when recursion
                     # is enabled and we're making links
                     args = {
                         :recurse => recurse,
                         :ensure => longname
                     }
 
                     if child = self.newchild(file, true, args)
                         added << child
                     end
                 end
             end
             
             added
         end
 
         # Build up a recursive map of what's around right now
         def localrecurse(recurse)
             unless FileTest.exist?(self[:path]) and self.stat.directory?
                 #self.info "%s is not a directory; not recursing" %
                 #    self[:path]
                 return
             end
 
             unless FileTest.readable? self[:path]
                 self.notice "Cannot manage %s: permission denied" % self.name
                 return
             end
 
             children = Dir.entries(self[:path])
          
             #Get rid of ignored children
             if @parameters.include?(:ignore)
                 children = handleignore(children)
             end
 
             added = []
             children.each { |file|
                 file = File.basename(file)
                 next if file =~ /^\.\.?$/ # skip . and .. 
                 options = {:recurse => recurse}
 
                 if child = self.newchild(file, true, options)
                     added << child
                 end
             }
             
             added
         end
         
         # Create a new file or directory object as a child to the current
         # object.
         def newchild(path, local, hash = {})
             raise(Puppet::DevError, "File recursion cannot happen without a catalog") unless catalog
 
             # make local copy of arguments
             args = symbolize_options(@arghash)
 
             # There's probably a better way to do this, but we don't want
             # to pass this info on.
             if v = args[:ensure]
                 v = symbolize(v)
                 args.delete(:ensure)
             end
 
             if path =~ %r{^#{File::SEPARATOR}}
                 self.devfail(
                     "Must pass relative paths to PFile#newchild()"
                 )
             else
                 path = File.join(self[:path], path)
             end
 
             args[:path] = path
 
             unless hash.include?(:recurse)
                 if args.include?(:recurse)
                     if args[:recurse].is_a?(Integer)
                         args[:recurse] -= 1 # reduce the level of recursion
                     end
                 end
 
             end
 
             hash.each { |key,value|
                 args[key] = value
             }
 
             child = nil
 
             # The child might already exist because 'localrecurse' runs
             # before 'sourcerecurse'.  I could push the override stuff into
             # a separate method or something, but the work is the same other
             # than this last bit, so it doesn't really make sense.
             if child = catalog.resource(:file, path)
                 unless child.parent.object_id == self.object_id
                     self.debug "Not managing more explicit file %s" %
                         path
                     return nil
                 end
 
                 # This is only necessary for sourcerecurse, because we might have
                 # created the object with different 'should' values than are
                 # set remotely.
                 unless local
                     args.each { |var,value|
                         next if var == :path
                         next if var == :name
 
                         # behave idempotently
                         unless child.should(var) == value
                             child[var] = value
                         end
                     }
                 end
                 return nil
             else # create it anew
                 #notice "Creating new file with args %s" % args.inspect
                 args[:parent] = self
                 begin
                     # This method is used by subclasses of :file, so use the class name rather than hard-coding
                     # :file.
                     return nil unless child = catalog.create_implicit_resource(self.class.name, args)
                 rescue => detail
                     puts detail.backtrace
                     self.notice "Cannot manage: %s" % [detail]
                     return nil
                 end
             end
 
             # LAK:FIXME This shouldn't be necessary, but as long as we're
             # modeling the relationship graph specifically, it is.
-            catalog.relationship_graph.add_edge! self, child
+            catalog.relationship_graph.add_edge self, child
 
             return child
         end
 
         # Files handle paths specially, because they just lengthen their
         # path names, rather than including the full parent's title each
         # time.
         def pathbuilder
             # We specifically need to call the method here, so it looks
             # up our parent in the catalog graph.
             if parent = parent()
                 # We only need to behave specially when our parent is also
                 # a file
                 if parent.is_a?(self.class)
                     # Remove the parent file name
                     list = parent.pathbuilder
                     list.pop # remove the parent's path info
                     return list << self.ref
                 else
                     return super
                 end
             else
                 return [self.ref]
             end
         end
         
         # Should we be purging?
         def purge?
             @parameters.include?(:purge) and (self[:purge] == :true or self[:purge] == "true")
         end
 
         # Recurse into the directory.  This basically just calls 'localrecurse'
         # and maybe 'sourcerecurse', returning the collection of generated
         # files.
         def recurse
             # are we at the end of the recursion?
             return unless self.recurse?
 
             recurse = self[:recurse]
             # we might have a string, rather than a number
             if recurse.is_a?(String)
                 if recurse =~ /^[0-9]+$/
                     recurse = Integer(recurse)
                 else # anything else is infinite recursion
                     recurse = true
                 end
             end
 
             if recurse.is_a?(Integer)
                 recurse -= 1
             end
             
             children = []
             
             # We want to do link-recursing before normal recursion so that all
             # of the target stuff gets copied over correctly.
             if @parameters.include? :target and ret = self.linkrecurse(recurse)
                 children += ret
             end
             if ret = self.localrecurse(recurse)
                 children += ret
             end
 
             # These will be files pulled in by the file source
             sourced = false
             if @parameters.include?(:source)
                 ret, sourced = self.sourcerecurse(recurse)
                 if ret
                     children += ret
                 end
             end
 
             # The purge check needs to happen after all of the other recursion.
             if self.purge?
                 children.each do |child|
                     if (sourced and ! sourced.include?(child[:path])) or ! child.managed?
                         child[:ensure] = :absent
                     end
                 end
             end
             
             children
         end
 
         # A simple method for determining whether we should be recursing.
         def recurse?
             return false unless @parameters.include?(:recurse)
 
             val = @parameters[:recurse].value
 
             if val and (val == true or val > 0)
                 return true
             else
                 return false
             end
         end
 
         # Remove the old backup.
         def remove_backup(newfile)
             if self.class.name == :file and self[:links] != :follow
                 method = :lstat
             else
                 method = :stat
             end
             old = File.send(method, newfile).ftype
 
             if old == "directory"
                 raise Puppet::Error,
                     "Will not remove directory backup %s; use a filebucket" %
                     newfile
             end
 
             info "Removing old backup of type %s" %
                 File.send(method, newfile).ftype
 
             begin
                 File.unlink(newfile)
             rescue => detail
                 if Puppet[:trace]
                     puts detail.backtrace
                 end
                 self.err "Could not remove old backup: %s" %
                     detail
                 return false
             end
         end
 
         # Remove any existing data.  This is only used when dealing with
         # links or directories.
         def remove_existing(should)
             return unless s = stat(true)
 
             unless handlebackup
                 self.fail "Could not back up; will not replace"
             end
 
             unless should.to_s == "link"
                 return if s.ftype.to_s == should.to_s 
             end
 
             case s.ftype
             when "directory":
                 if self[:force] == :true
                     debug "Removing existing directory for replacement with %s" %
                         should
                     FileUtils.rmtree(self[:path])
                 else
                     notice "Not removing directory; use 'force' to override"
                 end
             when "link", "file":
                 debug "Removing existing %s for replacement with %s" %
                     [s.ftype, should]
                 File.unlink(self[:path])
             else
                 self.fail "Could not back up files of type %s" % s.ftype
             end
         end
 
         # a wrapper method to make sure the file exists before doing anything
         def retrieve
             unless stat = self.stat(true)
                 self.debug "File does not exist"
                 # If the file doesn't exist but we have a source, then call
                 # retrieve on that property
 
                 propertyvalues = properties().inject({}) { |hash, property|
                                      hash[property] = :absent
                                      hash
                                   }
 
                 if @parameters.include?(:source)
                     propertyvalues[:source] = @parameters[:source].retrieve
                 end
                 return propertyvalues
             end
 
             return currentpropvalues()
         end
 
         # This recurses against the remote source and makes sure the local
         # and remote structures match.  It's run after 'localrecurse'.  This
         # method only does anything when its corresponding remote entry is
         # a directory; in that case, this method creates file objects that
         # correspond to any contained remote files.
         def sourcerecurse(recurse)
             # we'll set this manually as necessary
             if @arghash.include?(:ensure)
                 @arghash.delete(:ensure)
             end
             
             r = false
             if recurse
                 unless recurse == 0
                     r = 1
                 end
             end
             
             ignore = self[:ignore]
 
             result = []
             found = []
 
             # Keep track of all the files we found in the source, so we can purge
             # appropriately.
             sourced = []
             
             @parameters[:source].should.each do |source|
                 sourceobj, path = uri2obj(source)
 
                 # okay, we've got our source object; now we need to
                 # build up a local file structure to match the remote
                 # one
 
                 server = sourceobj.server
 
                 desc = server.list(path, self[:links], r, ignore)
                 if desc == "" 
                     next
                 end
             
                 # Now create a new child for every file returned in the list.
                 result += desc.split("\n").collect { |line|
                     file, type = line.split("\t")
                     next if file == "/" # skip the listing object
                     name = file.sub(/^\//, '')
 
                     # This makes sure that the first source *always* wins
                     # for conflicting files.
                     next if found.include?(name)
 
                     # For directories, keep all of the sources, so that
                     # sourceselect still works as planned.
                     if type == "directory"
                         newsource = @parameters[:source].should.collect do |tmpsource|
                             tmpsource + file
                         end
                     else
                         newsource = source + file
                     end
                     args = {:source => newsource}
                     if type == file
                         args[:recurse] = nil
                     end
 
                     found << name
                     sourced << File.join(self[:path], name)
 
                     self.newchild(name, false, args)
                 }.reject {|c| c.nil? }
 
                 if self[:sourceselect] == :first
                     return [result, sourced]
                 end
             end
             return [result, sourced]
         end
 
         # Set the checksum, from another property.  There are multiple
         # properties that modify the contents of a file, and they need the
         # ability to make sure that the checksum value is in sync.
         def setchecksum(sum = nil)
             if @parameters.include? :checksum
                 if sum
                     @parameters[:checksum].checksum = sum
                 else
                     # If they didn't pass in a sum, then tell checksum to
                     # figure it out.
                     currentvalue = @parameters[:checksum].retrieve
                     @parameters[:checksum].checksum = currentvalue
                 end
             end
         end
 
         # Stat our file.  Depending on the value of the 'links' attribute, we
         # use either 'stat' or 'lstat', and we expect the properties to use the
         # resulting stat object accordingly (mostly by testing the 'ftype'
         # value).
         def stat(refresh = false)
             method = :stat
 
             # Files are the only types that support links
             if (self.class.name == :file and self[:links] != :follow) or self.class.name == :tidy
                 method = :lstat
             end
             path = self[:path]
             # Just skip them when they don't exist at all.
             unless FileTest.exists?(path) or FileTest.symlink?(path)
                 @stat = nil
                 return @stat
             end
             if @stat.nil? or refresh == true
                 begin
                     @stat = File.send(method, self[:path])
                 rescue Errno::ENOENT => error
                     @stat = nil
                 rescue Errno::EACCES => error
                     self.warning "Could not stat; permission denied"
                     @stat = nil
                 end
             end
 
             return @stat
         end
 
         # We have to hack this just a little bit, because otherwise we'll get
         # an error when the target and the contents are created as properties on
         # the far side.
         def to_trans(retrieve = true)
             obj = super
             if obj[:target] == :notlink
                 obj.delete(:target)
             end
             obj
         end
 
         def localfileserver
             unless defined? @@localfileserver
                 args = {
                     :Local => true,
                     :Mount => { "/" => "localhost" },
                     :Config => false
                 }
                 @@localfileserver = Puppet::Network::Handler.handler(:fileserver).new(args)
             end
             @@localfileserver
         end
 
         def uri2obj(source)
             sourceobj = FileSource.new
             path = nil
             unless source
                 devfail "Got a nil source"
             end
             if source =~ /^\//
                 source = "file://localhost/%s" % URI.escape(source)
                 sourceobj.mount = "localhost"
                 sourceobj.local = true
             end
             begin
                 uri = URI.parse(URI.escape(source))
             rescue => detail
                 self.fail "Could not understand source %s: %s" %
                     [source, detail.to_s]
             end
 
             case uri.scheme
             when "file":
                 sourceobj.server = localfileserver
                 path = "/localhost" + uri.path
             when "puppet":
                 # FIXME: We should cache clients by uri.host + uri.port
                 # not by the full source path
                 unless @clients.include?(source)
                     host = uri.host
                     host ||= Puppet[:server] unless Puppet[:name] == "puppet"
                     if host.nil?
                         server = localfileserver
                     else
                         args = { :Server => host }
                         if uri.port
                             args[:Port] = uri.port
                         end
                         server = Puppet::Network::Client.file.new(args)
                     end
                     @clients[source] = server
                 end
                 sourceobj.server = @clients[source]
 
                 tmp = uri.path
                 if tmp =~ %r{^/(\w+)}
                     sourceobj.mount = $1
                     path = tmp
                     #path = tmp.sub(%r{^/\w+},'') || "/"
                 else
                     self.fail "Invalid source path %s" % tmp
                 end
             else
                 self.fail "Got other URL type '%s' from %s" %
                         [uri.scheme, source]
             end
 
             return [sourceobj, path.sub(/\/\//, '/')]
         end
 
         # Write out the file.  We open the file correctly, with all of the
         # uid and mode and such, and then yield the file handle for actual
         # writing.
         def write(property, usetmp = true)
             mode = self.should(:mode)
 
             remove_existing(:file)
 
             # The temporary file
             path = nil
             if usetmp
                 path = self[:path] + ".puppettmp"
             else
                 path = self[:path]
             end
 
             # As the correct user and group
             write_if_writable(File.dirname(path)) do
                 f = nil
                 # Open our file with the correct modes
                 if mode
                     Puppet::Util.withumask(000) do
                         f = File.open(path,
                             File::CREAT|File::WRONLY|File::TRUNC, mode)
                     end
                 else
                     f = File.open(path, File::CREAT|File::WRONLY|File::TRUNC)
                 end
 
                 # Yield it
                 yield f
 
                 f.flush
                 f.close
             end
 
             # And put our new file in place
             if usetmp
                 begin
                     File.rename(path, self[:path])
                 rescue => detail
                     self.err "Could not rename tmp %s for replacing: %s" %
                         [self[:path], detail]
                 ensure
                     # Make sure the created file gets removed
                     if FileTest.exists?(path)
                         File.unlink(path)
                     end
                 end
             end
 
             # make sure all of the modes are actually correct
             property_fix
 
             # And then update our checksum, so the next run doesn't find it.
             # FIXME This is extra work, because it's going to read the whole
             # file back in again.
             self.setchecksum
             
         end
         
         # Run the block as the specified user if the dir is writeable, else
         # run it as root (or the current user).
         def write_if_writable(dir)
             yield
             # We're getting different behaviors from different versions of ruby, so...
             # asroot = true
             # Puppet::Util::SUIDManager.asuser(asuser(), self.should(:group)) do
             #     if FileTest.writable?(dir)
             #         asroot = false
             #         yield
             #     end
             # end
             # 
             # if asroot
             #     yield
             # end
         end
 
         private
 
         # Override the parent method, because we don't want to generate changes
         # when the file is missing and there is no 'ensure' state.
         def propertychanges(currentvalues)
             unless self.stat
                 found = false
                 ([:ensure] + CREATORS).each do |prop|
                     if @parameters.include?(prop)
                         found = true
                         break
                     end
                 end
                 unless found
                     return []
                 end
             end
             super
         end
 
         # There are some cases where all of the work does not get done on
         # file creation/modification, so we have to do some extra checking.
         def property_fix
             properties.each do |thing|
                 next unless [:mode, :owner, :group].include?(thing.name)
 
                 # Make sure we get a new stat objct
                 self.stat(true)
                 currentvalue = thing.retrieve
                 unless thing.insync?(currentvalue)
                     thing.sync
                 end
             end
         end
     end # Puppet.type(:pfile)
 
     # the filesource class can't include the path, because the path
     # changes for every file instance
     class FileSource
         attr_accessor :mount, :root, :server, :local
     end
 
     # We put all of the properties in separate files, because there are so many
     # of them.  The order these are loaded is important, because it determines
     # the order they are in the property lit.
     require 'puppet/type/pfile/checksum'
     require 'puppet/type/pfile/content'     # can create the file
     require 'puppet/type/pfile/source'      # can create the file
     require 'puppet/type/pfile/target'      # creates a different type of file
     require 'puppet/type/pfile/ensure'      # can create the file
     require 'puppet/type/pfile/owner'
     require 'puppet/type/pfile/group'
     require 'puppet/type/pfile/mode'
     require 'puppet/type/pfile/type'
 end
diff --git a/lib/puppet/util/graph.rb b/lib/puppet/util/graph.rb
index a9744578b..d1ef36f8e 100644
--- a/lib/puppet/util/graph.rb
+++ b/lib/puppet/util/graph.rb
@@ -1,32 +1,32 @@
 #  Created by Luke Kanies on 2006-11-16.
 #  Copyright (c) 2006. All rights reserved.
 
 require 'puppet'
 require 'puppet/pgraph'
 
 # A module that handles the small amount of graph stuff in Puppet.
 module Puppet::Util::Graph
     # Make a graph where each of our children gets converted to
     # the receiving end of an edge.  Call the same thing on all
     # of our children, optionally using a block
     def to_graph(graph = nil, &block)
         # Allow our calling function to send in a graph, so that we
         # can call this recursively with one graph.
         graph ||= Puppet::PGraph.new
         
         self.each do |child|
             unless block_given? and ! yield(child)
-                graph.add_edge!(self, child)
+                graph.add_edge(self, child)
                 
                 if child.respond_to?(:to_graph)
                     child.to_graph(graph, &block)
                 end
             end
         end
 
         # Do a topsort, which will throw an exception if the graph is cyclic.
         
         graph
     end
 end
 
diff --git a/spec/unit/node/catalog.rb b/spec/unit/node/catalog.rb
index a0e201ca9..aa49909e2 100755
--- a/spec/unit/node/catalog.rb
+++ b/spec/unit/node/catalog.rb
@@ -1,803 +1,803 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Node::Catalog, " when compiling" do
     it "should accept tags" do
         config = Puppet::Node::Catalog.new("mynode")
         config.tag("one")
         config.tags.should == %w{one}
     end
 
     it "should accept multiple tags at once" do
         config = Puppet::Node::Catalog.new("mynode")
         config.tag("one", "two")
         config.tags.should == %w{one two}
     end
 
     it "should convert all tags to strings" do
         config = Puppet::Node::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::Node::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::Node::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::Node::Catalog.new("mynode")
         config.add_class("one")
         config.tags.should == %w{one}
     end
 end
 
 describe Puppet::Node::Catalog, " when extracting" do
     it "should return extraction result as the method result" do
         config = Puppet::Node::Catalog.new("mynode")
         config.expects(:extraction_format).returns(:whatever)
         config.expects(:extract_to_whatever).returns(:result)
         config.extract.should == :result
     end
 end
 
 describe Puppet::Node::Catalog, " 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::Node::Catalog.new("mynode")
 
         @scope = mkscope
         @source = mock 'source'
 
         main = mkresource("class", :main)
-        config.add_vertex!(main)
+        config.add_vertex(main)
 
         bucket = mock 'bucket'
         bucket.expects(:classes=).with(config.classes)
         main.stubs(:builtin?).returns(false)
         main.expects(:to_transbucket).returns(bucket)
 
         config.extract_to_transportable.should equal(bucket)
     end
 
     # This isn't really a spec-style test, but I don't know how better to do it.
     it "should transform the resource graph into a tree of TransBuckets and TransObjects" do
         config = Puppet::Node::Catalog.new("mynode")
 
         @scope = mkscope
         @source = mock 'source'
 
         defined = mkresource("class", :main)
         builtin = mkresource("file", "/yay")
 
-        config.add_edge!(defined, builtin)
+        config.add_edge(defined, builtin)
 
         bucket = []
         bucket.expects(:classes=).with(config.classes)
         defined.stubs(:builtin?).returns(false)
         defined.expects(:to_transbucket).returns(bucket)
         builtin.expects(:to_transobject).returns(:builtin)
 
         config.extract_to_transportable.should == [:builtin]
     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::Node::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
+        config.add_edge top, topres
 
         middle = mkresource "class", "middle"
         middle.expects(:to_trans).returns([])
-        config.add_edge! top, middle
+        config.add_edge top, middle
         midres = mkresource "file", "/mid"
         midres.expects(:to_trans).returns(:midres)
-        config.add_edge! middle, midres
+        config.add_edge middle, midres
 
         bottom = mkresource "class", "bottom"
         bottom.expects(:to_trans).returns([])
-        config.add_edge! middle, bottom
+        config.add_edge middle, bottom
         botres = mkresource "file", "/bot"
         botres.expects(:to_trans).returns(:botres)
-        config.add_edge! bottom, 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 Puppet::Node::Catalog, " when converting to a transobject catalog" do
     class TestResource
         attr_accessor :name, :virtual, :builtin
         def initialize(name, options = {})
             @name = name
             options.each { |p,v| send(p.to_s + "=", v) }
         end
 
         def ref
             if builtin?
                 "File[%s]" % name
             else
                 "Class[%s]" % name
             end
         end
 
         def virtual?
             virtual
         end
 
         def builtin?
             builtin
         end
 
         def to_transobject
             Puppet::TransObject.new(name, builtin? ? "file" : "class")
         end
     end
 
     before do
         @original = Puppet::Node::Catalog.new("mynode")
         @original.tag(*%w{one two three})
         @original.add_class *%w{four five six}
 
         @top            = TestResource.new 'top'
         @topobject      = TestResource.new 'topobject', :builtin => true
         @virtual        = TestResource.new 'virtual', :virtual => true
         @virtualobject  = TestResource.new 'virtualobject', :builtin => true, :virtual => true
         @middle         = TestResource.new 'middle'
         @middleobject   = TestResource.new 'middleobject', :builtin => true
         @bottom         = TestResource.new 'bottom'
         @bottomobject   = TestResource.new 'bottomobject', :builtin => true
 
         @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject]
 
-        @original.add_edge!(@top, @topobject)
-        @original.add_edge!(@top, @virtual)
-        @original.add_edge!(@virtual, @virtualobject)
-        @original.add_edge!(@top, @middle)
-        @original.add_edge!(@middle, @middleobject)
-        @original.add_edge!(@middle, @bottom)
-        @original.add_edge!(@bottom, @bottomobject)
+        @original.add_edge(@top, @topobject)
+        @original.add_edge(@top, @virtual)
+        @original.add_edge(@virtual, @virtualobject)
+        @original.add_edge(@top, @middle)
+        @original.add_edge(@middle, @middleobject)
+        @original.add_edge(@middle, @bottom)
+        @original.add_edge(@bottom, @bottomobject)
 
         @catalog = @original.to_transportable
     end
 
     it "should add all resources as TransObjects" do
         @resources.each { |resource| @catalog.resource(resource.ref).should be_instance_of(Puppet::TransObject) }
     end
 
     it "should not extract defined virtual resources" do
         @catalog.vertices.find { |v| v.name == "virtual" }.should be_nil
     end
 
     it "should not extract builtin virtual resources" do
         @catalog.vertices.find { |v| v.name == "virtualobject" }.should be_nil
     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|
             next if edge.source.virtual? or edge.target.virtual?
             source = @catalog.resource(edge.source.ref)
             target = @catalog.resource(edge.target.ref)
 
             source.should_not be_nil
             target.should_not be_nil
             @catalog.edge?(source, target).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 Puppet::Node::Catalog, " when converting to a RAL catalog" do
     before do
         @original = Puppet::Node::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)
+        @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::Node::Catalog.new('test')
         config.add_resource(changer)
         config.add_resource(@top)
 
-        config.add_edge!(@top, changer)
+        config.add_edge(@top, changer)
 
         resource = stub 'resource', :name => "changer2", :title => "changer2", :ref => "Test[changer2]", :catalog= => nil, :remove => nil
 
         changer.expects(:to_type).returns(resource)
 
         newconfig = nil
 
         Puppet::Type.allclear
 
         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 Puppet::Node::Catalog, " when functioning as a resource container" do
     before do
         @catalog = Puppet::Node::Catalog.new("host")
         @one = stub 'resource1', :ref => "Me[one]", :catalog= => nil
         @two = stub 'resource2', :ref => "Me[two]", :catalog= => nil
         @dupe = stub 'resource3', :ref => "Me[one]", :catalog= => nil
     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 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 not set itself as the resource's catalog if it is a relationship graph" do
         @one.expects(:catalog=).never
         @catalog.is_relationship_graph = true
         @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("me", "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("me[one]", nil).should equal(@one)
     end
 
     it "should not allow two resources with the same resource reference" do
         @catalog.add_resource(@one)
 
         # These are used to build the failure
         @dupe.stubs(:file)
         @dupe.stubs(:line)
         @one.stubs(:file)
         @one.stubs(:line)
         proc { @catalog.add_resource(@dupe) }.should raise_error(ArgumentError)
     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::Node::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("me", "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("me", "other").should equal(@one)
     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("me", "other").should equal(@one)
     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 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("me", "other").should be_nil
     end
 
     after do
         Puppet::Type.allclear
     end
 end
 
 module ApplyingCatalogs
     def setup
         @catalog = Puppet::Node::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
 end
 
 describe Puppet::Node::Catalog, " when applying" do
     include ApplyingCatalogs
 
     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
 end
 
 describe Puppet::Node::Catalog, " when applying host catalogs" do
     include ApplyingCatalogs
 
     # super() doesn't work in the setup method for some reason
     before do
         @catalog.host_config = true
     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 Puppet::Node::Catalog, " when applying non-host catalogs" do
     include ApplyingCatalogs
 
     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
 
 describe Puppet::Node::Catalog, " when creating a relationship graph" do
     before do
         @catalog = Puppet::Node::Catalog.new("host")
         @compone = Puppet::Type::Component.create :name => "one"
         @comptwo = Puppet::Type::Component.create :name => "two", :require => ["class", "one"]
         @file = Puppet::Type.type(:file)
         @one = @file.create :path => "/one"
         @two = @file.create :path => "/two"
-        @catalog.add_edge! @compone, @one
-        @catalog.add_edge! @comptwo, @two
+        @catalog.add_edge @compone, @one
+        @catalog.add_edge @comptwo, @two
 
         @three = @file.create :path => "/three"
         @four = @file.create :path => "/four", :require => ["file", "/three"]
         @five = @file.create :path => "/five"
         @catalog.add_resource @compone, @comptwo, @one, @two, @three, @four, @five
         @relationships = @catalog.relationship_graph
     end
 
     it "should fail when trying to create a relationship graph for a relationship graph" do
         proc { @relationships.relationship_graph }.should raise_error(Puppet::DevError)
     end
 
     it "should be able to create a relationship graph" do
         @relationships.should be_instance_of(Puppet::Node::Catalog)
     end
 
     it "should copy its host_config setting to the relationship graph" do
         config = Puppet::Node::Catalog.new
         config.host_config = true
         config.relationship_graph.host_config.should be_true
     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 get removed when the catalog is cleaned up" do
         @relationships.expects(:clear).with(false)
         @catalog.clear
         @catalog.instance_variable_get("@relationship_graph").should be_nil
     end
 
     it "should create a new relationship graph after clearing the old one" do
         @relationships.expects(:clear).with(false)
         @catalog.clear
         @catalog.relationship_graph.should be_instance_of(Puppet::Node::Catalog)
     end
 
     it "should look up resources in the relationship graph if not found in the main catalog" do
         five = stub 'five', :ref => "File[five]", :catalog= => nil
         @relationships.add_resource five
         @catalog.resource(five.ref).should equal(five)
     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
         Puppet::Type.type(:file).expects(:create).with(args).returns(resource)
         @catalog.create_resource :file, args
         @catalog.resource("File[/yay]").should equal(resource)
     end
 
     it "should provide a mechanism for creating implicit resources" do
         args = {:name => "/yay", :ensure => :file}
         resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog
         Puppet::Type.type(:file).expects(:create).with(args).returns(resource)
         resource.expects(:implicit=).with(true)
         @catalog.create_implicit_resource :file, args
         @catalog.resource("File[/yay]").should equal(resource)
     end
 
     it "should add implicit resources to the relationship graph if there is one" do
         args = {:name => "/yay", :ensure => :file}
         resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog
         resource.expects(:implicit=).with(true)
         Puppet::Type.type(:file).expects(:create).with(args).returns(resource)
         # build the graph
         relgraph = @catalog.relationship_graph
 
         @catalog.create_implicit_resource :file, args
         relgraph.resource("File[/yay]").should equal(resource)
     end
 
     it "should remove resources created mid-transaction" do
         args = {:name => "/yay", :ensure => :file}
         resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog
         @transaction = mock 'transaction'
         Puppet::Transaction.stubs(:new).returns(@transaction)
         @transaction.stubs(:evaluate)
         @transaction.stubs(:cleanup)
         @transaction.stubs(:addtimes)
         Puppet::Type.type(:file).expects(:create).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 from the relationship graph if it exists" do
         @catalog.remove_resource(@one)
         @catalog.relationship_graph.vertex?(@one).should be_false
     end
 
     after do
         Puppet::Type.allclear
     end
 end
 
 describe Puppet::Node::Catalog, " when writing dot files" do
     before do
         @catalog = Puppet::Node::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
 
     it "should only write when graphing is enabled" do
         File.expects(:open).with(@file).never
         @catalog.host_config = true
         Puppet[:graph] = false
         @catalog.write_graph(@name)
     end
 
     it "should write a dot file based on the passed name" do
         File.expects(:open).with(@file, "w").yields(stub("file", :puts => nil))
         @catalog.expects(:to_dot).with("name" => @name.to_s.capitalize)
         @catalog.host_config = true
         Puppet[:graph] = true
         @catalog.write_graph(@name)
     end
 
     after do
         Puppet.settings.clear
     end
 end
 
 describe Puppet::Node::Catalog, " when indirecting" do
     before do
         @indirection = mock 'indirection'
 
         Puppet::Indirector::Indirection.clear_cache
     end
 
     it "should redirect to the indirection for retrieval" do
         Puppet::Node::Catalog.stubs(:indirection).returns(@indirection)
         @indirection.expects(:find).with(:myconfig)
         Puppet::Node::Catalog.find(:myconfig)
     end
 
     it "should default to the 'compiler' terminus" do
         Puppet::Node::Catalog.indirection.terminus_class.should == :compiler
     end
 
     after do
         mocha_verify
         Puppet::Indirector::Indirection.clear_cache
     end
 end
 
 describe Puppet::Node::Catalog, " when converting to yaml" do
     before do
         @catalog = Puppet::Node::Catalog.new("me")
-        @catalog.add_edge!("one", "two")
+        @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
 end
 
 describe Puppet::Node::Catalog, " when converting from yaml" do
     before do
         @catalog = Puppet::Node::Catalog.new("me")
-        @catalog.add_edge!("one", "two")
+        @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::Node::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
diff --git a/spec/unit/other/pgraph.rb b/spec/unit/other/pgraph.rb
index 252a807ec..7d66ae331 100755
--- a/spec/unit/other/pgraph.rb
+++ b/spec/unit/other/pgraph.rb
@@ -1,209 +1,209 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-9-12.
 #  Copyright (c) 2006. All rights reserved.
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/util/graph'
 
 class Container
     include Puppet::Util::Graph
     include Enumerable
     attr_accessor :name
     def each
         @children.each do |c| yield c end
     end
     
     def initialize(name, ary)
         @name = name
         @children = ary
     end
     
     def push(*ary)
         ary.each { |c| @children.push(c)}
     end
     
     def to_s
         @name
     end
 end
 
 describe Puppet::PGraph do
     before do
         @graph = Puppet::PGraph.new
     end
 
     it "should correctly clear vertices and edges when asked" do
-	    @graph.add_edge!("a", "b")
-	    @graph.add_vertex! "c"
+	    @graph.add_edge("a", "b")
+	    @graph.add_vertex "c"
         @graph.clear
         @graph.vertices.should be_empty
         @graph.edges.should be_empty
     end
 end
 
 describe Puppet::PGraph, " when matching edges" do
     before do
         @graph = Puppet::PGraph.new
 	    @event = Puppet::Event.new(:source => "a", :event => :yay)
 	    @none = Puppet::Event.new(:source => "a", :event => :NONE)
 
 	    @edges = {}
 	    @edges["a/b"] = Puppet::Relationship.new("a", "b", {:event => :yay, :callback => :refresh})
 	    @edges["a/c"] = Puppet::Relationship.new("a", "c", {:event => :yay, :callback => :refresh})
-	    @graph.add_edge!(@edges["a/b"])
+	    @graph.add_edge(@edges["a/b"])
     end
 
     it "should match edges whose source matches the source of the event" do
 	    @graph.matching_edges([@event]).should == [@edges["a/b"]]
     end
 
     it "should match always match nothing when the event is :NONE" do
 	    @graph.matching_edges([@none]).should be_empty
     end
 
     it "should match multiple edges" do
-	    @graph.add_edge!(@edges["a/c"])
+	    @graph.add_edge(@edges["a/c"])
         edges = @graph.matching_edges([@event])
         edges.should be_include(@edges["a/b"])
         edges.should be_include(@edges["a/c"])
     end
 end
 
 describe Puppet::PGraph, " when determining dependencies" do
     before do
         @graph = Puppet::PGraph.new
         
-        @graph.add_edge!("a", "b")
-        @graph.add_edge!("a", "c")
-        @graph.add_edge!("b", "d")
+        @graph.add_edge("a", "b")
+        @graph.add_edge("a", "c")
+        @graph.add_edge("b", "d")
     end
 
     it "should find all dependents when they are on multiple levels" do
         @graph.dependents("a").sort.should == %w{b c d}.sort
     end
 
     it "should find single dependents" do
         @graph.dependents("b").sort.should == %w{d}.sort
     end
 
     it "should return an empty array when there are no dependents" do
         @graph.dependents("c").sort.should == [].sort
     end
 
     it "should find all dependencies when they are on multiple levels" do
         @graph.dependencies("d").sort.should == %w{a b}
     end
 
     it "should find single dependencies" do
         @graph.dependencies("c").sort.should == %w{a}
     end
     
     it "should return an empty array when there are no dependencies" do
         @graph.dependencies("a").sort.should == []
     end
 end
 
 describe Puppet::PGraph, " when splicing the relationship graph" do
     def container_graph
         @one = Container.new("one", %w{a b})
         @two = Container.new("two", ["c", "d"])
         @three = Container.new("three", ["i", "j"])
         @middle = Container.new("middle", ["e", "f", @two])
         @top = Container.new("top", ["g", "h", @middle, @one, @three])
         @empty = Container.new("empty", [])
 
         @contgraph = @top.to_graph
 
         # We have to add the container to the main graph, else it won't
         # be spliced in the dependency graph.
-        @contgraph.add_vertex!(@empty)
+        @contgraph.add_vertex(@empty)
     end
 
     def dependency_graph
         @depgraph = Puppet::PGraph.new
         @contgraph.vertices.each do |v|
-            @depgraph.add_vertex!(v)
+            @depgraph.add_vertex(v)
         end
 
         # We have to specify a relationship to our empty container, else it
         # never makes it into the dep graph in the first place.
         {@one => @two, "f" => "c", "h" => @middle, "c" => @empty}.each do |source, target|
-            @depgraph.add_edge!(source, target, :callback => :refresh)
+            @depgraph.add_edge(source, target, :callback => :refresh)
         end
     end
 
     def splice
         @depgraph.splice!(@contgraph, Container)
     end
 
     before do
         container_graph
         dependency_graph
         splice
     end
 
     # This is the real heart of splicing -- replacing all containers in
     # our relationship and exploding their relationships so that each
     # relationship to a container gets copied to all of its children.
     it "should remove all Container objects from the dependency graph" do
         @depgraph.vertices.find_all { |v| v.is_a?(Container) }.should be_empty
     end
 
     it "should add container relationships to contained objects" do
         @contgraph.leaves(@middle).each do |leaf|
             @depgraph.should be_edge("h", leaf)
         end
     end
 
     it "should explode container-to-container relationships, making edges between all respective contained objects" do
         @one.each do |oobj|
             @two.each do |tobj|
                 @depgraph.should be_edge(oobj, tobj)
             end
         end
     end
 
     it "should no longer contain anything but the non-container objects" do
         @depgraph.vertices.find_all { |v| ! v.is_a?(String) }.should be_empty
     end
 
     it "should copy labels" do
         @depgraph.edges.each do |edge|
             edge.label.should == {:callback => :refresh}
         end
     end
 
     it "should not add labels to edges that have none" do
-        @depgraph.add_edge!(@two, @three)
+        @depgraph.add_edge(@two, @three)
         splice
         @depgraph.edge_label("c", "i").should == {}
     end
 
     it "should copy labels over edges that have none" do
-        @depgraph.add_edge!("c", @three, {:callback => :refresh})
+        @depgraph.add_edge("c", @three, {:callback => :refresh})
         splice
         # And make sure the label got copied.
         @depgraph.edge_label("c", "i").should == {:callback => :refresh}
     end
 
     it "should not replace a label with a nil label" do
         # Lastly, add some new label-less edges and make sure the label stays.
-        @depgraph.add_edge!(@middle, @three)
-        @depgraph.add_edge!("c", @three, {:callback => :refresh})
+        @depgraph.add_edge(@middle, @three)
+        @depgraph.add_edge("c", @three, {:callback => :refresh})
         splice
         @depgraph.edge_label("c", "i").should == {:callback => :refresh}
     end
 
     it "should copy labels to all created edges" do
-        @depgraph.add_edge!(@middle, @three)
-        @depgraph.add_edge!("c", @three, {:callback => :refresh})
+        @depgraph.add_edge(@middle, @three)
+        @depgraph.add_edge("c", @three, {:callback => :refresh})
         splice
         @three.each do |child|
-            edge = @depgraph.edge_class.new("c", child)
+            edge = Puppet::Relationship.new("c", child)
             @depgraph.should be_edge(edge.source, edge.target)
             @depgraph.edge_label(edge.source, edge.target).should == {:callback => :refresh}
         end
     end
 end
diff --git a/spec/unit/ral/type.rb b/spec/unit/ral/type.rb
index 25f8cbaf1..5980167d6 100755
--- a/spec/unit/ral/type.rb
+++ b/spec/unit/ral/type.rb
@@ -1,29 +1,29 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Type, " when in a configuration" do
     before do
         @catalog = Puppet::Node::Catalog.new
         @container = Puppet::Type.type(:component).create(:name => "container")
         @one = Puppet::Type.type(:file).create(:path => "/file/one")
         @two = Puppet::Type.type(:file).create(:path => "/file/two")
         @catalog.add_resource @container
         @catalog.add_resource @one
         @catalog.add_resource @two
-        @catalog.add_edge! @container, @one
-        @catalog.add_edge! @container, @two
+        @catalog.add_edge @container, @one
+        @catalog.add_edge @container, @two
     end
 
     it "should have no parent if there is no in edge" do
         @container.parent.should be_nil
     end
 
     it "should set its parent to its in edge" do
         @one.parent.ref.should == @container.ref
     end
 
     after do
         @catalog.clear(true)
     end
 end
diff --git a/spec/unit/simple_graph.rb b/spec/unit/simple_graph.rb
index 061a07458..c8fe14cf3 100755
--- a/spec/unit/simple_graph.rb
+++ b/spec/unit/simple_graph.rb
@@ -1,269 +1,269 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-11-1.
 #  Copyright (c) 2006. All rights reserved.
 
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'puppet/simple_graph'
 
 describe Puppet::SimpleGraph do
     it "should return the number of its vertices as its length" do
         @graph = Puppet::SimpleGraph.new
-        @graph.add_vertex!("one")
-        @graph.add_vertex!("two")
+        @graph.add_vertex("one")
+        @graph.add_vertex("two")
         @graph.size.should == 2
     end
 
     it "should consider itself a directed graph" do
         Puppet::SimpleGraph.new.directed?.should be_true
     end
 
     it "should provide a method for reversing the graph" do
         @graph = Puppet::SimpleGraph.new
-        @graph.add_edge!(:one, :two)
+        @graph.add_edge(:one, :two)
         @graph.reversal.edge?(:two, :one).should be_true
     end
 
     it "should be able to produce a dot graph" do
         @graph = Puppet::SimpleGraph.new
-        @graph.add_edge!(:one, :two)
+        @graph.add_edge(:one, :two)
 
         proc { @graph.to_dot_graph }.should_not raise_error
     end
 end
 
 describe Puppet::SimpleGraph, " when managing vertices" do
     before do
         @graph = Puppet::SimpleGraph.new
     end
 
     it "should provide a method to add a vertex" do
-        @graph.add_vertex!(:test)
+        @graph.add_vertex(:test)
         @graph.vertex?(:test).should be_true
     end
 
     it "should ignore already-present vertices when asked to add a vertex" do
-        @graph.add_vertex!(:test)
-        proc { @graph.add_vertex!(:test) }.should_not raise_error
+        @graph.add_vertex(:test)
+        proc { @graph.add_vertex(:test) }.should_not raise_error
     end
 
     it "should return true when asked if a vertex is present" do
-        @graph.add_vertex!(:test)
+        @graph.add_vertex(:test)
         @graph.vertex?(:test).should be_true
     end
 
     it "should return false when asked if a non-vertex is present" do
         @graph.vertex?(:test).should be_false
     end
 
     it "should return all set vertices when asked" do
-        @graph.add_vertex!(:one)
-        @graph.add_vertex!(:two)
+        @graph.add_vertex(:one)
+        @graph.add_vertex(:two)
         @graph.vertices.length.should == 2
         @graph.vertices.should include(:one)
         @graph.vertices.should include(:two)
     end
 
     it "should remove a given vertex when asked" do
-        @graph.add_vertex!(:one)
+        @graph.add_vertex(:one)
         @graph.remove_vertex!(:one)
         @graph.vertex?(:one).should be_false
     end
 
     it "should do nothing when a non-vertex is asked to be removed" do
         proc { @graph.remove_vertex!(:one) }.should_not raise_error
     end
 end
 
 describe Puppet::SimpleGraph, " when managing edges" do
     before do
         @graph = Puppet::SimpleGraph.new
     end
 
     it "should provide a method to test whether a given vertex pair is an edge" do
         @graph.should respond_to(:edge?)
     end
 
     it "should provide a method to add an edge as an instance of the edge class" do
         edge = Puppet::Relationship.new(:one, :two)
-        @graph.add_edge!(edge)
+        @graph.add_edge(edge)
         @graph.edge?(:one, :two).should be_true
     end
 
     it "should provide a method to add an edge by specifying the two vertices" do
-        @graph.add_edge!(:one, :two)
+        @graph.add_edge(:one, :two)
         @graph.edge?(:one, :two).should be_true
     end
 
     it "should provide a method to add an edge by specifying the two vertices and a label" do
-        @graph.add_edge!(:one, :two, :stuff => :awesome)
+        @graph.add_edge(:one, :two, :stuff => :awesome)
         @graph.edge?(:one, :two).should be_true
     end
 
     it "should provide a method for retrieving an edge label" do
         edge = Puppet::Relationship.new(:one, :two, :stuff => :awesome)
-        @graph.add_edge!(edge)
+        @graph.add_edge(edge)
         @graph.edge_label(:one, :two).should == {:stuff => :awesome}
     end
 
     it "should provide a method for retrieving an edge" do
         edge = Puppet::Relationship.new(:one, :two)
-        @graph.add_edge!(edge)
+        @graph.add_edge(edge)
         @graph.edge(:one, :two).should equal(edge)
     end
 
     it "should add the edge source as a vertex if it is not already" do
         edge = Puppet::Relationship.new(:one, :two)
-        @graph.add_edge!(edge)
+        @graph.add_edge(edge)
         @graph.vertex?(:one).should be_true
     end
 
     it "should add the edge target as a vertex if it is not already" do
         edge = Puppet::Relationship.new(:one, :two)
-        @graph.add_edge!(edge)
+        @graph.add_edge(edge)
         @graph.vertex?(:two).should be_true
     end
 
     it "should return all edges as edge instances when asked" do
         one = Puppet::Relationship.new(:one, :two)
         two = Puppet::Relationship.new(:two, :three)
-        @graph.add_edge!(one)
-        @graph.add_edge!(two)
+        @graph.add_edge(one)
+        @graph.add_edge(two)
         edges = @graph.edges
         edges.length.should == 2
         edges.should include(one)
         edges.should include(two)
     end
 
     it "should remove an edge when asked" do
         edge = Puppet::Relationship.new(:one, :two)
-        @graph.add_edge!(edge)
+        @graph.add_edge(edge)
         @graph.remove_edge!(edge)
         @graph.edge?(edge.source, edge.target).should be_false
     end
 
     it "should remove all related edges when a vertex is removed" do
         one = Puppet::Relationship.new(:one, :two)
         two = Puppet::Relationship.new(:two, :three)
-        @graph.add_edge!(one)
-        @graph.add_edge!(two)
+        @graph.add_edge(one)
+        @graph.add_edge(two)
         @graph.remove_vertex!(:two)
         @graph.edge?(:one, :two).should be_false
         @graph.edge?(:two, :three).should be_false
         @graph.edges.length.should == 0
     end
 end
 
 describe Puppet::SimpleGraph, " when finding adjacent vertices" do
     before do
         @graph = Puppet::SimpleGraph.new
         @one_two = Puppet::Relationship.new(:one, :two)
         @two_three = Puppet::Relationship.new(:two, :three)
         @one_three = Puppet::Relationship.new(:one, :three)
-        @graph.add_edge!(@one_two)
-        @graph.add_edge!(@one_three)
-        @graph.add_edge!(@two_three)
+        @graph.add_edge(@one_two)
+        @graph.add_edge(@one_three)
+        @graph.add_edge(@two_three)
     end
 
     it "should return adjacent vertices" do
         adj = @graph.adjacent(:one)
         adj.should be_include(:three)
         adj.should be_include(:two)
     end
 
     it "should default to finding :out vertices" do
         @graph.adjacent(:two).should == [:three]
     end
 
     it "should support selecting :in vertices" do
         @graph.adjacent(:two, :direction => :in).should == [:one]
     end
 
     it "should default to returning the matching vertices as an array of vertices" do
         @graph.adjacent(:two).should == [:three]
     end
 
     it "should support returning an array of matching edges" do
         @graph.adjacent(:two, :type => :edges).should == [@two_three]
     end
 end
 
 describe Puppet::SimpleGraph, " when clearing" do
     before do
         @graph = Puppet::SimpleGraph.new
         one = Puppet::Relationship.new(:one, :two)
         two = Puppet::Relationship.new(:two, :three)
-        @graph.add_edge!(one)
-        @graph.add_edge!(two)
+        @graph.add_edge(one)
+        @graph.add_edge(two)
 
         @graph.clear
     end
 
     it "should remove all vertices" do
         @graph.vertices.should be_empty
     end
 
     it "should remove all edges" do
         @graph.edges.should be_empty
     end
 end
 
 describe Puppet::SimpleGraph, " when reversing graphs" do
     before do
         @graph = Puppet::SimpleGraph.new
     end
 
     it "should provide a method for reversing the graph" do
-        @graph.add_edge!(:one, :two)
+        @graph.add_edge(:one, :two)
         @graph.reversal.edge?(:two, :one).should be_true
     end
 
     it "should add all vertices to the reversed graph" do
-        @graph.add_edge!(:one, :two)
+        @graph.add_edge(:one, :two)
         @graph.vertex?(:one).should be_true
         @graph.vertex?(:two).should be_true
     end
     
     it "should retain labels on edges" do
-        @graph.add_edge!(:one, :two, :stuff => :awesome)
+        @graph.add_edge(:one, :two, :stuff => :awesome)
         edge = @graph.reversal.edge(:two, :one)
         edge.label.should == {:stuff => :awesome}
     end
 end
 
 describe Puppet::SimpleGraph, " when sorting the graph" do
     before do
         @graph = Puppet::SimpleGraph.new
     end
 
     def add_edges(hash)
         hash.each do |a,b|
-            @graph.add_edge!(a, b)
+            @graph.add_edge(a, b)
         end
     end
 
     it "should sort the graph topologically" do
         add_edges :a => :b, :b => :c
         @graph.topsort.should == [:a, :b, :c]
     end
 
     it "should fail on two-vertex loops" do
         add_edges :a => :b, :b => :a
         proc { @graph.topsort }.should raise_error(Puppet::Error)
     end
 
     it "should fail on multi-vertex loops" do
         add_edges :a => :b, :b => :c, :c => :a
         proc { @graph.topsort }.should raise_error(Puppet::Error)
     end
 
     it "should fail when a larger tree contains a small cycle" do
         add_edges :a => :b, :b => :a, :c => :a, :d => :c
         proc { @graph.topsort }.should raise_error(Puppet::Error)
     end
 
     it "should succeed on trees with no cycles" do
         add_edges :a => :b, :b => :e, :c => :a, :d => :c
         proc { @graph.topsort }.should_not raise_error
     end
 end
diff --git a/test/lib/puppettest/support/resources.rb b/test/lib/puppettest/support/resources.rb
index 384f61c33..255c55569 100755
--- a/test/lib/puppettest/support/resources.rb
+++ b/test/lib/puppettest/support/resources.rb
@@ -1,37 +1,37 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke A. Kanies on 2006-11-29.
 #  Copyright (c) 2006. All rights reserved.
 
 module PuppetTest::Support::Resources
     def tree_resource(name)
         Puppet::Type.type(:file).create :title => name, :path => "/tmp/#{name}", :mode => 0755
     end
     
     def tree_container(name)
         Puppet::Type::Component.create :name => name, :type => "yay"
     end
     
     def treenode(config, name, *resources)
         comp = tree_container name
         resources.each do |resource| 
             if resource.is_a?(String)
                 resource = tree_resource(resource)
             end
-            config.add_edge!(comp, resource)
+            config.add_edge(comp, resource)
             config.add_resource resource unless config.resource(resource.ref)
         end
         return comp
     end
     
     def mktree
         catalog = Puppet::Node::Catalog.new do |config|
             one = treenode(config, "one", "a", "b")
             two = treenode(config, "two", "c", "d")
             middle = treenode(config, "middle", "e", "f", two)
             top = treenode(config, "top", "g", "h", middle, one)
         end
         
         return catalog
     end
 end
diff --git a/test/other/transactions.rb b/test/other/transactions.rb
index 79971a28b..105698da1 100755
--- a/test/other/transactions.rb
+++ b/test/other/transactions.rb
@@ -1,1109 +1,1109 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppet'
 require 'puppettest'
 require 'mocha'
 require 'puppettest/support/resources'
 
 class TestTransactions < Test::Unit::TestCase
     include PuppetTest::FileTesting
     include PuppetTest::Support::Resources
     class Fakeprop <Puppet::Property
         attr_accessor :path, :is, :should, :name
         def should_to_s(value)
             value.to_s
         end
         def insync?(foo)
             true
         end
         def info(*args)
             false
         end
     end
     
     
     def mkgenerator(&block)
         $finished = []
         cleanup { $finished = nil }
         
         # Create a bogus type that generates new instances with shorter
         type = Puppet::Type.newtype(:generator) do
             newparam(:name, :namevar => true)
             def finish
                 $finished << self.name
             end
         end
         if block
             type.class_eval(&block)
         end
         cleanup do
             Puppet::Type.rmtype(:generator)
         end
         
         return type
     end
     
     # Create a new type that generates instances with shorter names.
     def mkreducer(&block)
         type = mkgenerator() do
             def eval_generate
                 ret = []
                 if title.length > 1
                     ret << self.class.create(:title => title[0..-2])
                 else
                     return nil
                 end
                 ret
             end
         end
         
         if block
             type.class_eval(&block)
         end
         
         return type
     end
 
     def test_reports
         path1 = tempfile()
         path2 = tempfile()
         objects = []
         objects << Puppet::Type.newfile(
             :path => path1,
             :content => "yayness"
         )
         objects << Puppet::Type.newfile(
             :path => path2,
             :content => "booness"
         )
 
         trans = assert_events([:file_created, :file_created], *objects)
 
         report = nil
 
         assert_nothing_raised {
             report = trans.generate_report
         }
 
         # First test the report logs
         assert(report.logs.length > 0, "Did not get any report logs")
 
         report.logs.each do |obj|
             assert_instance_of(Puppet::Util::Log, obj)
         end
 
         # Then test the metrics
         metrics = report.metrics
 
         assert(metrics, "Did not get any metrics")
         assert(metrics.length > 0, "Did not get any metrics")
 
         assert(metrics.has_key?("resources"), "Did not get object metrics")
         assert(metrics.has_key?("changes"), "Did not get change metrics")
 
         metrics.each do |name, metric|
             assert_instance_of(Puppet::Util::Metric, metric)
         end
     end
 
     def test_prefetch
         # Create a type just for testing prefetch
         name = :prefetchtesting
         $prefetched = false
         type = Puppet::Type.newtype(name) do
             newparam(:name) {}
         end
         
         cleanup do
             Puppet::Type.rmtype(name)
         end
 
         # Now create a provider
         type.provide(:prefetch) do
             def self.prefetch(resources)
                 $prefetched = resources
             end
         end
 
         # Now create an instance
         inst = type.create :name => "yay"
         
         # Create a transaction
         trans = Puppet::Transaction.new(mk_catalog(inst))
 
         # Make sure prefetch works
         assert_nothing_raised do
             trans.prefetch
         end
 
         assert_equal({inst.title => inst}, $prefetched, "type prefetch was not called")
 
         # Now make sure it gets called from within evaluate()
         $prefetched = false
         assert_nothing_raised do
             trans.evaluate
         end
 
         assert_equal({inst.title => inst}, $prefetched, "evaluate did not call prefetch")
     end
 
     def test_refreshes_generate_events
         path = tempfile()
         firstpath = tempfile()
         secondpath = tempfile()
         file = Puppet::Type.newfile(:title => "file", :path => path, :content => "yayness")
         first = Puppet::Type.newexec(:title => "first",
                                      :command => "/bin/echo first > #{firstpath}",
                                      :subscribe => [:file, path],
                                      :refreshonly => true
         )
         second = Puppet::Type.newexec(:title => "second",
                                      :command => "/bin/echo second > #{secondpath}",
                                      :subscribe => [:exec, "first"],
                                      :refreshonly => true
         )
 
         assert_apply(file, first, second)
 
         assert(FileTest.exists?(secondpath), "Refresh did not generate an event")
     end
 
     unless %x{groups}.chomp.split(/ /).length > 1
         $stderr.puts "You must be a member of more than one group to test transactions"
     else
     def ingroup(gid)
         require 'etc'
         begin
             group = Etc.getgrgid(gid)
         rescue => detail
             puts "Could not retrieve info for group %s: %s" % [gid, detail]
             return nil
         end
 
         return @groups.include?(group.name)
     end
 
     def setup
         super
         @groups = %x{groups}.chomp.split(/ /)
         unless @groups.length > 1
             p @groups
             raise "You must be a member of more than one group to test this"
         end
     end
 
     def newfile(hash = {})
         tmpfile = tempfile()
         File.open(tmpfile, "w") { |f| f.puts rand(100) }
 
         # XXX now, because os x apparently somehow allows me to make a file
         # owned by a group i'm not a member of, i have to verify that
         # the file i just created is owned by one of my groups
         # grrr
         unless ingroup(File.stat(tmpfile).gid)
             Puppet.info "Somehow created file in non-member group %s; fixing" %
                 File.stat(tmpfile).gid
 
             require 'etc'
             firstgr = @groups[0]
             unless firstgr.is_a?(Integer)
                 str = Etc.getgrnam(firstgr)
                 firstgr = str.gid
             end
             File.chown(nil, firstgr, tmpfile)
         end
 
         hash[:name] = tmpfile
         assert_nothing_raised() {
             return Puppet.type(:file).create(hash)
         }
     end
 
     def newexec(file)
         assert_nothing_raised() {
             return Puppet.type(:exec).create(
                 :name => "touch %s" % file,
                 :path => "/bin:/usr/bin:/sbin:/usr/sbin",
                 :returns => 0
             )
         }
     end
 
     # modify a file and then roll the modifications back
     def test_filerollback
         transaction = nil
         file = newfile()
 
         properties = {}
         check = [:group,:mode]
         file[:check] = check
 
         assert_nothing_raised() {
             file.retrieve
         }
 
         assert_nothing_raised() {
             check.each { |property|
                 value = file.value(property)
                 assert(value)
                 properties[property] = value
             }
         }
 
 
         component = mk_catalog("file",file)
         require 'etc'
         groupname = Etc.getgrgid(File.stat(file.name).gid).name
         assert_nothing_raised() {
             # Find a group that it's not set to
             group = @groups.find { |group| group != groupname }
             unless group
                 raise "Could not find suitable group"
             end
             file[:group] = group
 
             file[:mode] = "755"
         }
         trans = assert_events([:file_changed, :file_changed], component)
         file.retrieve
 
         assert_rollback_events(trans, [:file_changed, :file_changed], "file")
 
         assert_nothing_raised() {
             file.retrieve
         }
         properties.each { |property,value|
             assert_equal(
                 value, file.value(property), "File %s remained %s" % [property, file.value(property)]
             )
         }
     end
 
     # test that services are correctly restarted and that work is done
     # in the right order
     def test_refreshing
         transaction = nil
         file = newfile()
         execfile = File.join(tmpdir(), "exectestingness")
         exec = newexec(execfile)
         properties = {}
         check = [:group,:mode]
         file[:check] = check
         file[:group] = @groups[0]
 
         config = mk_catalog(file)
         config.apply
 
         @@tmpfiles << execfile
 
         # 'subscribe' expects an array of arrays
         exec[:subscribe] = [[file.class.name,file.name]]
         exec[:refreshonly] = true
 
         assert_nothing_raised() {
             file.retrieve
             exec.retrieve
         }
 
         check.each { |property|
             properties[property] = file.value(property)
         }
         assert_nothing_raised() {
             file[:mode] = "755"
         }
 
         # Make a new catalog so the resource relationships get
         # set up.
         config = mk_catalog(file, exec)
 
         trans = assert_events([:file_changed, :triggered], config)
 
         assert(FileTest.exists?(execfile), "Execfile does not exist")
         File.unlink(execfile)
         assert_nothing_raised() {
             file[:group] = @groups[1]
         }
 
         trans = assert_events([:file_changed, :triggered], config)
         assert(FileTest.exists?(execfile), "Execfile does not exist")
     end
 
     # Verify that one component requiring another causes the contained
     # resources in the requiring component to get refreshed.
     def test_refresh_across_two_components
         transaction = nil
         file = newfile()
         execfile = File.join(tmpdir(), "exectestingness2")
         @@tmpfiles << execfile
         exec = newexec(execfile)
         properties = {}
         check = [:group,:mode]
         file[:check] = check
         file[:group] = @groups[0]
         assert_apply(file)
 
         config = Puppet::Node::Catalog.new
         fcomp = Puppet::Type.type(:component).create(:name => "file")
         config.add_resource fcomp
         config.add_resource file
-        config.add_edge!(fcomp, file)
+        config.add_edge(fcomp, file)
 
         ecomp = Puppet::Type.type(:component).create(:name => "exec")
         config.add_resource ecomp
         config.add_resource exec
-        config.add_edge!(ecomp, exec)
+        config.add_edge(ecomp, exec)
 
         # 'subscribe' expects an array of arrays
         #component[:require] = [[file.class.name,file.name]]
         ecomp[:subscribe] = fcomp
         exec[:refreshonly] = true
 
         trans = assert_events([], config)
 
         assert_nothing_raised() {
             file[:group] = @groups[1]
             file[:mode] = "755"
         }
 
         trans = assert_events([:file_changed, :file_changed, :triggered], config)
     end
 
     # Make sure that multiple subscriptions get triggered.
     def test_multisubs
         path = tempfile()
         file1 = tempfile()
         file2 = tempfile()
         file = Puppet.type(:file).create(
             :path => path,
             :ensure => "file"
         )
         exec1 = Puppet.type(:exec).create(
             :path => ENV["PATH"],
             :command => "touch %s" % file1,
             :refreshonly => true,
             :subscribe => [:file, path]
         )
         exec2 = Puppet.type(:exec).create(
             :path => ENV["PATH"],
             :command => "touch %s" % file2,
             :refreshonly => true,
             :subscribe => [:file, path]
         )
 
         assert_apply(file, exec1, exec2)
         assert(FileTest.exists?(file1), "File 1 did not get created")
         assert(FileTest.exists?(file2), "File 2 did not get created")
     end
 
     # Make sure that a failed trigger doesn't result in other events not
     # getting triggered.
     def test_failedrefreshes
         path = tempfile()
         newfile = tempfile()
         file = Puppet.type(:file).create(
             :path => path,
             :ensure => "file"
         )
         exec1 = Puppet.type(:exec).create(
             :path => ENV["PATH"],
             :command => "touch /this/cannot/possibly/exist",
             :logoutput => true,
             :refreshonly => true,
             :subscribe => file,
             :title => "one"
         )
         exec2 = Puppet.type(:exec).create(
             :path => ENV["PATH"],
             :command => "touch %s" % newfile,
             :logoutput => true,
             :refreshonly => true,
             :subscribe => [file, exec1],
             :title => "two"
         )
 
         assert_apply(file, exec1, exec2)
         assert(FileTest.exists?(newfile), "Refresh file did not get created")
     end
 
     # Make sure that unscheduled and untagged objects still respond to events
     def test_unscheduled_and_untagged_response
         Puppet::Type.type(:schedule).mkdefaultschedules
         Puppet[:ignoreschedules] = false
         file = Puppet.type(:file).create(
             :name => tempfile(),
             :ensure => "file",
             :backup => false
         )
 
         fname = tempfile()
         exec = Puppet.type(:exec).create(
             :name => "touch %s" % fname,
             :path => "/usr/bin:/bin",
             :schedule => "monthly",
             :subscribe => ["file", file.name]
         )
 
         config = mk_catalog(file, exec)
 
         # Run it once
         assert_apply(config)
         assert(FileTest.exists?(fname), "File did not get created")
 
         assert(!exec.scheduled?, "Exec is somehow scheduled")
 
         # Now remove it, so it can get created again
         File.unlink(fname)
 
         file[:content] = "some content"
 
         assert_events([:file_changed, :triggered], config)
 
         assert(FileTest.exists?(fname), "File did not get recreated")
 
         # Now remove it, so it can get created again
         File.unlink(fname)
 
         # And tag our exec
         exec.tag("testrun")
 
         # And our file, so it runs
         file.tag("norun")
 
         Puppet[:tags] = "norun"
 
         file[:content] = "totally different content"
 
         assert(! file.insync?(file.retrieve), "Uh, file is in sync?")
 
         assert_events([:file_changed, :triggered], config)
         assert(FileTest.exists?(fname), "File did not get recreated")
     end
 
     def test_failed_reqs_mean_no_run
         exec = Puppet::Type.type(:exec).create(
             :command => "/bin/mkdir /this/path/cannot/possibly/exit",
             :title => "mkdir"
         )
 
         file1 = Puppet::Type.type(:file).create(
             :title => "file1",
             :path => tempfile(),
             :require => exec,
             :ensure => :file
         )
 
         file2 = Puppet::Type.type(:file).create(
             :title => "file2",
             :path => tempfile(),
             :require => file1,
             :ensure => :file
         )
 
         config = mk_catalog(exec, file1, file2)
 
         assert_apply(config)
 
         assert(! FileTest.exists?(file1[:path]),
             "File got created even tho its dependency failed")
         assert(! FileTest.exists?(file2[:path]),
             "File got created even tho its deep dependency failed")
     end
     end
     
     def test_relationship_graph
         config = mktree
 
         config.meta_def(:f) do |name|
             self.resource("File[%s]" % name)
         end
         
         {"one" => "two", "File[f]" => "File[c]", "File[h]" => "middle"}.each do |source_ref, target_ref|
             source = config.resource(source_ref) or raise "Missing %s" % source_ref
             target = config.resource(target_ref) or raise "Missing %s" % target_ref
             target[:require] = source
         end
         
         trans = Puppet::Transaction.new(config)
         
         graph = nil
         assert_nothing_raised do
             graph = trans.relationship_graph
         end
 
         assert_instance_of(Puppet::Node::Catalog, graph,
             "Did not get relationship graph")
         
         # Make sure all of the components are gone
         comps = graph.vertices.find_all { |v| v.is_a?(Puppet::Type::Component)}
         assert(comps.empty?, "Deps graph still contains components %s" %
             comps.collect { |c| c.ref }.join(","))
         
         assert_equal([], comps, "Deps graph still contains components")
         
         # It must be reversed because of how topsort works
         sorted = graph.topsort.reverse
         
         # Now make sure the appropriate edges are there and are in the right order
         assert(graph.dependents(config.f(:f)).include?(config.f(:c)),
             "c not marked a dep of f")
         assert(sorted.index(config.f(:c)) < sorted.index(config.f(:f)),
             "c is not before f")
             
         config.resource("one").each do |o|
             config.resource("two").each do |t|
                 assert(graph.dependents(o).include?(t),
                     "%s not marked a dep of %s" % [t.ref, o.ref])
                 assert(sorted.index(t) < sorted.index(o),
                     "%s is not before %s" % [t.ref, o.ref])
             end
         end
         
         trans.catalog.leaves(config.resource("middle")).each do |child|
             assert(graph.dependents(config.f(:h)).include?(child),
                 "%s not marked a dep of h" % [child.ref])
             assert(sorted.index(child) < sorted.index(config.f(:h)),
                 "%s is not before h" % child.ref)
         end
         
         # Lastly, make sure our 'g' vertex made it into the relationship
         # graph, since it's not involved in any relationships.
         assert(graph.vertex?(config.f(:g)),
             "Lost vertexes with no relations")
 
         # Now make the reversal graph and make sure all of the vertices made it into that
         reverse = graph.reversal
         %w{a b c d e f g h}.each do |letter|
             file = config.f(letter)
             assert(reverse.vertex?(file), "%s did not make it into reversal" % letter)
         end
     end
     
     # Test pre-evaluation generation
     def test_generate
         mkgenerator() do
             def generate
                 ret = []
                 if title.length > 1
                     ret << self.class.create(:title => title[0..-2])
                 else
                     return nil
                 end
                 ret
             end
         end
         
         yay = Puppet::Type.newgenerator :title => "yay"
         rah = Puppet::Type.newgenerator :title => "rah"
         config = mk_catalog(yay, rah)
         trans = Puppet::Transaction.new(config)
         
         assert_nothing_raised do
             trans.generate
         end
         
         %w{ya ra y r}.each do |name|
             assert(trans.catalog.vertex?(Puppet::Type.type(:generator)[name]),
                 "Generated %s was not a vertex" % name)
             assert($finished.include?(name), "%s was not finished" % name)
         end
         
         # Now make sure that cleanup gets rid of those generated types.
         assert_nothing_raised do
             trans.cleanup
         end
         
         %w{ya ra y r}.each do |name|
             assert(!trans.catalog.vertex?(Puppet::Type.type(:generator)[name]),
                 "Generated vertex %s was not removed from graph" % name)
             assert_nil(Puppet::Type.type(:generator)[name],
                 "Generated vertex %s was not removed from class" % name)
         end
     end
     
     # Test mid-evaluation generation.
     def test_eval_generate
         $evaluated = []
         cleanup { $evaluated = nil }
         type = mkreducer() do
             def evaluate
                 $evaluated << self.title
                 return []
             end
         end
 
         yay = Puppet::Type.newgenerator :title => "yay"
         rah = Puppet::Type.newgenerator :title => "rah", :subscribe => yay
         config = mk_catalog(yay, rah)
         trans = Puppet::Transaction.new(config)
         
         trans.prepare
         
         # Now apply the resources, and make sure they appropriately generate
         # things.
         assert_nothing_raised("failed to apply yay") do
             trans.eval_resource(yay)
         end
         ya = type["ya"]
         assert(ya, "Did not generate ya")
         assert(trans.relationship_graph.vertex?(ya),
             "Did not add ya to rel_graph")
         
         # Now make sure the appropriate relationships were added
         assert(trans.relationship_graph.edge?(yay, ya),
             "parent was not required by child")
         assert(! trans.relationship_graph.edge?(ya, rah),
             "generated child ya inherited depencency on rah")
         
         # Now make sure it in turn eval_generates appropriately
         assert_nothing_raised("failed to apply yay") do
             trans.eval_resource(type["ya"])
         end
 
         %w{y}.each do |name|
             res = type[name]
             assert(res, "Did not generate %s" % name)
             assert(trans.relationship_graph.vertex?(res),
                 "Did not add %s to rel_graph" % name)
             assert($finished.include?("y"), "y was not finished")
         end
         
         assert_nothing_raised("failed to eval_generate with nil response") do
             trans.eval_resource(type["y"])
         end
         assert(trans.relationship_graph.edge?(yay, ya), "no edge was created for ya => yay")
         
         assert_nothing_raised("failed to apply rah") do
             trans.eval_resource(rah)
         end
 
         ra = type["ra"]
         assert(ra, "Did not generate ra")
         assert(trans.relationship_graph.vertex?(ra),
             "Did not add ra to rel_graph" % name)
         assert($finished.include?("ra"), "y was not finished")
         
         # Now make sure this generated resource has the same relationships as
         # the generating resource
         assert(! trans.relationship_graph.edge?(yay, ra),
            "rah passed its dependencies on to its children")
         assert(! trans.relationship_graph.edge?(ya, ra),
             "children have a direct relationship")
         
         # Now make sure that cleanup gets rid of those generated types.
         assert_nothing_raised do
             trans.cleanup
         end
         
         %w{ya ra y r}.each do |name|
             assert(!trans.relationship_graph.vertex?(type[name]),
                 "Generated vertex %s was not removed from graph" % name)
             assert_nil(type[name],
                 "Generated vertex %s was not removed from class" % name)
         end
         
         # Now, start over and make sure that everything gets evaluated.
         trans = Puppet::Transaction.new(config)
         $evaluated.clear
         assert_nothing_raised do
             trans.evaluate
         end
         
         assert_equal(%w{yay ya y rah ra r}, $evaluated,
             "Not all resources were evaluated or not in the right order")
     end
 
     def test_ignore_tags?
         config = Puppet::Node::Catalog.new
         config.host_config = true
         transaction = Puppet::Transaction.new(config)
         assert(! transaction.ignore_tags?, "Ignoring tags when applying a host catalog")
 
         config.host_config = false
         transaction = Puppet::Transaction.new(config)
         assert(transaction.ignore_tags?, "Not ignoring tags when applying a non-host catalog")
     end
     
     def test_missing_tags?
         resource = stub 'resource', :tagged? => true
         config = Puppet::Node::Catalog.new
 
         # Mark it as a host config so we don't care which test is first
         config.host_config = true
         transaction = Puppet::Transaction.new(config)
         assert(! transaction.missing_tags?(resource), "Considered a resource to be missing tags when none are set")
 
         # host catalogs pay attention to tags, no one else does.
         Puppet[:tags] = "three,four"
         config.host_config = false
         transaction = Puppet::Transaction.new(config)
         assert(! transaction.missing_tags?(resource), "Considered a resource to be missing tags when not running a host catalog")
 
         # 
         config.host_config = true
         transaction = Puppet::Transaction.new(config)
         assert(! transaction.missing_tags?(resource), "Considered a resource to be missing tags when running a host catalog and all tags are present")
 
         transaction = Puppet::Transaction.new(config)
         resource.stubs :tagged? => false
         assert(transaction.missing_tags?(resource), "Considered a resource not to be missing tags when running a host catalog and tags are missing")
     end
     
     # Make sure changes generated by eval_generated resources have proxies
     # set to the top-level resource.
     def test_proxy_resources
         type = mkreducer do
             def evaluate
                 return Puppet::PropertyChange.new(Fakeprop.new(
                     :path => :path, :is => :is, :should => :should, :name => self.name, :resource => "a parent"), :is)
             end
         end
         
         resource = type.create :name => "test"
         config = mk_catalog(resource)
         trans = Puppet::Transaction.new(config)
         trans.prepare
 
         assert_nothing_raised do
             trans.eval_resource(resource)
         end
 
         changes = trans.instance_variable_get("@changes")
         
         assert(changes.length > 0, "did not get any changes")
         
         changes.each do |change|
             assert_equal(resource, change.source, "change did not get proxy set correctly")
         end
     end
     
     # Make sure changes in contained files still generate callback events.
     def test_generated_callbacks
         dir = tempfile()
         maker = tempfile()
         Dir.mkdir(dir)
         file = File.join(dir, "file")
         File.open(file, "w") { |f| f.puts "" }
         File.chmod(0644, file)
         File.chmod(0755, dir) # So only the child file causes a change
         
         dirobj = Puppet::Type.type(:file).create :mode => "755", :recurse => true, :path => dir
         exec = Puppet::Type.type(:exec).create :title => "make",
             :command => "touch #{maker}", :path => ENV['PATH'], :refreshonly => true,
             :subscribe => dirobj
         
         assert_apply(dirobj, exec)
         assert(FileTest.exists?(maker), "Did not make callback file")
     end
 
     # Yay, this out to be fun.
     def test_trigger
         $triggered = []
         cleanup { $triggered = nil }
         trigger = Class.new do
             attr_accessor :name
             include Puppet::Util::Logging
             def initialize(name)
                 @name = name
             end
             def ref
                 self.name
             end
             def refresh
                 $triggered << self.name
             end
 
             def to_s
                 self.name
             end
         end
 
         # Make a graph with some stuff in it.
         graph = Puppet::Node::Catalog.new
 
         # Add a non-triggering edge.
         a = trigger.new(:a)
         b = trigger.new(:b)
         c = trigger.new(:c)
         nope = Puppet::Relationship.new(a, b)
         yep = Puppet::Relationship.new(a, c, {:callback => :refresh})
-        graph.add_edge!(nope)
+        graph.add_edge(nope)
 
         # And a triggering one.
-        graph.add_edge!(yep)
+        graph.add_edge(yep)
 
         # Create our transaction
         trans = Puppet::Transaction.new(graph)
 
         # Set the non-triggering on
         assert_nothing_raised do
             trans.set_trigger(nope)
         end
 
         assert(! trans.targeted?(b), "b is incorrectly targeted")
 
         # Now set the other
         assert_nothing_raised do
             trans.set_trigger(yep)
         end
         assert(trans.targeted?(c), "c is not targeted")
 
         # Now trigger our three resources
         assert_nothing_raised do
             assert_nil(trans.trigger(a), "a somehow triggered something")
         end
         assert_nothing_raised do
             assert_nil(trans.trigger(b), "b somehow triggered something")
         end
         assert_equal([], $triggered,"got something in triggered")
         result = nil
         assert_nothing_raised do
             result = trans.trigger(c)
         end
         assert(result, "c did not trigger anything")
         assert_instance_of(Array, result)
         event = result.shift
         assert_instance_of(Puppet::Event, event)
         assert_equal(:triggered, event.event, "event was not set correctly")
         assert_equal(c, event.source, "source was not set correctly")
         assert_equal(trans, event.transaction, "transaction was not set correctly")
 
         assert(trans.triggered?(c, :refresh),
             "Transaction did not store the trigger")
     end
     
     def test_set_target
         file = Puppet::Type.newfile(:path => tempfile(), :content => "yay")
         exec1 = Puppet::Type.type(:exec).create :command => "/bin/echo exec1"
         exec2 = Puppet::Type.type(:exec).create :command => "/bin/echo exec2"
         trans = Puppet::Transaction.new(mk_catalog(file, exec1, exec2))
         
         # First try it with an edge that has no callback
         edge = Puppet::Relationship.new(file, exec1)
         assert_nothing_raised { trans.set_trigger(edge) }
         assert(! trans.targeted?(exec1), "edge with no callback resulted in a target")
         
         # Now with an edge that has an unsupported callback
         edge = Puppet::Relationship.new(file, exec1, :callback => :nosuchmethod, :event => :ALL_EVENTS)
         assert_nothing_raised { trans.set_trigger(edge) }
         assert(! trans.targeted?(exec1), "edge with invalid callback resulted in a target")
         
         # Lastly, with an edge with a supported callback
         edge = Puppet::Relationship.new(file, exec1, :callback => :refresh, :event => :ALL_EVENTS)
         assert_nothing_raised { trans.set_trigger(edge) }
         assert(trans.targeted?(exec1), "edge with valid callback did not result in a target")
     end
     
     # Testing #401 -- transactions are calling refresh() on classes that don't support it.
     def test_callback_availability
         $called = []
         klass = Puppet::Type.newtype(:norefresh) do
             newparam(:name, :namevar => true) {}
             def method_missing(method, *args)
                 $called << method
             end
         end
         cleanup do
             $called = nil
             Puppet::Type.rmtype(:norefresh)
         end
 
         file = Puppet::Type.newfile :path => tempfile(), :content => "yay"
         one = klass.create :name => "one", :subscribe => file
         
         assert_apply(file, one)
         
         assert(! $called.include?(:refresh), "Called refresh when it wasn't set as a method")
     end
 
     # Testing #437 - cyclic graphs should throw failures.
     def test_fail_on_cycle
         one = Puppet::Type.type(:exec).create(:name => "/bin/echo one")
         two = Puppet::Type.type(:exec).create(:name => "/bin/echo two")
         one[:require] = two
         two[:require] = one
 
         config = mk_catalog(one, two)
         trans = Puppet::Transaction.new(config)
         assert_raise(Puppet::Error) do
             trans.prepare
         end
     end
 
     def test_errors_during_generation
         type = Puppet::Type.newtype(:failer) do
             newparam(:name) {}
             def eval_generate
                 raise ArgumentError, "Invalid value"
             end
             def generate
                 raise ArgumentError, "Invalid value"
             end
         end
         cleanup { Puppet::Type.rmtype(:failer) }
 
         obj = type.create(:name => "testing")
 
         assert_apply(obj)
     end
     
     def test_self_refresh_causes_triggering
         type = Puppet::Type.newtype(:refresher, :self_refresh => true) do
             attr_accessor :refreshed, :testing
             newparam(:name) {}
             newproperty(:testing) do
                 def sync
                     self.is = self.should
                     :ran_testing
                 end
             end
             def refresh
                 @refreshed = true
             end
         end
         cleanup { Puppet::Type.rmtype(:refresher)}
         
         obj = type.create(:name => "yay", :testing => "cool")
         
         assert(! obj.insync?(obj.retrieve), "fake object is already in sync")
         
         # Now make sure it gets refreshed when the change happens
         assert_apply(obj)
         assert(obj.refreshed, "object was not refreshed during transaction")
     end
     
     # Testing #433
     def test_explicit_dependencies_beat_automatic
         # Create a couple of different resource sets that have automatic relationships and make sure the manual relationships win
         rels = {}
         # First users and groups
         group = Puppet::Type.type(:group).create(:name => nonrootgroup.name, :ensure => :present)
         user = Puppet::Type.type(:user).create(:name => nonrootuser.name, :ensure => :present, :gid => group.title)
         
         # Now add the explicit relationship
         group[:require] = user
         rels[group] = user
         # Now files
         d = tempfile()
         f = File.join(d, "file")
         file = Puppet::Type.newfile(:path => f, :content => "yay")
         dir = Puppet::Type.newfile(:path => d, :ensure => :directory, :require => file)
         
         rels[dir] = file
         rels.each do |after, before|
             config = mk_catalog(before, after)
             trans = Puppet::Transaction.new(config)
             str = "from %s to %s" % [before, after]
         
             assert_nothing_raised("Failed to create graph %s" % str) do
                 trans.prepare
             end
         
             graph = trans.relationship_graph
             assert(graph.edge?(before, after), "did not create manual relationship %s" % str)
             assert(! graph.edge?(after, before), "created automatic relationship %s" % str)
         end
     end
 
     # #542 - make sure resources in noop mode still notify their resources,
     # so that users know if a service will get restarted.
     def test_noop_with_notify
         path = tempfile
         epath = tempfile
         spath = tempfile
         file = Puppet::Type.newfile(:path => path, :ensure => :file,
             :title => "file")
         exec = Puppet::Type.type(:exec).create(:command => "touch %s" % epath,
             :path => ENV["PATH"], :subscribe => file, :refreshonly => true,
             :title => 'exec1')
         exec2 = Puppet::Type.type(:exec).create(:command => "touch %s" % spath,
             :path => ENV["PATH"], :subscribe => exec, :refreshonly => true,
             :title => 'exec2')
 
         Puppet[:noop] = true
 
         assert(file.noop, "file not in noop")
         assert(exec.noop, "exec not in noop")
 
         @logs.clear
         assert_apply(file, exec, exec2)
 
         assert(! FileTest.exists?(path), "Created file in noop")
         assert(! FileTest.exists?(epath), "Executed exec in noop")
         assert(! FileTest.exists?(spath), "Executed second exec in noop")
 
         assert(@logs.detect { |l|
             l.message =~ /should be/  and l.source == file.property(:ensure).path},
                 "did not log file change")
         assert(@logs.detect { |l|
             l.message =~ /Would have/ and l.source == exec.path },
                 "did not log first exec trigger")
         assert(@logs.detect { |l|
             l.message =~ /Would have/ and l.source == exec2.path },
                 "did not log second exec trigger")
     end
 
     def test_only_stop_purging_with_relations
         files = []
         paths = []
         3.times do |i|
             path = tempfile
             paths << path
             file = Puppet::Type.newfile(:path => path, :ensure => :absent,
                 :backup => false, :title => "file%s" % i)
             File.open(path, "w") { |f| f.puts "" }
             files << file
         end
 
         files[0][:ensure] = :file
         files[0][:require] = files[1..2]
 
         # Mark the second as purging
         files[1].purging
 
         assert_apply(*files)
 
         assert(FileTest.exists?(paths[1]), "Deleted required purging file")
         assert(! FileTest.exists?(paths[2]), "Did not delete non-purged file")
     end
 
     def test_flush
         $state = "absent"
         $flushed = 0
         type = Puppet::Type.newtype(:flushtest) do
             newparam(:name)
             newproperty(:ensure) do
                 def retrieve
                     $state
                 end
                 def set(value)
                     $state = value
                     :thing_changed
                 end
             end
 
             def flush
                 $flushed += 1
             end
         end
 
         cleanup { Puppet::Type.rmtype(:flushtest) }
 
         obj = type.create(:name => "test", :ensure => "present")
 
         # first make sure it runs through and flushes
         assert_apply(obj)
 
         assert_equal("present", $state, "Object did not make a change")
         assert_equal(1, $flushed, "object was not flushed")
 
         # Now run a noop and make sure we don't flush
         obj[:ensure] = "other"
         obj[:noop] = true
 
         assert_apply(obj)
         assert_equal("present", $state, "Object made a change in noop")
         assert_equal(1, $flushed, "object was flushed in noop")
     end
 end
diff --git a/test/ral/manager/type.rb b/test/ral/manager/type.rb
index 6a044687e..6c5587ddd 100755
--- a/test/ral/manager/type.rb
+++ b/test/ral/manager/type.rb
@@ -1,816 +1,816 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../lib/puppettest'
 
 require 'puppettest'
 require 'mocha'
 
 class TestType < Test::Unit::TestCase
 	include PuppetTest
     def test_typemethods
         Puppet::Type.eachtype { |type|
             name = nil
             assert_nothing_raised("Searching for name for %s caused failure" %
                 type.to_s) {
                     name = type.name
             }
 
             assert(name, "Could not find name for %s" % type.to_s)
 
             assert_equal(
                 type,
                 Puppet::Type.type(name),
                 "Failed to retrieve %s by name" % name
             )
 
             # Skip types with no parameters or valid properties
             #unless ! type.parameters.empty? or ! type.validproperties.empty?
             #    next
             #end
 
             assert_nothing_raised {
                 assert(
                     type.namevar,
                     "Failed to retrieve namevar for %s" % name
                 )
 
                 assert_not_nil(
                     type.properties,
                     "Properties for %s are nil" % name
                 )
 
                 assert_not_nil(
                     type.validproperties,
                     "Valid properties for %s are nil" % name
                 )
             }
         }
     end
 
     def test_stringvssymbols
         file = nil
         path = tempfile()
         assert_nothing_raised() {
             system("rm -f %s" % path)
             file = Puppet.type(:file).create(
                 :path => path,
                 :ensure => "file",
                 :recurse => true,
                 :checksum => "md5"
             )
         }
         assert_nothing_raised() {
             file.retrieve
         }
         assert_nothing_raised() {
             file.evaluate
         }
         Puppet.type(:file).clear
         assert_nothing_raised() {
             system("rm -f %s" % path)
             file = Puppet.type(:file).create(
                 "path" => path,
                 "ensure" => "file",
                 "recurse" => true,
                 "checksum" => "md5"
             )
         }
         assert_nothing_raised() {
             file.retrieve
         }
         assert_nothing_raised() {
             file[:path]
         }
         assert_nothing_raised() {
             file["path"]
         }
         assert_nothing_raised() {
             file[:recurse]
         }
         assert_nothing_raised() {
             file["recurse"]
         }
         assert_nothing_raised() {
             file.evaluate
         }
     end
 
     # This was supposed to test objects whose name was a property, but that
     # fundamentally doesn't make much sense, and we now don't have any such
     # types.
     def disabled_test_nameasproperty
         # currently groups are the only objects with the namevar as a property
         group = nil
         assert_nothing_raised {
             group = Puppet.type(:group).create(
                 :name => "testing"
             )
         }
 
         assert_equal("testing", group.name, "Could not retrieve name")
     end
 
     # Verify that values get merged correctly
     def test_mergepropertyvalues
         file = tempfile()
 
         # Create the first version
         assert_nothing_raised {
             Puppet.type(:file).create(
                 :path => file,
                 :owner => ["root", "bin"]
             )
         }
 
         # Make sure no other statements are allowed
         assert_raise(Puppet::Error) {
             Puppet.type(:file).create(
                 :path => file,
                 :group => "root"
             )
         }
     end
 
     def test_aliases_to_self_are_not_failures
         resource = Puppet.type(:file).create(
             :name => "/path/to/some/missing/file",
             :ensure => "file"
         )
         resource.stubs(:path).returns("")
 
         catalog = stub 'catalog'
         catalog.expects(:resource).with(:file, "/path/to/some/missing/file").returns(resource)
         resource.catalog = catalog
 
         # Verify our adding ourselves as an alias isn't an error.
         assert_nothing_raised("Could not add alias") {
             resource[:alias] = "/path/to/some/missing/file"
         }
 
         assert_equal(resource.object_id, Puppet.type(:file)["/path/to/some/missing/file"].object_id, "Could not retrieve alias to self")
     end
 
     def test_aliases_are_added_to_class_and_catalog
         resource = Puppet.type(:file).create(
             :name => "/path/to/some/missing/file",
             :ensure => "file"
         )
         resource.stubs(:path).returns("")
 
         catalog = stub 'catalog'
         catalog.stubs(:resource).returns(nil)
         catalog.expects(:alias).with(resource, "funtest")
         resource.catalog = catalog
 
         assert_nothing_raised("Could not add alias") {
             resource[:alias] = "funtest"
         }
 
         assert_equal(resource.object_id, Puppet.type(:file)["funtest"].object_id, "Could not retrieve alias")
     end
 
     def test_aliasing_fails_without_a_catalog
         resource = Puppet.type(:file).create(
             :name => "/no/such/file",
             :ensure => "file"
         )
 
         assert_raise(Puppet::Error, "Did not fail to alias when no catalog was available") {
             resource[:alias] = "funtest"
         }
     end
 
     def test_catalogs_are_set_during_initialization_if_present_on_the_transobject
         trans = Puppet::TransObject.new("/path/to/some/file", :file)
         trans.catalog = :my_config
         resource = trans.to_type
         assert_equal(resource.catalog, trans.catalog, "Did not set catalog on initialization")
     end
 
     # Verify that requirements don't depend on file order
     def test_prereqorder
         one = tempfile()
         two = tempfile()
 
         twoobj = nil
         oneobj = nil
         assert_nothing_raised("Could not create prereq that doesn't exist yet") {
             twoobj = Puppet.type(:file).create(
                 :name => two,
                 :require => [:file, one]
             )
         }
 
         assert_nothing_raised {
             oneobj = Puppet.type(:file).create(
                 :name => one
             )
         }
 
         comp = mk_catalog(twoobj, oneobj)
 
         assert_nothing_raised {
             comp.finalize
         }
 
 
         assert(twoobj.requires?(oneobj), "Requirement was not created")
     end
 
     # Verify that names are aliases, not equivalents
     def test_nameasalias
         file = nil
         # Create the parent dir, so we make sure autorequiring the parent dir works
         parentdir = tempfile()
         dir = Puppet.type(:file).create(
             :name => parentdir,
             :ensure => "directory"
         )
         assert_apply(dir)
         path = File.join(parentdir, "subdir")
         name = "a test file"
         transport = Puppet::TransObject.new(name, "file")
         transport[:path] = path
         transport[:ensure] = "file"
         assert_nothing_raised {
             file = transport.to_type
         }
 
         assert_equal(path, file[:path])
         assert_equal(name, file.title)
 
         assert_nothing_raised {
             file.retrieve
         }
 
         assert_apply(file)
 
         assert(Puppet.type(:file)[name], "Could not look up object by name")
     end
 
     def test_ensuredefault
         user = nil
         assert_nothing_raised {
             user = Puppet.type(:user).create(
                 :name => "pptestAA",
                 :check => [:uid]
             )
         }
 
         # make sure we don't get :ensure for unmanaged files
         assert(! user.property(:ensure), "User got an ensure property")
 
         assert_nothing_raised {
             user = Puppet.type(:user).create(
                 :name => "pptestAB",
                 :comment => "Testingness"
             )
         }
         # but make sure it gets added once we manage them
         assert(user.property(:ensure), "User did not add ensure property")
 
         assert_nothing_raised {
             user = Puppet.type(:user).create(
                 :name => "pptestBC",
                 :comment => "A fake user"
             )
         }
 
         # and make sure managed objects start with them
         assert(user.property(:ensure), "User did not get an ensure property")
     end
     def test_newtype_methods
         assert_nothing_raised {
             Puppet::Type.newtype(:mytype) do
                 newparam(:wow) do isnamevar end
             end
         }
 
         assert(Puppet::Type.respond_to?(:newmytype),
             "new<type> method did not get created")
 
         obj = nil
         assert_nothing_raised {
             obj = Puppet::Type.newmytype(:wow => "yay")
         }
 
         assert(obj.is_a?(Puppet::Type.type(:mytype)),
             "Obj is not the correct type")
 
         # Now make the type again, just to make sure it works on refreshing.
         assert_nothing_raised {
             Puppet::Type.newtype(:mytype) do
                 newparam(:yay) do isnamevar end
             end
         }
 
         obj = nil
         # Make sure the old class was thrown away and only the new one is sitting
         # around.
         assert_raise(Puppet::Error) {
             obj = Puppet::Type.newmytype(:wow => "yay")
         }
         assert_nothing_raised {
             obj = Puppet::Type.newmytype(:yay => "yay")
         }
 
         # Now make sure that we don't replace existing, non-type methods
         parammethod = Puppet::Type.method(:newparam)
 
         assert_nothing_raised {
             Puppet::Type.newtype(:param) do
                 newparam(:rah) do isnamevar end
             end
         }
         assert_equal(parammethod, Puppet::Type.method(:newparam),
             "newparam method got replaced by newtype")
     end
 
     def test_newproperty_options
         # Create a type with a fake provider
         providerclass = Class.new do
             def self.supports_parameter?(prop)
                 return true
             end
             def method_missing(method, *args)
                 return method
             end
         end
         self.class.const_set("ProviderClass", providerclass)
 
         type = Puppet::Type.newtype(:mytype) do
             newparam(:name) do
                 isnamevar
             end
             def provider
                 @provider ||= ProviderClass.new
 
                 @provider
             end
         end
 
         # Now make a property with no options.
         property = nil
         assert_nothing_raised do
             property = type.newproperty(:noopts) do
             end
         end
 
         # Now create an instance
         obj = type.create(:name => :myobj)
 
         inst = property.new(:resource => obj)
 
         # And make sure it's correctly setting @is
         ret = nil
         assert_nothing_raised {
             ret = inst.retrieve
         }
 
         assert_equal(:noopts, inst.retrieve)
 
         # Now create a property with a different way of doing it
         property = nil
         assert_nothing_raised do
             property = type.newproperty(:setretrieve, :retrieve => :yayness)
         end
 
         inst = property.new(:resource => obj)
 
         # And make sure it's correctly setting @is
         ret = nil
         assert_nothing_raised {
             ret = inst.retrieve
         }
 
         assert_equal(:yayness, ret)
     end
 
     def test_name_vs_title
         path = tempfile()
 
         trans = nil
 
         assert_nothing_raised {
             trans = Puppet::TransObject.new(path, :file)
         }
 
         file = nil
         assert_nothing_raised {
             file = Puppet::Type.newfile(trans)
         }
 
         assert(file.respond_to?(:title),
             "No 'title' method")
 
         assert(file.respond_to?(:name),
             "No 'name' method")
 
         assert_equal(file.title, file.name,
             "Name and title were not marked equal")
 
         assert_nothing_raised {
             file.title = "My file"
         }
 
         assert_equal("My file", file.title)
         assert_equal(path, file.name)
     end
 
     # Make sure the title is sufficiently differentiated from the namevar.
     def test_title_at_creation_with_hash
         file = nil
         fileclass = Puppet::Type.type(:file) 
 
         path = tempfile()
         assert_nothing_raised do
             file = fileclass.create(
                 :title => "Myfile",
                 :path => path
             )
         end
 
         assert_equal("Myfile", file.title, "Did not get correct title")
         assert_equal(path, file[:name], "Did not get correct name")
 
         file = nil
         Puppet::Type.type(:file).clear
 
         # Now make sure we can specify both and still get the right answers
         assert_nothing_raised do
             file = fileclass.create(
                 :title => "Myfile",
                 :name => path
             )
         end
 
         assert_instance_of(fileclass, file)
 
         assert_equal("Myfile", file.title, "Did not get correct title")
         assert_equal(path, file[:name], "Did not get correct name")
     end
 
     # Make sure the "create" class method behaves appropriately.
     def test_class_create
         title = "Myfile"
         validate = proc do |element|
             assert(element, "Did not create file")
             assert_instance_of(Puppet::Type.type(:file), element)
             assert_equal(title, element.title, "Title is not correct")
         end
         type = :file
         args = {:path => tempfile(), :owner => "root"}
 
         trans = Puppet::TransObject.new(title, type)
         args.each do |name, val| trans[name] = val end
 
         # First call it on the appropriate typeclass
         obj = nil
         assert_nothing_raised do
             obj = Puppet::Type.type(:file).create(trans)
         end
 
         validate.call(obj)
 
         # Now try it using the class method on Type
         oldid = obj.object_id
         obj = nil
         Puppet::Type.type(:file).clear
 
         assert_nothing_raised {
             obj = Puppet::Type.create(trans)
         }
 
         validate.call(obj)
         assert(oldid != obj.object_id, "Got same object back")
 
         # Now try the same things with hashes instead of a transobject
         oldid = obj.object_id
         obj = nil
         Puppet::Type.type(:file).clear
         hash = {
             :type => :file,
             :title => "Myfile",
             :path => tempfile(),
             :owner => "root"
         }
 
         # First call it on the appropriate typeclass
         obj = nil
         assert_nothing_raised do
             obj = Puppet::Type.type(:file).create(hash)
         end
 
         validate.call(obj)
         assert_equal(:file, obj.should(:type),
             "Type param did not pass through")
 
         assert(oldid != obj.object_id, "Got same object back")
 
         # Now try it using the class method on Type
         oldid = obj.object_id
         obj = nil
         Puppet::Type.type(:file).clear
 
         assert_nothing_raised {
             obj = Puppet::Type.create(hash)
         }
 
         validate.call(obj)
         assert(oldid != obj.object_id, "Got same object back")
         assert_nil(obj.should(:type),
             "Type param passed through")
     end
 
     def test_multiplenames
         obj = nil
         path = tempfile()
         assert_raise ArgumentError do
             obj = Puppet::Type.type(:file).create(
                 :name => path,
                 :path => path
             )
         end
     end
 
     def test_title_and_name
         obj = nil
         path = tempfile()
         fileobj = Puppet::Type.type(:file)
 
         assert_nothing_raised do
             obj = fileobj.create(
                 :title => "myfile",
                 :path => path
             )
         end
 
         assert_equal(obj, fileobj["myfile"],
             "Could not retrieve obj by title")
 
         assert_equal(obj, fileobj[path],
             "Could not retrieve obj by name")
     end
 
     # Make sure default providers behave correctly
     def test_defaultproviders
         # Make a fake type
         type = Puppet::Type.newtype(:defaultprovidertest) do
             newparam(:name) do end
         end
 
         basic = type.provide(:basic) do
             defaultfor :operatingsystem => :somethingelse,
                 :operatingsystemrelease => :yayness
         end
 
         assert_equal(basic, type.defaultprovider)
         type.defaultprovider = nil
 
         greater = type.provide(:greater) do
             defaultfor :operatingsystem => Facter.value("operatingsystem")
         end
 
         assert_equal(greater, type.defaultprovider)
     end
 
     # Make sure that we can have multiple isomorphic objects with the same name,
     # but not with non-isomorphic objects.
     def test_isomorphic_names
         # First do execs, since they're not isomorphic.
         echo = Puppet::Util.binary "echo"
         exec1 = exec2 = nil
         assert_nothing_raised do
             exec1 = Puppet::Type.type(:exec).create(
                 :title => "exec1",
                 :command => "#{echo} funtest"
             )
         end
         assert_nothing_raised do
             exec2 = Puppet::Type.type(:exec).create(
                 :title => "exec2",
                 :command => "#{echo} funtest"
             )
         end
 
         assert_apply(exec1, exec2)
 
         # Now do files, since they are. This should fail.
         file1 = file2 = nil
         path = tempfile()
         assert_nothing_raised do
             file1 = Puppet::Type.type(:file).create(
                 :title => "file1",
                 :path => path,
                 :content => "yayness"
             )
         end
 
         # This will fail, but earlier systems will catch it.
         assert_raise(Puppet::Error) do
             file2 = Puppet::Type.type(:file).create(
                 :title => "file2",
                 :path => path,
                 :content => "rahness"
             )
         end
 
         assert(file1, "Did not create first file")
         assert_nil(file2, "Incorrectly created second file")
     end
 
     def test_tags
         obj = Puppet::Type.type(:file).create(:path => tempfile())
 
         tags = [:some, :test, :tags]
 
         obj.tags = tags
 
         assert_equal(tags + [:file], obj.tags)
     end
 
     def disabled_test_list
         Puppet::Type.loadall
 
         Puppet::Type.eachtype do |type|
             next if type.name == :symlink
             next if type.name == :component
             next if type.name == :tidy
             assert(type.respond_to?(:list), "%s does not respond to list" % type.name)
         end
     end
 
     def test_to_hash
         file = Puppet::Type.newfile :path => tempfile(), :owner => "luke",
             :recurse => true, :loglevel => "warning"
 
         hash = nil
         assert_nothing_raised do
             hash = file.to_hash
         end
 
         [:path, :owner, :recurse, :loglevel].each do |param|
             assert(hash[param], "Hash did not include %s" % param)
         end
     end
 
     # Make sure that classes behave like hashes.
     def test_class_hash_behaviour
         path = tempfile()
 
         filetype = Puppet::Type.type(:file)
         one = Puppet::Type.newfile :path => path
 
         assert_equal(one, filetype[path], "Did not get file back")
 
         assert_raise(Puppet::Error) do
             filetype[path] = one
         end
     end
 
     def test_ref
         path = tempfile()
         Puppet::Type.type(:exec) # uggh, the methods need to load the types
         file = Puppet::Type.newfile(:path => path)
         assert_equal("File[#{path}]", file.ref)
 
         exec = Puppet::Type.newexec(:title => "yay", :command => "/bin/echo yay")
         assert_equal("Exec[yay]", exec.ref)
     end
     
     def test_noop_metaparam
         file = Puppet::Type.newfile :path => tempfile
         assert(!file.noop, "file incorrectly in noop")
         
         assert_nothing_raised do
             file[:noop] = true
         end
         assert(file.noop, "file should be in noop")
         
         # Now set the main one
         Puppet[:noop] = true
         assert(file.noop, "file should be in noop")
         file[:noop] = false
         assert(file.noop, "file should be in noop")
     end
     
     def test_path
         config = mk_catalog
 
         # Check that our paths are built correctly.  Just pick a random, "normal" type.
         type = Puppet::Type.type(:exec)
         mk = Proc.new do |i, hash|
             hash[:title] = "exec%s" % i
             hash[:command] = "/bin/echo"
             if parent = hash[:parent]
                 hash.delete(:parent)
             end
             res = type.create(hash)
             config.add_resource res
             if parent
-                config.add_edge!(parent, res)
+                config.add_edge(parent, res)
             end
             res
         end
         
         exec = mk.call(1, {})
         
         assert_equal("/Exec[exec1]", exec.path)
         
         comp = Puppet::Type.newcomponent :title => "My[component]", :type => "Yay"
         config.add_resource comp
         
         exec = mk.call(2, :parent => comp)
         
         assert_equal("/My[component]/Exec[exec2]", exec.path)
         
         comp = Puppet::Type.newcomponent :name => "Other[thing]"
         config.add_resource comp
         exec = mk.call(3, :parent => comp)
         assert_equal("/Other[thing]/Exec[exec3]", exec.path)
         
         comp = Puppet::Type.newcomponent :type => "server", :name => "server"
         config.add_resource comp
         exec = mk.call(4, :parent => comp)
         assert_equal("/server/Exec[exec4]", exec.path)
         
         comp = Puppet::Type.newcomponent :type => "whatever", :name => "class[main]"
         config.add_resource comp
         exec = mk.call(5, :parent => comp)
         assert_equal("//Exec[exec5]", exec.path)
         
         newcomp = Puppet::Type.newcomponent :type => "yay", :name => "Good[bad]"
         config.add_resource newcomp
-        config.add_edge! comp, newcomp
+        config.add_edge comp, newcomp
         exec = mk.call(6, :parent => newcomp)
         assert_equal("//Good[bad]/Exec[exec6]", exec.path)
     end
 
     def test_evaluate
         faketype = Puppet::Type.newtype(:faketype) do
             newparam(:name) {}
         end
         cleanup { Puppet::Type.rmtype(:faketype) }
         faketype.provide(:fake) do
             def prefetch
             end
         end
 
         obj = faketype.create :name => "yayness", :provider => :fake
         assert(obj, "did not create object")
 
         obj.provider.expects(:prefetch)
         obj.expects(:retrieve)
         obj.expects(:propertychanges).returns([])
         obj.expects(:cache)
 
         obj.evaluate
     end
 
     # Partially test #704, but also cover the rest of the schedule management bases.
     def test_schedule
         Puppet::Type.type(:schedule).create(:name => "maint")
 
         {"maint" => true, nil => false, :fail => :fail}.each do |name, should|
             args = {:name => tempfile, :ensure => :file}
             if name
                 args[:schedule] = name
             end
             resource = Puppet::Type.type(:file).create(args)
 
             if should == :fail
                 assert_raise(Puppet::Error, "Did not fail on missing schedule") do
                     resource.schedule
                 end
             else
                 sched = nil
                 assert_nothing_raised("Failed when schedule was %s" % sched) do
                     sched = resource.schedule
                 end
 
                 if should
                     assert_equal(name, sched.name, "did not get correct schedule back")
                 end
             end
         end
     end
 
     # #801 -- resources only checked in noop should be rescheduled immediately.
     def test_reschedule_when_noop
         Puppet::Type.type(:schedule).mkdefaultschedules
         file = Puppet::Type.type(:file).create(:path => "/tmp/whatever", :mode => "755", :noop => true, :schedule => :daily, :ensure => :file)
 
         assert(file.noop?, "File not considered in noop")
         assert(file.scheduled?, "File is not considered scheduled")
 
         file.evaluate
 
         assert_nil(file.cached(:checked), "Stored a checked time when running in noop mode when there were changes")
         file.cache(:checked, nil)
 
         file.stubs(:propertychanges).returns([])
 
         file.evaluate
         assert_instance_of(Time, file.cached(:checked), "Did not store a checked time when running in noop mode when there were no changes")
     end
 end
diff --git a/test/ral/types/basic.rb b/test/ral/types/basic.rb
index 7bbadc5bc..3c5faeee0 100755
--- a/test/ral/types/basic.rb
+++ b/test/ral/types/basic.rb
@@ -1,85 +1,85 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../lib/puppettest'
 
 require 'puppettest'
 
 class TestBasic < Test::Unit::TestCase
 	include PuppetTest
 
     def setup
         super
         @component = nil
         @configfile = nil
         @command = nil
 
         assert_nothing_raised() {
             @component = Puppet.type(:component).create(
                 :name => "yaytest",
                 :type => "testing"
             )
         }
 
         assert_nothing_raised() {
             @filepath = tempfile()
             @configfile = Puppet.type(:file).create(
                 :path => @filepath,
                 :ensure => "file",
                 :checksum => "md5"
             )
         }
         assert_nothing_raised() {
             @command = Puppet.type(:exec).create(
                 :title => "echo",
                 :command => "echo yay",
                 :path => ENV["PATH"]
             )
         }
         @config = mk_catalog(@component, @configfile, @command)
-        @config.add_edge! @component, @configfile
-        @config.add_edge! @component, @command
+        @config.add_edge @component, @configfile
+        @config.add_edge @component, @command
     end
 
     def teardown
         super
         stopservices
     end
 
     def test_values
         [:ensure, :checksum].each do |param|
             prop = @configfile.property(param)
             assert(prop, "got no property for %s" % param)
             assert(prop.value, "got no value for %s" % param)
         end
     end
 
     def test_name_calls
         [@command, @configfile].each { |obj|
             Puppet.debug "obj is %s" % obj
             assert_nothing_raised(){
                 obj.name
             }
         }
     end
 
     def test_name_equality
         assert_equal(@filepath, @configfile.title)
 
         assert_equal("echo", @command.title)
     end
 
     def test_object_retrieval
         [@command, @configfile].each { |obj|
             assert_equal(obj.class[obj.name].object_id, obj.object_id,
                 "%s did not match class version" % obj.ref)
         }
     end
 
     def test_paths
         [@configfile, @command, @component].each { |obj|
             assert_nothing_raised {
                 assert_instance_of(String, obj.path)
             }
         }
     end
 end