diff --git a/lib/puppet/resource/catalog.rb b/lib/puppet/resource/catalog.rb
index a8668d844..fed0f46da 100644
--- a/lib/puppet/resource/catalog.rb
+++ b/lib/puppet/resource/catalog.rb
@@ -1,595 +1,591 @@
 require 'puppet/node'
 require 'puppet/indirector'
 require 'puppet/simple_graph'
 require 'puppet/transaction'
 
 require 'puppet/util/cacher'
 require 'puppet/util/pson'
 
 require 'puppet/util/tagging'
 
 # This class models a node catalog.  It is the thing
 # meant to be passed from server to client, and it contains all
 # of the information in the catalog, including the resources
 # and the relationships between them.
 class Puppet::Resource::Catalog < Puppet::SimpleGraph
   class DuplicateResourceError < Puppet::Error; end
 
   extend Puppet::Indirector
   indirects :catalog, :terminus_setting => :catalog_terminus
 
   include Puppet::Util::Tagging
   extend Puppet::Util::Pson
   include Puppet::Util::Cacher::Expirer
 
   # The host name this is a catalog for.
   attr_accessor :name
 
   # The catalog version.  Used for testing whether a catalog
   # is up to date.
   attr_accessor :version
 
   # How long this catalog took to retrieve.  Used for reporting stats.
   attr_accessor :retrieval_duration
 
   # Whether this is a host catalog, which behaves very differently.
   # In particular, reports are sent, graphs are made, and state is
   # stored in the state database.  If this is set incorrectly, then you often
   # end up in infinite loops, because catalogs are used to make things
   # that the host catalog needs.
   attr_accessor :host_config
 
   # Whether this catalog was retrieved from the cache, which affects
   # whether it is written back out again.
   attr_accessor :from_cache
 
   # Some metadata to help us compile and generally respond to the current state.
   attr_accessor :client_version, :server_version
 
   # 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
 
   def title_key_for_ref( ref )
     ref =~ /^([-\w:]+)\[(.*)\]$/m
     [$1, $2]
   end
 
-  # Add one or more resources to our graph and to our resource table.
+  # Add a resource to our graph and to our resource table.
   # This is actually a relatively complicated method, because it handles multiple
   # aspects of Catalog behaviour:
   # * Add the resource to the resource table
   # * Add the resource to the resource graph
   # * Add the resource to the relationship graph
   # * Add any aliases that make sense for the resource (e.g., name != title)
-  def add_resource(*resources)
-    resources.each do |resource|
-      raise ArgumentError, "Can only add objects that respond to :ref, not instances of #{resource.class}" unless resource.respond_to?(:ref)
-    end.each { |resource| fail_on_duplicate_type_and_title(resource) }.each do |resource|
-      title_key = title_key_for_ref(resource.ref)
-
-      @transient_resources << resource if applying?
-      @resource_table[title_key] = resource
-
-      # If the name and title differ, set up an alias
-
-      if resource.respond_to?(:name) and resource.respond_to?(:title) and resource.respond_to?(:isomorphic?) and resource.name != resource.title
-        self.alias(resource, resource.uniqueness_key) if resource.isomorphic?
-      end
-
-      resource.catalog = self if resource.respond_to?(:catalog=)
-
-      add_vertex(resource)
-
-      @relationship_graph.add_vertex(resource) if @relationship_graph
-
-      yield(resource) if block_given?
+  def add_resource(*resource)
+    add_resource(*resource[0..-2]) if resource.length > 1
+    resource = resource.pop
+    raise ArgumentError, "Can only add objects that respond to :ref, not instances of #{resource.class}" unless resource.respond_to?(:ref)
+    fail_on_duplicate_type_and_title(resource)
+    title_key = title_key_for_ref(resource.ref)
+ 
+    @transient_resources << resource if applying?
+    @resource_table[title_key] = resource
+
+    # If the name and title differ, set up an alias
+
+    if resource.respond_to?(:name) and resource.respond_to?(:title) and resource.respond_to?(:isomorphic?) and resource.name != resource.title
+      self.alias(resource, resource.uniqueness_key) if resource.isomorphic?
     end
+
+    resource.catalog = self if resource.respond_to?(:catalog=)
+    add_vertex(resource)
+    @relationship_graph.add_vertex(resource) if @relationship_graph
   end
 
   # Create an alias for a resource.
   def alias(resource, key)
     resource.ref =~ /^(.+)\[/
     class_name = $1 || resource.class.name
 
     newref = [class_name, key]
 
     if key.is_a? String
       ref_string = "#{class_name}[#{key}]"
       return if ref_string == resource.ref
     end
 
     # LAK:NOTE It's important that we directly compare the references,
     # because sometimes an alias is created before the resource is
     # added to the catalog, so comparing inside the below if block
     # isn't sufficient.
     if existing = @resource_table[newref]
       return if existing == resource
       raise(ArgumentError, "Cannot alias #{resource.ref} to #{key.inspect}; resource #{newref.inspect} already exists")
     end
     @resource_table[newref] = resource
     @aliases[resource.ref] ||= []
     @aliases[resource.ref] << newref
   end
 
   # Apply our catalog to the local host.  Valid options
   # are:
   #   :tags - set the tags that restrict what resources run
   #       during the transaction
   #   :ignoreschedules - tell the transaction to ignore schedules
   #       when determining the resources to run
   def apply(options = {})
     @applying = true
 
     # Expire all of the resource data -- this ensures that all
     # data we're operating against is entirely current.
     expire
 
     Puppet::Util::Storage.load if host_config?
     transaction = Puppet::Transaction.new(self)
 
     transaction.report = options[:report] if options[:report]
     transaction.tags = options[:tags] if options[:tags]
     transaction.ignoreschedules = true if options[:ignoreschedules]
 
     transaction.add_times :config_retrieval => self.retrieval_duration || 0
 
     begin
       transaction.evaluate
     rescue Puppet::Error => detail
       puts detail.backtrace if Puppet[:trace]
       Puppet.err "Could not apply complete catalog: #{detail}"
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       Puppet.err "Got an uncaught exception of type #{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?
 
     return transaction
   ensure
     @applying = false
     cleanup
   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 @relationship_graph
       @relationship_graph.clear
       @relationship_graph = nil
     end
   end
 
   def classes
     @classes.dup
   end
 
   # Create a new resource and register it in the catalog.
   def create_resource(type, options)
     unless klass = Puppet::Type.type(type)
       raise ArgumentError, "Unknown resource type #{type}"
     end
     return unless resource = klass.new(options)
 
     add_resource(resource)
     resource
   end
 
   def dependent_data_expired?(ts)
     if applying?
       return super
     else
       return true
     end
   end
 
   # Turn our catalog graph into an old-style tree of TransObjects and TransBuckets.
   # LAK:NOTE(20081211): This is a  pre-0.25 backward compatibility method.
   # It can be removed as soon as xmlrpc is killed.
   def extract
     top = nil
     current = nil
     buckets = {}
 
     unless main = resource(:stage, "main")
       raise Puppet::DevError, "Could not find 'main' stage; cannot generate catalog"
     end
 
     if stages = vertices.find_all { |v| v.type == "Stage" and v.title != "main" } and ! stages.empty?
       Puppet.warning "Stages are not supported by 0.24.x client; stage(s) #{stages.collect { |s| s.to_s }.join(', ') } will be ignored"
     end
 
     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
         raise "No bucket created for #{source}" unless bucket
         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.
         buckets[target.to_s] = child unless target.builtin?
       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
     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
   end
 
   def initialize(name = nil)
     super()
     @name = name if name
     @classes = []
     @resource_table = {}
     @transient_resources = []
     @applying = false
     @relationship_graph = nil
 
     @host_config = true
 
     @aliases = {}
 
     if block_given?
       yield(self)
       finalize
     end
   end
 
   # Make the default objects necessary for function.
   def make_default_resources
     # We have to add the resources to the catalog, or else they won't get cleaned up after
     # the transaction.
 
     # First create the default scheduling objects
     Puppet::Type.type(:schedule).mkdefaultschedules.each { |res| add_resource(res) unless resource(res.ref) }
 
     # And filebuckets
     if bucket = Puppet::Type.type(:filebucket).mkdefaultbucket
       add_resource(bucket) unless resource(bucket.ref)
     end
   end
 
   # Create a graph of all of the relationships in our catalog.
   def relationship_graph
     unless @relationship_graph
       # It's important that we assign the graph immediately, because
       # the debug messages below use the relationships in the
       # relationship graph to determine the path to the resources
       # spitting out the messages.  If this is not set,
       # then we get into an infinite loop.
       @relationship_graph = Puppet::SimpleGraph.new
 
       # First create the dependency graph
       self.vertices.each do |vertex|
         @relationship_graph.add_vertex vertex
         vertex.builddepends.each do |edge|
           @relationship_graph.add_edge(edge)
         end
       end
 
       # Lastly, add in any autorequires
       @relationship_graph.vertices.each do |vertex|
         vertex.autorequire(self).each do |edge|
           unless @relationship_graph.edge?(edge.source, edge.target) # don't let automatic relationships conflict with manual ones.
             unless @relationship_graph.edge?(edge.target, edge.source)
               vertex.debug "Autorequiring #{edge.source}"
               @relationship_graph.add_edge(edge)
             else
               vertex.debug "Skipping automatic relationship with #{(edge.source == vertex ? edge.target : edge.source)}"
             end
           end
         end
       end
       @relationship_graph.write_graph(:relationships) if host_config?
 
       # Then splice in the container information
       @relationship_graph.splice!(self, Puppet::Type::Component)
 
       @relationship_graph.write_graph(:expanded_relationships) if host_config?
     end
     @relationship_graph
   end
 
   # Remove the resource from our catalog.  Notice that we also call
   # 'remove' on the resource, at least until resource classes no longer maintain
   # references to the resource instances.
   def remove_resource(*resources)
     resources.each do |resource|
       @resource_table.delete(resource.ref)
       if aliases = @aliases[resource.ref]
         aliases.each { |res_alias| @resource_table.delete(res_alias) }
         @aliases.delete(resource.ref)
       end
       remove_vertex!(resource) if vertex?(resource)
       @relationship_graph.remove_vertex!(resource) if @relationship_graph and @relationship_graph.vertex?(resource)
       resource.remove
     end
   end
 
   # Look a resource up by its reference (e.g., File[/etc/passwd]).
   def resource(type, title = nil)
     # Always create a resource reference, so that it always canonizes how we
     # are referring to them.
     if title
       res = Puppet::Resource.new(type, title)
     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.
       res = Puppet::Resource.new(nil, type)
     end
     title_key      = [res.type, res.title.to_s]
     uniqueness_key = [res.type, res.uniqueness_key]
     @resource_table[title_key] || @resource_table[uniqueness_key]
   end
 
   def resource_refs
     resource_keys.collect{ |type, name| name.is_a?( String ) ? "#{type}[#{name}]" : nil}.compact
   end
 
   def resource_keys
     @resource_table.keys
   end
 
   def resources
     @resource_table.values.uniq
   end
 
   def self.from_pson(data)
     result = new(data['name'])
 
     if tags = data['tags']
       result.tag(*tags)
     end
 
     if version = data['version']
       result.version = version
     end
 
     if resources = data['resources']
       resources = PSON.parse(resources) if resources.is_a?(String)
       resources.each do |res|
         resource_from_pson(result, res)
       end
     end
 
     if edges = data['edges']
       edges = PSON.parse(edges) if edges.is_a?(String)
       edges.each do |edge|
         edge_from_pson(result, edge)
       end
     end
 
     if classes = data['classes']
       result.add_class(*classes)
     end
 
     result
   end
 
   def self.edge_from_pson(result, edge)
     # If no type information was presented, we manually find
     # the class.
     edge = Puppet::Relationship.from_pson(edge) if edge.is_a?(Hash)
     unless source = result.resource(edge.source)
       raise ArgumentError, "Could not convert from pson: Could not find relationship source #{edge.source.inspect}"
     end
     edge.source = source
 
     unless target = result.resource(edge.target)
       raise ArgumentError, "Could not convert from pson: Could not find relationship target #{edge.target.inspect}"
     end
     edge.target = target
 
     result.add_edge(edge)
   end
 
   def self.resource_from_pson(result, res)
     res = Puppet::Resource.from_pson(res) if res.is_a? Hash
     result.add_resource(res)
   end
 
   PSON.register_document_type('Catalog',self)
   def to_pson_data_hash
     {
       'document_type' => 'Catalog',
       'data'       => {
         'tags'      => tags,
         'name'      => name,
         'version'   => version,
         'resources' => vertices.collect { |v| v.to_pson_data_hash },
         'edges'     => edges.   collect { |e| e.to_pson_data_hash },
         'classes'   => classes
         },
       'metadata' => {
         'api_version' => 1
         }
     }
   end
 
   def to_pson(*args)
     to_pson_data_hash.to_pson(*args)
   end
 
   # Convert our catalog into a RAL catalog.
   def to_ral
     to_catalog :to_ral
   end
 
   # Convert our catalog into a catalog of Puppet::Resource instances.
   def to_resource
     to_catalog :to_resource
   end
 
   # filter out the catalog, applying +block+ to each resource.
   # If the block result is false, the resource will
   # be kept otherwise it will be skipped
   def filter(&block)
     to_catalog :to_resource, &block
   end
 
   # Store the classes in the classfile.
   def write_class_file
       ::File.open(Puppet[:classfile], "w") do |f|
         f.puts classes.join("\n")
       end
   rescue => detail
       Puppet.err "Could not create class file #{Puppet[:classfile]}: #{detail}"
   end
 
   # Produce the graph files if requested.
   def write_graph(name)
     # We only want to graph the main host catalog.
     return unless host_config?
 
     super
   end
 
   private
 
   def cleanup
     # Expire any cached data the resources are keeping.
     expire
   end
 
   # Verify that the given resource isn't defined elsewhere.
   def fail_on_duplicate_type_and_title(resource)
     # Short-curcuit the common case,
     return unless existing_resource = @resource_table[title_key_for_ref(resource.ref)]
 
     # If we've gotten this far, it's a real conflict
     msg = "Duplicate definition: #{resource.ref} is already defined"
 
     msg << " in file #{existing_resource.file} at line #{existing_resource.line}" if existing_resource.file and existing_resource.line
 
     msg << "; cannot redefine" if resource.line or resource.file
 
     raise DuplicateResourceError.new(msg)
   end
 
   # An abstracted method for converting one catalog into another type of catalog.
   # This pretty much just converts all of the resources from one class to another, using
   # a conversion method.
   def to_catalog(convert)
     result = self.class.new(self.name)
 
     result.version = self.version
 
     map = {}
     vertices.each do |resource|
       next if virtual_not_exported?(resource)
       next if block_given? and yield resource
 
       #This is hackity hack for 1094
       #Aliases aren't working in the ral catalog because the current instance of the resource
       #has a reference to the catalog being converted. . . So, give it a reference to the new one
       #problem solved. . .
       if resource.class == Puppet::Resource
         resource = resource.dup
         resource.catalog = result
       elsif resource.is_a?(Puppet::TransObject)
         resource = resource.dup
         resource.catalog = result
       elsif resource.is_a?(Puppet::Parser::Resource)
         resource = resource.to_resource
         resource.catalog = result
       end
 
       if resource.is_a?(Puppet::Resource) and convert.to_s == "to_resource"
         newres = resource
       else
         newres = resource.send(convert)
       end
 
       # We can't guarantee that resources don't munge their names
       # (like files do with trailing slashes), so we have to keep track
       # of what a resource got converted to.
       map[resource.ref] = newres
 
       result.add_resource newres
     end
 
     message = convert.to_s.gsub "_", " "
     edges.each do |edge|
       # Skip edges between virtual resources.
       next if virtual_not_exported?(edge.source)
       next if block_given? and yield edge.source
 
       next if virtual_not_exported?(edge.target)
       next if block_given? and yield edge.target
 
       unless source = map[edge.source.ref]
         raise Puppet::DevError, "Could not find resource #{edge.source.ref} when converting #{message} resources"
       end
 
       unless target = map[edge.target.ref]
         raise Puppet::DevError, "Could not find resource #{edge.target.ref} when converting #{message} resources"
       end
 
       result.add_edge(source, target, edge.label)
     end
 
     map.clear
 
     result.add_class(*self.classes)
     result.tag(*self.tags)
 
     result
   end
 
   def virtual_not_exported?(resource)
     resource.respond_to?(:virtual?) and resource.virtual? and (resource.respond_to?(:exported?) and not resource.exported?)
   end
 end
diff --git a/lib/puppet/transaction.rb b/lib/puppet/transaction.rb
index eba601cfe..aa0eec3ee 100644
--- a/lib/puppet/transaction.rb
+++ b/lib/puppet/transaction.rb
@@ -1,334 +1,337 @@
 # the class that actually walks our resource/property tree, collects the changes,
 # and performs them
 
 require 'puppet'
 require 'puppet/util/tagging'
 require 'puppet/application'
 
 class Puppet::Transaction
   require 'puppet/transaction/event'
   require 'puppet/transaction/event_manager'
   require 'puppet/transaction/resource_harness'
   require 'puppet/resource/status'
 
   attr_accessor :component, :catalog, :ignoreschedules
-  attr_accessor :sorted_resources, :configurator
+  attr_accessor :configurator
 
   # The report, once generated.
   attr_accessor :report
 
   # Routes and stores any events and subscriptions.
   attr_reader :event_manager
 
   # Handles most of the actual interacting with resources
   attr_reader :resource_harness
 
   include Puppet::Util
   include Puppet::Util::Tagging
 
   # Wraps application run state check to flag need to interrupt processing
   def stop_processing?
     Puppet::Application.stop_requested?
   end
 
   # Add some additional times for reporting
   def add_times(hash)
     hash.each do |name, num|
       report.add_times(name, num)
     end
   end
 
   # Are there any failed resources in this transaction?
   def any_failed?
     report.resource_statuses.values.detect { |status| status.failed? }
   end
 
   # Apply all changes for a resource
   def apply(resource, ancestor = nil)
     status = resource_harness.evaluate(resource)
     add_resource_status(status)
     event_manager.queue_events(ancestor || resource, status.events)
   rescue => detail
     resource.err "Could not evaluate: #{detail}"
   end
 
   # Find all of the changed resources.
   def changed?
     report.resource_statuses.values.find_all { |status| status.changed }.collect { |status| catalog.resource(status.resource) }
   end
 
+  # Find all of the applied resources (including failed attempts).
+  def applied_resources
+    report.resource_statuses.values.collect { |status| catalog.resource(status.resource) }
+  end
+
   # Copy an important relationships from the parent to the newly-generated
   # child resource.
-  def make_parent_child_relationship(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_vertex(gen_child)
-
-      unless relationship_graph.edge?(edge[1], edge[0])
-        relationship_graph.add_edge(*edge)
-      else
-        resource.debug "Skipping automatic relationship to #{gen_child}"
-      end
+  def make_parent_child_relationship(parent, child)
+    relationship_graph.add_vertex(child)
+    edge = parent.depthfirst? ? [child, parent] : [parent, child]
+    if relationship_graph.edge?(*edge.reverse)
+      parent.debug "Skipping automatic relationship to #{child}"
+    else
+      relationship_graph.add_edge(*edge)
     end
   end
 
-  # See if the resource generates new resources at evaluation time.
-  def eval_generate(resource)
-    generate_additional_resources(resource, :eval_generate)
-  end
-
   # Evaluate a single resource.
   def eval_resource(resource, ancestor = nil)
     if skip?(resource)
       resource_status(resource).skipped = true
     else
       eval_children_and_apply_resource(resource, ancestor)
     end
 
     # Check to see if there are any events queued for this resource
     event_manager.process_events(resource)
   end
 
   def eval_children_and_apply_resource(resource, ancestor = nil)
     resource_status(resource).scheduled = true
-
-    # We need to generate first regardless, because the recursive
-    # actions sometimes change how the top resource is applied.
-    children = eval_generate(resource)
-
-    if ! children.empty? and resource.depthfirst?
-      children.each do |child|
-        # The child will never be skipped when the parent isn't
-        eval_resource(child, ancestor || resource)
-      end
-    end
-
-    # Perform the actual changes
     apply(resource, ancestor)
-
-    if ! children.empty? and ! resource.depthfirst?
-      children.each do |child|
-        eval_resource(child, ancestor || resource)
-      end
-    end
   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
     # Start logging.
     Puppet::Util::Log.newdestination(@report)
 
     prepare
 
     Puppet.info "Applying configuration version '#{catalog.version}'" if catalog.version
 
     begin
-      @sorted_resources.each do |resource|
+      visit_resources do |resource|
         next if stop_processing?
         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
 
         resource.info "Evaluated in %0.2f seconds" % seconds if Puppet[:evaltrace] and @catalog.host_config?
         ret
       end
     ensure
       # And then close the transaction log.
       Puppet::Util::Log.close(@report)
     end
 
     Puppet.debug "Finishing transaction #{object_id}"
   end
 
   def events
     event_manager.events
   end
 
   def failed?(resource)
     s = resource_status(resource) and s.failed?
   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.
     found_failed = false
     relationship_graph.dependencies(resource).each do |dep|
       next unless failed?(dep)
       resource.notice "Dependency #{dep} has failures: #{resource_status(dep).failed}"
       found_failed = true
     end
 
     found_failed
   end
 
+  def eval_generate(resource)
+    return [] unless resource.respond_to?(:eval_generate)
+    begin
+      made = resource.eval_generate
+    rescue => detail
+      puts detail.backtrace if Puppet[:trace]
+      resource.err "Failed to generate additional resources using 'eval_generate: #{detail}"
+    end
+    parents = [resource]
+    [made].flatten.compact.uniq.each do |res|
+      begin
+        res.tag(*resource.tags)
+        @catalog.add_resource(res)
+        res.finish
+        make_parent_child_relationship(parents.reverse.find { |r| r.name == res.name[0,r.name.length]}, res)
+        parents << res
+      rescue Puppet::Resource::Catalog::DuplicateResourceError
+        res.info "Duplicate generated resource; skipping"
+      end
+    end
+  end
+
   # A general method for recursively generating new resources from a
   # resource.
-  def generate_additional_resources(resource, method)
+  def generate_additional_resources(resource, method, presume_prefix_dependencies=false)
     return [] unless resource.respond_to?(method)
     begin
       made = resource.send(method)
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       resource.err "Failed to generate additional resources using '#{method}': #{detail}"
     end
     return [] unless made
     made = [made] unless made.is_a?(Array)
     made.uniq.find_all do |res|
       begin
         res.tag(*resource.tags)
-        @catalog.add_resource(res) do |r|
-          r.finish
-          make_parent_child_relationship(resource, [r])
-
-          # Call 'generate' recursively
-          generate_additional_resources(r, method)
-        end
+        @catalog.add_resource(res)
+        res.finish
+        make_parent_child_relationship(resource, res)
+        generate_additional_resources(res, method, presume_prefix_dependencies)
         true
       rescue Puppet::Resource::Catalog::DuplicateResourceError
         res.info "Duplicate generated resource; skipping"
         false
       end
     end
   end
 
   # Collect any dynamically generated resources.  This method is called
   # before the transaction starts.
   def generate
     list = @catalog.vertices
     newlist = []
     while ! list.empty?
       list.each do |resource|
         newlist += generate_additional_resources(resource, :generate)
       end
       list = newlist
       newlist = []
     end
   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(catalog)
     @catalog = catalog
 
     @report = Puppet::Transaction::Report.new("apply")
 
     @event_manager = Puppet::Transaction::EventManager.new(self)
 
     @resource_harness = Puppet::Transaction::ResourceHarness.new(self)
   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.name] = 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 #{provider.name} resources for #{provider.resource_type.name}"
       begin
         provider.prefetch(resources)
       rescue => detail
         puts detail.backtrace if Puppet[:trace]
         Puppet.err "Could not prefetch #{provider.resource_type.name} provider '#{provider.name}': #{detail}"
       end
     end
   end
 
   # Prepare to evaluate the resources in a transaction.
   def prepare
     # Now add any dynamically generated resources
     generate
 
     # Then prefetch.  It's important that we generate and then prefetch,
     # so that any generated resources also get prefetched.
     prefetch
+  end
 
-    # This will throw an error if there are cycles in the graph.
-    @sorted_resources = relationship_graph.topsort
+  def visit_resources(&block)
+    eval_generated = {}
+    while r = relationship_graph.topsort.find { |r| !applied_resources.include?(r) }
+      #p relationship_graph.topsort.collect { |r0| r0.title[/(-0.*)/,1] }
+      if !eval_generated[r]
+        #p [:generate,r.title]
+        eval_generate(r)
+        eval_generated[r] = true
+      else
+        #p [:apply,r.title]
+        yield r
+      end
+    end
   end
 
   def relationship_graph
     catalog.relationship_graph
   end
 
   def add_resource_status(status)
     report.add_resource_status status
   end
 
   def resource_status(resource)
     report.resource_statuses[resource.to_s] || add_resource_status(Puppet::Resource::Status.new(resource))
   end
 
   # Is the resource currently scheduled?
   def scheduled?(resource)
     self.ignoreschedules or resource_harness.scheduled?(resource_status(resource), resource)
   end
 
   # Should this resource be skipped?
   def skip?(resource)
     if missing_tags?(resource)
       resource.debug "Not tagged with #{tags.join(", ")}"
     elsif ! scheduled?(resource)
       resource.debug "Not scheduled"
     elsif failed_dependencies?(resource)
       resource.warning "Skipping because of failed dependencies"
     elsif resource.virtual?
       resource.debug "Skipping because virtual"
     else
       return false
     end
     true
   end
 
   # The tags we should be checking.
   def tags
     self.tags = Puppet[:tags] unless defined?(@tags)
 
     super
   end
 
   def handle_qualified_tags( qualified )
     # The default behavior of Puppet::Util::Tagging is
     # to split qualified tags into parts. That would cause
     # qualified tags to match too broadly here.
     return
   end
 
   # Is this resource tagged appropriately?
   def missing_tags?(resource)
     return false if ignore_tags?
     return false if tags.empty?
 
     not resource.tagged?(*tags)
   end
 end
 
 require 'puppet/transaction/report'
 
diff --git a/lib/puppet/type/file.rb b/lib/puppet/type/file.rb
index 2c5a95bbc..cbc1f77da 100644
--- a/lib/puppet/type/file.rb
+++ b/lib/puppet/type/file.rb
@@ -1,791 +1,783 @@
 require 'digest/md5'
 require 'cgi'
 require 'etc'
 require 'uri'
 require 'fileutils'
 require 'puppet/network/handler'
 require 'puppet/util/diff'
 require 'puppet/util/checksums'
 require 'puppet/network/client'
 require 'puppet/util/backups'
 
 Puppet::Type.newtype(:file) do
   include Puppet::Util::MethodHelper
   include Puppet::Util::Checksums
   include Puppet::Util::Backups
   @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
     Puppet Labs and we can hopefully work with you to develop a
     native resource to support what you are doing.
     
     **Autorequires:** If Puppet is managing the user or group that owns a file, the file resource will autorequire them. If Puppet is managing any parent directories of a file, the file resource will autorequire them."
 
   def self.title_patterns
     [ [ /^(.*?)\/*\Z/m, [ [ :path, lambda{|x| x} ] ] ] ]
   end
 
   newparam(:path) do
     desc "The path to the file to manage.  Must be fully qualified."
     isnamevar
 
     validate do |value|
       # accept various path syntaxes: lone slash, posix, win32, unc
       unless (Puppet.features.posix? and value =~ /^\//) or (Puppet.features.microsoft_windows? and (value =~ /^.:\// or value =~ /^\/\/[^\/]+\/[^\/]+/))
         fail Puppet::Error, "File paths must be fully qualified, not '#{value}'"
       end
     end
 
     # convert the current path in an index into the collection and the last
     # path name. The aim is to use less storage for all common paths in a hierarchy
     munge do |value|
       path, name = ::File.split(value.gsub(/\/+/,'/'))
       { :index => Puppet::FileCollection.collection.index(path), :name => name }
     end
 
     # and the reverse
     unmunge do |value|
       basedir = Puppet::FileCollection.collection.path(value[:index])
       # a lone slash as :name indicates a root dir on windows
       if value[:name] == '/'
         basedir
       else
         ::File.join( basedir, value[:name] )
       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 `puppet master` 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.
       value = value.shift if value.is_a?(Array)
 
       case value
       when false, "false", :false
         false
       when true, "true", ".puppet-bak", :true
         ".puppet-bak"
       when String
         value
       else
         self.fail "Invalid backup type #{value.inspect}"
       end
     end
   end
 
   newparam(:recurse) do
     desc "Whether and how deeply to do recursive
       management."
 
     newvalues(:true, :false, :inf, :remote, /^[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 :remote; :remote
       when Integer, Fixnum, Bignum
         self.warning "Setting recursion depth with the recurse parameter is now deprecated, please use recurselimit"
 
         # recurse == 0 means no recursion
         return false if value == 0
 
         resource[:recurselimit] = value
         true
       when /^\d+$/
         self.warning "Setting recursion depth with the recurse parameter is now deprecated, please use recurselimit"
         value = Integer(value)
 
         # recurse == 0 means no recursion
         return false if value == 0
 
         resource[:recurselimit] = value
         true
       else
         self.fail "Invalid recurse value #{value.inspect}"
       end
     end
   end
 
   newparam(:recurselimit) do
     desc "How deeply to do recursive management."
 
     newvalues(/^[0-9]+$/)
 
     munge do |value|
       newval = super(value)
       case newval
       when Integer, Fixnum, Bignum; value
       when /^\d+$/; Integer(value)
       else
         self.fail "Invalid recurselimit value #{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., `*/*`."
 
     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)
 
     defaultto :manage
   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
 
   # Autorequire any parent directories.
   autorequire(:file) do
     basedir = ::File.dirname(self[:path])
     if basedir != self[:path]
       basedir
     else
       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]
   SOURCE_ONLY_CHECKSUMS = [:none, :ctime, :mtime]
 
   validate do
     creator_count = 0
     CREATORS.each do |param|
       creator_count += 1 if self.should(param)
     end
     creator_count += 1 if @parameters.include?(:source)
     self.fail "You cannot specify more than one of #{CREATORS.collect { |p| p.to_s}.join(", ")}" if creator_count > 1
 
     self.fail "You cannot specify a remote recursion without a source" if !self[:source] and self[:recurse] == :remote
 
     self.fail "You cannot specify source when using checksum 'none'" if self[:checksum] == :none && !self[:source].nil?
 
     SOURCE_ONLY_CHECKSUMS.each do |checksum_type|
       self.fail "You cannot specify content when using checksum '#{checksum_type}'" if self[:checksum] == checksum_type && !self[:content].nil?
     end
 
     self.warning "Possible error: recurselimit is set but not recurse, no recursion will happen" if !self[:recurse] and self[:recurselimit]
   end
 
   def self.[](path)
     return nil unless path
     super(path.gsub(/\/+/, '/').sub(/\/$/, ''))
   end
 
   def self.instances(base = '/')
     return self.new(:name => base, :recurse => true, :recurselimit => 1, :audit => :all).recurse_local.values
   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.
       asuser = self.should(:owner) if writeable
     end
 
     asuser
   end
 
   def bucket
     return @bucket if @bucket
 
     backup = self[:backup]
     return nil unless backup
     return nil if backup =~ /^\./
 
     unless catalog or backup == "puppet"
       fail "Can not find filebucket for backups without a catalog"
     end
 
     unless catalog and filebucket = catalog.resource(:filebucket, backup) or backup == "puppet"
       fail "Could not find filebucket #{backup} specified in backup"
     end
 
     return default_bucket unless filebucket
 
     @bucket = filebucket.bucket
 
     @bucket
   end
 
   def default_bucket
     Puppet::Type.type(:filebucket).mkdefaultbucket.bucket
   end
 
   # Does the file currently exist?  Just checks for whether
   # we have a stat
   def exist?
     stat ? true : false
   end
 
   # We have to do some extra finishing, to retrieve our bucket if
   # there is one.
   def finish
     # Look up our bucket, if there is one
     bucket
     super
   end
 
   # Create any children via recursion or whatever.
   def eval_generate
     return [] unless self.recurse?
 
     recurse
     #recurse.reject do |resource|
     #    catalog.resource(:file, resource[:path])
     #end.each do |child|
     #    catalog.add_resource child
     #    catalog.relationship_graph.add_edge self, child
     #end
   end
 
   def flush
     # We want to make sure we retrieve metadata anew on each transaction.
     @parameters.each do |name, param|
       param.flush if param.respond_to?(:flush)
     end
     @stat = nil
   end
 
   def initialize(hash)
     # Used for caching clients
     @clients = {}
 
     super
 
     # If they've specified a source, we get our 'should' values
     # from it.
     unless self[:ensure]
       if self[:target]
         self[:ensure] = :symlink
       elsif self[:content]
         self[:ensure] = :file
       end
     end
 
     @stat = nil
   end
 
   # Configure discovered resources to be purged.
   def mark_children_for_purging(children)
     children.each do |name, child|
       next if child[:source]
       child[:ensure] = :absent
     end
   end
 
   # Create a new file or directory object as a child to the current
   # object.
   def newchild(path)
     full_path = ::File.join(self[:path], path)
 
     # Add some new values to our original arguments -- these are the ones
     # set at initialization.  We specifically want to exclude any param
     # values set by the :source property or any default values.
     # LAK:NOTE This is kind of silly, because the whole point here is that
     # the values set at initialization should live as long as the resource
     # but values set by default or by :source should only live for the transaction
     # or so.  Unfortunately, we don't have a straightforward way to manage
     # the different lifetimes of this data, so we kludge it like this.
     # The right-side hash wins in the merge.
     options = @original_parameters.merge(:path => full_path).reject { |param, value| value.nil? }
 
     # These should never be passed to our children.
     [:parent, :ensure, :recurse, :recurselimit, :target, :alias, :source].each do |param|
       options.delete(param) if options.include?(param)
     end
 
     self.class.new(options)
   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
 
   # Recursively generate a list of file resources, which will
   # be used to copy remote files, manage local files, and/or make links
   # to map to another directory.
   def recurse
-    children = {}
-    children = recurse_local if self[:recurse] != :remote
+    children = (self[:recurse] == :remote) ? {} : recurse_local
 
     if self[:target]
       recurse_link(children)
     elsif self[:source]
       recurse_remote(children)
     end
 
     # If we're purging resources, then delete any resource that isn't on the
     # remote system.
     mark_children_for_purging(children) if self.purge?
 
     result = children.values.sort { |a, b| a[:path] <=> b[:path] }
     remove_less_specific_files(result)
   end
 
   # This is to fix bug #2296, where two files recurse over the same
   # set of files.  It's a rare case, and when it does happen you're
   # not likely to have many actual conflicts, which is good, because
   # this is a pretty inefficient implementation.
   def remove_less_specific_files(files)
     mypath = self[:path].split(::File::Separator)
     other_paths = catalog.vertices.
       select  { |r| r.is_a?(self.class) and r[:path] != self[:path] }.
       collect { |r| r[:path].split(::File::Separator) }.
       select  { |p| p[0,mypath.length]  == mypath }
 
     return files if other_paths.empty?
 
     files.reject { |file|
       path = file[:path].split(::File::Separator)
       other_paths.any? { |p| path[0,p.length] == p }
       }
   end
 
   # A simple method for determining whether we should be recursing.
   def recurse?
-    return false unless @parameters.include?(:recurse)
-
-    val = @parameters[:recurse].value
-
-    !!(val and (val == true or val == :remote))
+    self[:recurse] == true or self[:recurse] == :remote
   end
 
   # Recurse the target of the link.
   def recurse_link(children)
     perform_recursion(self[:target]).each do |meta|
       if meta.relative_path == "."
         self[:ensure] = :directory
         next
       end
 
       children[meta.relative_path] ||= newchild(meta.relative_path)
       if meta.ftype == "directory"
         children[meta.relative_path][:ensure] = :directory
       else
         children[meta.relative_path][:ensure] = :link
         children[meta.relative_path][:target] = meta.full_path
       end
     end
     children
   end
 
   # Recurse the file itself, returning a Metadata instance for every found file.
   def recurse_local
     result = perform_recursion(self[:path])
     return {} unless result
     result.inject({}) do |hash, meta|
       next hash if meta.relative_path == "."
 
       hash[meta.relative_path] = newchild(meta.relative_path)
       hash
     end
   end
 
   # Recurse against our remote file.
   def recurse_remote(children)
     sourceselect = self[:sourceselect]
 
     total = self[:source].collect do |source|
       next unless result = perform_recursion(source)
       return if top = result.find { |r| r.relative_path == "." } and top.ftype != "directory"
       result.each { |data| data.source = "#{source}/#{data.relative_path}" }
       break result if result and ! result.empty? and sourceselect == :first
       result
     end.flatten
 
     # This only happens if we have sourceselect == :all
     unless sourceselect == :first
       found = []
       total.reject! do |data|
         result = found.include?(data.relative_path)
         found << data.relative_path unless found.include?(data.relative_path)
         result
       end
     end
 
     total.each do |meta|
       if meta.relative_path == "."
         parameter(:source).metadata = meta
         next
       end
       children[meta.relative_path] ||= newchild(meta.relative_path)
       children[meta.relative_path][:source] = meta.source
       children[meta.relative_path][:checksum] = :md5 if meta.ftype == "file"
 
       children[meta.relative_path].parameter(:source).metadata = meta
     end
 
     children
   end
 
   def perform_recursion(path)
-
     Puppet::FileServing::Metadata.indirection.search(
-
       path,
       :links => self[:links],
       :recurse => (self[:recurse] == :remote ? true : self[:recurse]),
-
       :recurselimit => self[:recurselimit],
       :ignore => self[:ignore],
       :checksum_type => (self[:source] || self[:content]) ? self[:checksum] : :none
     )
   end
 
   # Remove any existing data.  This is only used when dealing with
   # links or directories.
   def remove_existing(should)
     return unless s = stat
 
     self.fail "Could not back up; will not replace" unless perform_backup
 
     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 #{should}"
         FileUtils.rmtree(self[:path])
       else
         notice "Not removing directory; use 'force' to override"
       end
     when "link", "file"
       debug "Removing existing #{s.ftype} for replacement with #{should}"
       ::File.unlink(self[:path])
     else
       self.fail "Could not back up files of type #{s.ftype}"
     end
     expire
   end
 
   def retrieve
     if source = parameter(:source)
       source.copy_source_values
     end
     super
   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
 
   # Should this thing be a normal file?  This is a relatively complex
   # way of determining whether we're trying to create a normal file,
   # and it's here so that the logic isn't visible in the content property.
   def should_be_file?
     return true if self[:ensure] == :file
 
     # I.e., it's set to something like "directory"
     return false if e = self[:ensure] and e != :present
 
     # The user doesn't really care, apparently
     if self[:ensure] == :present
       return true unless s = stat
       return(s.ftype == "file" ? true : false)
     end
 
     # If we've gotten here, then :ensure isn't set
     return true if self[:content]
     return true if stat and stat.ftype == "file"
     false
   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).
   cached_attr(:stat) do
     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]
 
     begin
       ::File.send(method, self[:path])
     rescue Errno::ENOENT => error
       return nil
     rescue Errno::EACCES => error
       warning "Could not stat; permission denied"
       return nil
     end
   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
     obj.delete(:target) if obj[:target] == :notlink
     obj
   end
 
   # Write out the file.  Requires the property name for logging.
   # Write will be done by the content property, along with checksum computation
   def write(property)
     remove_existing(:file)
 
     use_temporary_file = write_temporary_file?
     if use_temporary_file
       path = "#{self[:path]}.puppettmp_#{rand(10000)}"
       path = "#{self[:path]}.puppettmp_#{rand(10000)}" while ::File.exists?(path) or ::File.symlink?(path)
     else
       path = self[:path]
     end
 
     mode = self.should(:mode) # might be nil
     umask = mode ? 000 : 022
     mode_int = mode ? mode.to_i(8) : nil
 
     content_checksum = Puppet::Util.withumask(umask) { ::File.open(path, 'w', mode_int ) { |f| write_content(f) } }
 
     # And put our new file in place
     if use_temporary_file # This is only not true when our file is empty.
       begin
         fail_if_checksum_is_wrong(path, content_checksum) if validate_checksum?
         ::File.rename(path, self[:path])
       rescue => detail
         fail "Could not rename temporary file #{path} to #{self[:path]}: #{detail}"
       ensure
         # Make sure the created file gets removed
         ::File.unlink(path) if FileTest.exists?(path)
       end
     end
 
     # make sure all of the modes are actually correct
     property_fix
 
   end
 
   private
 
   # Should we validate the checksum of the file we're writing?
   def validate_checksum?
     self[:checksum] !~ /time/
   end
 
   # Make sure the file we wrote out is what we think it is.
   def fail_if_checksum_is_wrong(path, content_checksum)
     newsum = parameter(:checksum).sum_file(path)
     return if [:absent, nil, content_checksum].include?(newsum)
 
     self.fail "File written to disk did not match checksum; discarding changes (#{content_checksum} vs #{newsum})"
   end
 
   # write the current content. Note that if there is no content property
   # simply opening the file with 'w' as done in write is enough to truncate
   # or write an empty length file.
   def write_content(file)
     (content = property(:content)) && content.write(file)
   end
 
   private
 
   def write_temporary_file?
     # unfortunately we don't know the source file size before fetching it
     # so let's assume the file won't be empty
     (c = property(:content) and c.length) || (s = @parameters[:source] and 1)
   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, :seluser, :selrole, :seltype, :selrange].include?(thing.name)
 
       # Make sure we get a new stat objct
       expire
       currentvalue = thing.retrieve
       thing.sync unless thing.safe_insync?(currentvalue)
     end
   end
 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/file/checksum'
 require 'puppet/type/file/content'     # can create the file
 require 'puppet/type/file/source'      # can create the file
 require 'puppet/type/file/target'      # creates a different type of file
 require 'puppet/type/file/ensure'      # can create the file
 require 'puppet/type/file/owner'
 require 'puppet/type/file/group'
 require 'puppet/type/file/mode'
 require 'puppet/type/file/type'
 require 'puppet/type/file/selcontext'  # SELinux file context
 require 'puppet/type/file/ctime'
 require 'puppet/type/file/mtime'
diff --git a/lib/puppet/type/tidy.rb b/lib/puppet/type/tidy.rb
index d2e9ebe22..1a308e17d 100755
--- a/lib/puppet/type/tidy.rb
+++ b/lib/puppet/type/tidy.rb
@@ -1,335 +1,331 @@
 Puppet::Type.newtype(:tidy) do
   require 'puppet/file_serving/fileset'
   require 'puppet/file_bucket/dipper'
 
   @doc = "Remove unwanted files based on specific criteria.  Multiple
     criteria are OR'd together, so a file that is too large but is not
     old enough will still get tidied.
 
     If you don't specify either `age` or `size`, then all files will
     be removed.
 
     This resource type works by generating a file resource for every file
     that should be deleted and then letting that resource perform the
     actual deletion.
     "
 
   newparam(:path) do
     desc "The path to the file or directory to manage.  Must be fully
       qualified."
     isnamevar
   end
 
   newparam(:recurse) do
     desc "If target is a directory, recursively descend
       into the directory looking for files to tidy."
 
     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 #{value.inspect}"
       end
     end
   end
 
   newparam(:matches) do
     desc "One or more (shell type) file glob patterns, which restrict
       the list of files to be tidied to those whose basenames match
       at least one of the patterns specified. Multiple patterns can
       be specified using an array.
 
       Example:
 
           tidy { \"/tmp\":
             age => \"1w\",
             recurse => 1,
             matches => [ \"[0-9]pub*.tmp\", \"*.temp\", \"tmpfile?\" ]
           }
 
       This removes files from `/tmp` if they are one week old or older,
       are not in a subdirectory and match one of the shell globs given.
 
       Note that the patterns are matched against the basename of each
       file -- that is, your glob patterns should not have any '/'
       characters in them, since you are only specifying against the last
       bit of the file.
 
       Finally, note that you must now specify a non-zero/non-false value
       for recurse if matches is used, as matches only apply to files found
       by recursion (there's no reason to use static patterns match against
       a statically determined path).  Requiering explicit recursion clears
       up a common source of confusion."
 
     # Make sure we convert to an array.
     munge do |value|
       fail "Tidy can't use matches with recurse 0, false, or undef" if "#{@resource[:recurse]}" =~ /^(0|false|)$/
       [value].flatten
     end
 
     # Does a given path match our glob patterns, if any?  Return true
     # if no patterns have been provided.
     def tidy?(path, stat)
       basename = File.basename(path)
       flags = File::FNM_DOTMATCH | File::FNM_PATHNAME
       return(value.find {|pattern| File.fnmatch(pattern, basename, flags) } ? true : false)
     end
   end
 
   newparam(:backup) do
     desc "Whether tidied files should be backed up.  Any values are passed
       directly to the file resources used for actual file deletion, so use
       its backup documentation to determine valid values."
   end
 
   newparam(:age) do
     desc "Tidy files whose age is equal to or greater than
       the specified time.  You can choose seconds, minutes,
       hours, days, or weeks by specifying the first letter of any
       of those words (e.g., '1w').
 
       Specifying 0 will remove all files."
 
     @@ageconvertors = {
       :s => 1,
       :m => 60
     }
 
     @@ageconvertors[:h] = @@ageconvertors[:m] * 60
     @@ageconvertors[:d] = @@ageconvertors[:h] * 24
     @@ageconvertors[:w] = @@ageconvertors[:d] * 7
 
     def convert(unit, multi)
       if num = @@ageconvertors[unit]
         return num * multi
       else
         self.fail "Invalid age unit '#{unit}'"
       end
     end
 
     def tidy?(path, stat)
       # If the file's older than we allow, we should get rid of it.
       (Time.now.to_i - stat.send(resource[:type]).to_i) > value
     end
 
     munge do |age|
       unit = multi = nil
       case age
       when /^([0-9]+)(\w)\w*$/
         multi = Integer($1)
         unit = $2.downcase.intern
       when /^([0-9]+)$/
         multi = Integer($1)
         unit = :d
       else
         self.fail "Invalid tidy age #{age}"
       end
 
       convert(unit, multi)
     end
   end
 
   newparam(:size) do
     desc "Tidy files whose size is equal to or greater than
       the specified size.  Unqualified values are in kilobytes, but
       *b*, *k*, *m*, *g*, and *t* can be appended to specify *bytes*,
       *kilobytes*, *megabytes*, *gigabytes*, and *terabytes*, respectively.
       Only the first character is significant, so the full word can also 
       be used."
 
     @@sizeconvertors = {
       :b => 0,
       :k => 1,
       :m => 2,
       :g => 3,
       :t => 4
     }
 
     def convert(unit, multi)
       if num = @@sizeconvertors[unit]
         result = multi
         num.times do result *= 1024 end
         return result
       else
         self.fail "Invalid size unit '#{unit}'"
       end
     end
 
     def tidy?(path, stat)
       stat.size >= value
     end
 
     munge do |size|
       case size
       when /^([0-9]+)(\w)\w*$/
         multi = Integer($1)
         unit = $2.downcase.intern
       when /^([0-9]+)$/
         multi = Integer($1)
         unit = :k
       else
         self.fail "Invalid tidy size #{age}"
       end
 
       convert(unit, multi)
     end
   end
 
   newparam(:type) do
     desc "Set the mechanism for determining age."
 
     newvalues(:atime, :mtime, :ctime)
 
     defaultto :atime
   end
 
   newparam(:rmdirs, :boolean => true) do
     desc "Tidy directories in addition to files; that is, remove
       directories whose age is older than the specified criteria.
       This will only remove empty directories, so all contained
       files must also be tidied before a directory gets removed."
 
     newvalues :true, :false
   end
 
   # Erase PFile's validate method
   validate do
   end
 
   def self.instances
     []
   end
 
   def depthfirst?
     true
   end
 
   def initialize(hash)
     super
 
     # only allow backing up into filebuckets
     self[:backup] = false unless self[:backup].is_a? Puppet::FileBucket::Dipper
   end
 
   # Make a file resource to remove a given file.
   def mkfile(path)
     # Force deletion, so directories actually get deleted.
     Puppet::Type.type(:file).new :path => path, :backup => self[:backup], :ensure => :absent, :force => true
   end
 
   def retrieve
     # Our ensure property knows how to retrieve everything for us.
     if obj = @parameters[:ensure]
       return obj.retrieve
     else
       return {}
     end
   end
 
   # Hack things a bit so we only ever check the ensure property.
   def properties
     []
   end
 
-  def eval_generate
-    []
-  end
-
   def generate
     return [] unless stat(self[:path])
 
     case self[:recurse]
     when Integer, Fixnum, Bignum, /^\d+$/
       parameter = { :recurse => true, :recurselimit => self[:recurse] }
     when true, :true, :inf
       parameter = { :recurse => true }
     end
 
     if parameter
       files = Puppet::FileServing::Fileset.new(self[:path], parameter).files.collect do |f|
         f == "." ? self[:path] : ::File.join(self[:path], f)
       end
     else
       files = [self[:path]]
     end
     result = files.find_all { |path| tidy?(path) }.collect { |path| mkfile(path) }.each { |file| notice "Tidying #{file.ref}" }.sort { |a,b| b[:path] <=> a[:path] }
 
     # No need to worry about relationships if we don't have rmdirs; there won't be
     # any directories.
     return result unless rmdirs?
 
     # Now make sure that all directories require the files they contain, if all are available,
     # so that a directory is emptied before we try to remove it.
     files_by_name = result.inject({}) { |hash, file| hash[file[:path]] = file; hash }
 
     files_by_name.keys.sort { |a,b| b <=> b }.each do |path|
       dir = ::File.dirname(path)
       next unless resource = files_by_name[dir]
       if resource[:require]
         resource[:require] << Puppet::Resource.new(:file, path)
       else
         resource[:require] = [Puppet::Resource.new(:file, path)]
       end
     end
 
     result
   end
 
   # Does a given path match our glob patterns, if any?  Return true
   # if no patterns have been provided.
   def matches?(path)
     return true unless self[:matches]
 
     basename = File.basename(path)
     flags = File::FNM_DOTMATCH | File::FNM_PATHNAME
     if self[:matches].find {|pattern| File.fnmatch(pattern, basename, flags) }
       return true
     else
       debug "No specified patterns match #{path}, not tidying"
       return false
     end
   end
 
   # Should we remove the specified file?
   def tidy?(path)
     return false unless stat = self.stat(path)
 
     return false if stat.ftype == "directory" and ! rmdirs?
 
     # The 'matches' parameter isn't OR'ed with the other tests --
     # it's just used to reduce the list of files we can match.
     return false if param = parameter(:matches) and ! param.tidy?(path, stat)
 
     tested = false
     [:age, :size].each do |name|
       next unless param = parameter(name)
       tested = true
       return true if param.tidy?(path, stat)
     end
 
     # If they don't specify either, then the file should always be removed.
     return true unless tested
     false
   end
 
   def stat(path)
     begin
       ::File.lstat(path)
     rescue Errno::ENOENT => error
       info "File does not exist"
       return nil
     rescue Errno::EACCES => error
       warning "Could not stat; permission denied"
       return nil
     end
   end
 end
diff --git a/spec/integration/indirector/catalog/compiler_spec.rb b/spec/integration/indirector/catalog/compiler_spec.rb
index 1146c20b0..dafa1af7c 100755
--- a/spec/integration/indirector/catalog/compiler_spec.rb
+++ b/spec/integration/indirector/catalog/compiler_spec.rb
@@ -1,68 +1,65 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 require 'puppet/resource/catalog'
 
 Puppet::Resource::Catalog.indirection.terminus(:compiler)
 
 describe Puppet::Resource::Catalog::Compiler do
   before do
     Facter.stubs(:value).returns "something"
     @catalog = Puppet::Resource::Catalog.new
-
-    @one = Puppet::Resource.new(:file, "/one")
-
-    @two = Puppet::Resource.new(:file, "/two")
-    @catalog.add_resource(@one, @two)
+    @catalog.add_resource(@one = Puppet::Resource.new(:file, "/one"))
+    @catalog.add_resource(@two = Puppet::Resource.new(:file, "/two"))
   end
 
   after { Puppet.settings.clear }
 
   it "should remove virtual resources when filtering" do
     @one.virtual = true
     Puppet::Resource::Catalog.indirection.terminus.filter(@catalog).resource_refs.should == [ @two.ref ]
   end
 
   it "should not remove exported resources when filtering" do
     @one.exported = true
     Puppet::Resource::Catalog.indirection.terminus.filter(@catalog).resource_refs.sort.should == [ @one.ref, @two.ref ]
   end
 
   it "should remove virtual exported resources when filtering" do
     @one.exported = true
     @one.virtual = true
     Puppet::Resource::Catalog.indirection.terminus.filter(@catalog).resource_refs.should == [ @two.ref ]
   end
 
   it "should filter out virtual resources when finding a catalog" do
     @one.virtual = true
     request = stub 'request', :name => "mynode"
     Puppet::Resource::Catalog.indirection.terminus.stubs(:extract_facts_from_request)
     Puppet::Resource::Catalog.indirection.terminus.stubs(:node_from_request)
     Puppet::Resource::Catalog.indirection.terminus.stubs(:compile).returns(@catalog)
 
     Puppet::Resource::Catalog.indirection.find(request).resource_refs.should == [ @two.ref ]
   end
 
   it "should not filter out exported resources when finding a catalog" do
     @one.exported = true
     request = stub 'request', :name => "mynode"
     Puppet::Resource::Catalog.indirection.terminus.stubs(:extract_facts_from_request)
     Puppet::Resource::Catalog.indirection.terminus.stubs(:node_from_request)
     Puppet::Resource::Catalog.indirection.terminus.stubs(:compile).returns(@catalog)
 
     Puppet::Resource::Catalog.indirection.find(request).resource_refs.sort.should == [ @one.ref, @two.ref ]
   end
 
   it "should filter out virtual exported resources when finding a catalog" do
     @one.exported = true
     @one.virtual = true
     request = stub 'request', :name => "mynode"
     Puppet::Resource::Catalog.indirection.terminus.stubs(:extract_facts_from_request)
     Puppet::Resource::Catalog.indirection.terminus.stubs(:node_from_request)
     Puppet::Resource::Catalog.indirection.terminus.stubs(:compile).returns(@catalog)
 
     Puppet::Resource::Catalog.indirection.find(request).resource_refs.should == [ @two.ref ]
   end
 end
diff --git a/spec/integration/type/file_spec.rb b/spec/integration/type/file_spec.rb
index 46900a0f1..513b96e41 100755
--- a/spec/integration/type/file_spec.rb
+++ b/spec/integration/type/file_spec.rb
@@ -1,509 +1,512 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet_spec/files'
 
 describe Puppet::Type.type(:file) do
   include PuppetSpec::Files
 
   before do
     # stub this to not try to create state.yaml
     Puppet::Util::Storage.stubs(:store)
   end
 
   it "should not attempt to manage files that do not exist if no means of creating the file is specified" do
     file = Puppet::Type.type(:file).new :path => "/my/file", :mode => "755"
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource file
 
     file.parameter(:mode).expects(:retrieve).never
 
     transaction = Puppet::Transaction.new(catalog)
     transaction.resource_harness.evaluate(file).should_not be_failed
   end
 
   describe "when writing files" do
     it "should backup files to a filebucket when one is configured" do
       bucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
       file = Puppet::Type.type(:file).new :path => tmpfile("bucket_backs"), :backup => "mybucket", :content => "foo"
       catalog = Puppet::Resource::Catalog.new
-      catalog.add_resource file, bucket
+      catalog.add_resource file
+      catalog.add_resource bucket
 
       File.open(file[:path], "w") { |f| f.puts "bar" }
 
       md5 = Digest::MD5.hexdigest(File.read(file[:path]))
 
       catalog.apply
 
       bucket.bucket.getfile(md5).should == "bar\n"
     end
 
     it "should backup files in the local directory when a backup string is provided" do
       file = Puppet::Type.type(:file).new :path => tmpfile("bucket_backs"), :backup => ".bak", :content => "foo"
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
 
       File.open(file[:path], "w") { |f| f.puts "bar" }
 
       catalog.apply
 
       backup = file[:path] + ".bak"
       FileTest.should be_exist(backup)
       File.read(backup).should == "bar\n"
     end
 
     it "should fail if no backup can be performed" do
       dir = tmpfile("backups")
       Dir.mkdir(dir)
       path = File.join(dir, "testfile")
       file = Puppet::Type.type(:file).new :path => path, :backup => ".bak", :content => "foo"
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
 
       File.open(file[:path], "w") { |f| f.puts "bar" }
 
       # Create a directory where the backup should be so that writing to it fails
       Dir.mkdir(File.join(dir, "testfile.bak"))
 
       Puppet::Util::Log.stubs(:newmessage)
 
       catalog.apply
 
       File.read(file[:path]).should == "bar\n"
     end
 
     it "should not backup symlinks" do
       link = tmpfile("link")
       dest1 = tmpfile("dest1")
       dest2 = tmpfile("dest2")
       bucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
       file = Puppet::Type.type(:file).new :path => link, :target => dest2, :ensure => :link, :backup => "mybucket"
       catalog = Puppet::Resource::Catalog.new
-      catalog.add_resource file, bucket
+      catalog.add_resource file
+      catalog.add_resource bucket
 
       File.open(dest1, "w") { |f| f.puts "whatever" }
       File.symlink(dest1, link)
 
       md5 = Digest::MD5.hexdigest(File.read(file[:path]))
 
       catalog.apply
 
       File.readlink(link).should == dest2
       Find.find(bucket[:path]) { |f| File.file?(f) }.should be_nil
     end
 
     it "should backup directories to the local filesystem by copying the whole directory" do
       file = Puppet::Type.type(:file).new :path => tmpfile("bucket_backs"), :backup => ".bak", :content => "foo", :force => true
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
 
       Dir.mkdir(file[:path])
       otherfile = File.join(file[:path], "foo")
       File.open(otherfile, "w") { |f| f.print "yay" }
 
       catalog.apply
 
       backup = file[:path] + ".bak"
       FileTest.should be_directory(backup)
       File.read(File.join(backup, "foo")).should == "yay"
     end
 
     it "should backup directories to filebuckets by backing up each file separately" do
       bucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
       file = Puppet::Type.type(:file).new :path => tmpfile("bucket_backs"), :backup => "mybucket", :content => "foo", :force => true
       catalog = Puppet::Resource::Catalog.new
-      catalog.add_resource file, bucket
+      catalog.add_resource file
+      catalog.add_resource bucket
 
       Dir.mkdir(file[:path])
       foofile = File.join(file[:path], "foo")
       barfile = File.join(file[:path], "bar")
       File.open(foofile, "w") { |f| f.print "fooyay" }
       File.open(barfile, "w") { |f| f.print "baryay" }
 
 
       foomd5 = Digest::MD5.hexdigest(File.read(foofile))
       barmd5 = Digest::MD5.hexdigest(File.read(barfile))
 
       catalog.apply
 
       bucket.bucket.getfile(foomd5).should == "fooyay"
       bucket.bucket.getfile(barmd5).should == "baryay"
     end
 
     it "should propagate failures encountered when renaming the temporary file" do
       file = Puppet::Type.type(:file).new :path => tmpfile("fail_rename"), :content => "foo"
       file.stubs(:remove_existing) # because it tries to make a backup
 
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
 
       File.open(file[:path], "w") { |f| f.print "bar" }
 
       File.expects(:rename).raises ArgumentError
 
       lambda { file.write(:content) }.should raise_error(Puppet::Error)
       File.read(file[:path]).should == "bar"
     end
   end
 
   describe "when recursing" do
     def build_path(dir)
       Dir.mkdir(dir)
       File.chmod(0750, dir)
 
       @dirs = [dir]
       @files = []
 
       %w{one two}.each do |subdir|
         fdir = File.join(dir, subdir)
         Dir.mkdir(fdir)
         File.chmod(0750, fdir)
         @dirs << fdir
 
         %w{three}.each do |file|
           ffile = File.join(fdir, file)
           @files << ffile
           File.open(ffile, "w") { |f| f.puts "test #{file}" }
           File.chmod(0640, ffile)
         end
       end
     end
 
     it "should be able to recurse over a nonexistent file" do
       @path = tmpfile("file_integration_tests")
 
       @file = Puppet::Type::File.new(
         :name    => @path,
         :mode    => 0644,
         :recurse => true,
         :backup  => false
       )
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @file
 
       lambda { @file.eval_generate }.should_not raise_error
     end
 
     it "should be able to recursively set properties on existing files" do
       @path = tmpfile("file_integration_tests")
 
       build_path(@path)
 
       @file = Puppet::Type::File.new(
         :name    => @path,
         :mode    => 0644,
         :recurse => true,
         :backup  => false
       )
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @file
 
       @catalog.apply
 
       @dirs.each do |path|
         (File.stat(path).mode & 007777).should == 0755
       end
 
       @files.each do |path|
         (File.stat(path).mode & 007777).should == 0644
       end
     end
 
     it "should be able to recursively make links to other files" do
       source = tmpfile("file_link_integration_source")
 
       build_path(source)
 
       dest = tmpfile("file_link_integration_dest")
 
       @file = Puppet::Type::File.new(:name => dest, :target => source, :recurse => true, :ensure => :link, :backup => false)
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @file
 
       @catalog.apply
 
       @dirs.each do |path|
         link_path = path.sub(source, dest)
 
         File.lstat(link_path).should be_directory
       end
 
       @files.each do |path|
         link_path = path.sub(source, dest)
 
         File.lstat(link_path).ftype.should == "link"
       end
     end
 
     it "should be able to recursively copy files" do
       source = tmpfile("file_source_integration_source")
 
       build_path(source)
 
       dest = tmpfile("file_source_integration_dest")
 
       @file = Puppet::Type::File.new(:name => dest, :source => source, :recurse => true, :backup => false)
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @file
 
       @catalog.apply
 
       @dirs.each do |path|
         newpath = path.sub(source, dest)
 
         File.lstat(newpath).should be_directory
       end
 
       @files.each do |path|
         newpath = path.sub(source, dest)
 
         File.lstat(newpath).ftype.should == "file"
       end
     end
 
     it "should not recursively manage files managed by a more specific explicit file" do
       dir = tmpfile("recursion_vs_explicit_1")
 
       subdir = File.join(dir, "subdir")
       file = File.join(subdir, "file")
 
       FileUtils.mkdir_p(subdir)
       File.open(file, "w") { |f| f.puts "" }
 
       base = Puppet::Type::File.new(:name => dir, :recurse => true, :backup => false, :mode => "755")
       sub = Puppet::Type::File.new(:name => subdir, :recurse => true, :backup => false, :mode => "644")
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource base
       @catalog.add_resource sub
 
       @catalog.apply
 
       (File.stat(file).mode & 007777).should == 0644
     end
 
     it "should recursively manage files even if there is an explicit file whose name is a prefix of the managed file" do
       dir = tmpfile("recursion_vs_explicit_2")
 
       managed   = File.join(dir, "file")
       generated = File.join(dir, "file_with_a_name_starting_with_the_word_file")
 
       FileUtils.mkdir_p(dir)
       File.open(managed,   "w") { |f| f.puts "" }
       File.open(generated, "w") { |f| f.puts "" }
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource Puppet::Type::File.new(:name => dir,     :recurse => true, :backup => false, :mode => "755")
       @catalog.add_resource Puppet::Type::File.new(:name => managed, :recurse => true, :backup => false, :mode => "644")
 
       @catalog.apply
 
       (File.stat(generated).mode & 007777).should == 0755
     end
   end
 
   describe "when generating resources" do
     before do
       @source = tmpfile("generating_in_catalog_source")
 
       @dest = tmpfile("generating_in_catalog_dest")
 
       Dir.mkdir(@source)
 
       s1 = File.join(@source, "one")
       s2 = File.join(@source, "two")
 
       File.open(s1, "w") { |f| f.puts "uno" }
       File.open(s2, "w") { |f| f.puts "dos" }
 
       @file = Puppet::Type::File.new(:name => @dest, :source => @source, :recurse => true, :backup => false)
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @file
     end
 
     it "should add each generated resource to the catalog" do
       @catalog.apply do |trans|
         @catalog.resource(:file, File.join(@dest, "one")).should be_instance_of(@file.class)
         @catalog.resource(:file, File.join(@dest, "two")).should be_instance_of(@file.class)
       end
     end
 
     it "should have an edge to each resource in the relationship graph" do
       @catalog.apply do |trans|
         one = @catalog.resource(:file, File.join(@dest, "one"))
-        @catalog.relationship_graph.should be_edge(@file, one)
+        @catalog.relationship_graph.edge?(@file, one).should be
 
         two = @catalog.resource(:file, File.join(@dest, "two"))
-        @catalog.relationship_graph.should be_edge(@file, two)
+        @catalog.relationship_graph.edge?(@file, two).should be
       end
     end
   end
 
   describe "when copying files" do
     # Ticket #285.
     it "should be able to copy files with pound signs in their names" do
       source = tmpfile("filewith#signs")
 
       dest = tmpfile("destwith#signs")
 
       File.open(source, "w") { |f| f.print "foo" }
 
       file = Puppet::Type::File.new(:name => dest, :source => source)
 
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
 
       catalog.apply
 
       File.read(dest).should == "foo"
     end
 
     it "should be able to copy files with spaces in their names" do
       source = tmpfile("filewith spaces")
 
       dest = tmpfile("destwith spaces")
 
       File.open(source, "w") { |f| f.print "foo" }
       File.chmod(0755, source)
 
       file = Puppet::Type::File.new(:path => dest, :source => source)
 
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
 
       catalog.apply
 
       File.read(dest).should == "foo"
       (File.stat(dest).mode & 007777).should == 0755
     end
 
     it "should be able to copy individual files even if recurse has been specified" do
       source = tmpfile("source")
       dest = tmpfile("dest")
 
       File.open(source, "w") { |f| f.print "foo" }
 
       file = Puppet::Type::File.new(:name => dest, :source => source, :recurse => true)
 
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
       catalog.apply
 
       File.read(dest).should == "foo"
     end
   end
 
   it "should be able to create files when 'content' is specified but 'ensure' is not" do
     dest = tmpfile("files_with_content")
 
 
     file = Puppet::Type.type(:file).new(
       :name    => dest,
       :content => "this is some content, yo"
     )
 
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource file
     catalog.apply
 
     File.read(dest).should == "this is some content, yo"
   end
 
   it "should create files with content if both 'content' and 'ensure' are set" do
     dest = tmpfile("files_with_content")
 
 
     file = Puppet::Type.type(:file).new(
       :name    => dest,
       :ensure  => "file",
       :content => "this is some content, yo"
     )
 
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource file
     catalog.apply
 
     File.read(dest).should == "this is some content, yo"
   end
 
   it "should delete files with sources but that are set for deletion" do
     dest = tmpfile("dest_source_with_ensure")
     source = tmpfile("source_source_with_ensure")
     File.open(source, "w") { |f| f.puts "yay" }
     File.open(dest, "w") { |f| f.puts "boo" }
 
 
     file = Puppet::Type.type(:file).new(
       :name   => dest,
       :ensure => :absent,
       :source => source,
       :backup => false
     )
 
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource file
     catalog.apply
 
     File.should_not be_exist(dest)
   end
 
   describe "when purging files" do
     before do
       @sourcedir = tmpfile("purge_source")
       @destdir = tmpfile("purge_dest")
       Dir.mkdir(@sourcedir)
       Dir.mkdir(@destdir)
       @sourcefile = File.join(@sourcedir, "sourcefile")
       @copiedfile = File.join(@destdir, "sourcefile")
       @localfile = File.join(@destdir, "localfile")
       @purgee = File.join(@destdir, "to_be_purged")
       File.open(@localfile, "w") { |f| f.puts "rahtest" }
       File.open(@sourcefile, "w") { |f| f.puts "funtest" }
       # this file should get removed
       File.open(@purgee, "w") { |f| f.puts "footest" }
 
 
       @lfobj = Puppet::Type.newfile(
         :title   => "localfile",
         :path    => @localfile,
         :content => "rahtest\n",
         :ensure  => :file,
         :backup  => false
       )
 
 
       @destobj = Puppet::Type.newfile(
         :title   => "destdir",
         :path    => @destdir,
         :source  => @sourcedir,
         :backup  => false,
         :purge   => true,
         :recurse => true
       )
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @lfobj, @destobj
     end
 
     it "should still copy remote files" do
       @catalog.apply
       FileTest.should be_exist(@copiedfile)
     end
 
     it "should not purge managed, local files" do
       @catalog.apply
       FileTest.should be_exist(@localfile)
     end
 
     it "should purge files that are neither remote nor otherwise managed" do
       @catalog.apply
       FileTest.should_not be_exist(@purgee)
     end
   end
 end
diff --git a/spec/unit/resource/catalog_spec.rb b/spec/unit/resource/catalog_spec.rb
index 42850c23b..411d10b32 100755
--- a/spec/unit/resource/catalog_spec.rb
+++ b/spec/unit/resource/catalog_spec.rb
@@ -1,1068 +1,1062 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Puppet::Resource::Catalog, "when compiling" do
 
   before do
     @basepath = Puppet.features.posix? ? "/somepath" : "C:/somepath"
     # stub this to not try to create state.yaml
     Puppet::Util::Storage.stubs(:store)
   end
 
   it "should be an Expirer" do
     Puppet::Resource::Catalog.ancestors.should be_include(Puppet::Util::Cacher::Expirer)
   end
 
   it "should always be expired if it's not applying" do
     @catalog = Puppet::Resource::Catalog.new("host")
     @catalog.expects(:applying?).returns false
     @catalog.should be_dependent_data_expired(Time.now)
   end
 
   it "should not be expired if it's applying and the timestamp is late enough" do
     @catalog = Puppet::Resource::Catalog.new("host")
     @catalog.expire
     @catalog.expects(:applying?).returns true
     @catalog.should_not be_dependent_data_expired(Time.now)
   end
 
   it "should be able to write its list of classes to the class file" do
     @catalog = Puppet::Resource::Catalog.new("host")
 
     @catalog.add_class "foo", "bar"
 
     Puppet.settings.expects(:value).with(:classfile).returns "/class/file"
 
     fh = mock 'filehandle'
     File.expects(:open).with("/class/file", "w").yields fh
 
     fh.expects(:puts).with "foo\nbar"
 
     @catalog.write_class_file
   end
 
   it "should have a client_version attribute" do
     @catalog = Puppet::Resource::Catalog.new("host")
     @catalog.client_version = 5
     @catalog.client_version.should == 5
   end
 
   it "should have a server_version attribute" do
     @catalog = Puppet::Resource::Catalog.new("host")
     @catalog.server_version = 5
     @catalog.server_version.should == 5
   end
 
   describe "when compiling" do
     it "should accept tags" do
       config = Puppet::Resource::Catalog.new("mynode")
       config.tag("one")
       config.tags.should == %w{one}
     end
 
     it "should accept multiple tags at once" do
       config = Puppet::Resource::Catalog.new("mynode")
       config.tag("one", "two")
       config.tags.should == %w{one two}
     end
 
     it "should convert all tags to strings" do
       config = Puppet::Resource::Catalog.new("mynode")
       config.tag("one", :two)
       config.tags.should == %w{one two}
     end
 
     it "should tag with both the qualified name and the split name" do
       config = Puppet::Resource::Catalog.new("mynode")
       config.tag("one::two")
       config.tags.include?("one").should be_true
       config.tags.include?("one::two").should be_true
     end
 
     it "should accept classes" do
       config = Puppet::Resource::Catalog.new("mynode")
       config.add_class("one")
       config.classes.should == %w{one}
       config.add_class("two", "three")
       config.classes.should == %w{one two three}
     end
 
     it "should tag itself with passed class names" do
       config = Puppet::Resource::Catalog.new("mynode")
       config.add_class("one")
       config.tags.should == %w{one}
     end
   end
 
   describe "when extracting transobjects" do
 
     def mkscope
       @node = Puppet::Node.new("mynode")
       @compiler = Puppet::Parser::Compiler.new(@node)
 
       # XXX This is ridiculous.
       @compiler.send(:evaluate_main)
       @scope = @compiler.topscope
     end
 
     def mkresource(type, name)
       Puppet::Parser::Resource.new(type, name, :source => @source, :scope => @scope)
     end
 
     it "should fail if no 'main' stage can be found" do
       lambda { Puppet::Resource::Catalog.new("mynode").extract }.should raise_error(Puppet::DevError)
     end
 
     it "should warn if any non-main stages are present" do
       config = Puppet::Resource::Catalog.new("mynode")
 
       @scope = mkscope
       @source = mock 'source'
 
       main = mkresource("stage", "main")
       config.add_resource(main)
 
       other = mkresource("stage", "other")
       config.add_resource(other)
 
       Puppet.expects(:warning)
 
       config.extract
     end
 
     it "should always create a TransBucket for the 'main' stage" do
       config = Puppet::Resource::Catalog.new("mynode")
 
       @scope = mkscope
       @source = mock 'source'
 
       main = mkresource("stage", "main")
       config.add_resource(main)
 
       result = config.extract
       result.type.should == "Stage"
       result.name.should == "main"
     end
 
     # Now try it with a more complicated graph -- a three tier graph, each tier
     it "should transform arbitrarily deep graphs into isomorphic trees" do
       config = Puppet::Resource::Catalog.new("mynode")
 
       @scope = mkscope
       @scope.stubs(:tags).returns([])
       @source = mock 'source'
 
       # Create our scopes.
       top = mkresource "stage", "main"
 
       config.add_resource top
       topbucket = []
       topbucket.expects(:classes=).with([])
       top.expects(:to_trans).returns(topbucket)
       topres = mkresource "file", "/top"
       topres.expects(:to_trans).returns(:topres)
       config.add_edge top, topres
 
       middle = mkresource "class", "middle"
       middle.expects(:to_trans).returns([])
       config.add_edge top, middle
       midres = mkresource "file", "/mid"
       midres.expects(:to_trans).returns(:midres)
       config.add_edge middle, midres
 
       bottom = mkresource "class", "bottom"
       bottom.expects(:to_trans).returns([])
       config.add_edge middle, bottom
       botres = mkresource "file", "/bot"
       botres.expects(:to_trans).returns(:botres)
       config.add_edge bottom, botres
 
       toparray = config.extract
 
       # This is annoying; it should look like:
       #   [[[:botres], :midres], :topres]
       # but we can't guarantee sort order.
       toparray.include?(:topres).should be_true
 
       midarray = toparray.find { |t| t.is_a?(Array) }
       midarray.include?(:midres).should be_true
       botarray = midarray.find { |t| t.is_a?(Array) }
       botarray.include?(:botres).should be_true
     end
   end
 
   describe " when converting to a Puppet::Resource catalog" do
     before do
       @original = Puppet::Resource::Catalog.new("mynode")
       @original.tag(*%w{one two three})
       @original.add_class *%w{four five six}
 
       @top            = Puppet::TransObject.new 'top', "class"
       @topobject      = Puppet::TransObject.new '/topobject', "file"
       @middle         = Puppet::TransObject.new 'middle', "class"
       @middleobject   = Puppet::TransObject.new '/middleobject', "file"
       @bottom         = Puppet::TransObject.new 'bottom', "class"
       @bottomobject   = Puppet::TransObject.new '/bottomobject', "file"
 
       @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject]
 
       @original.add_resource(*@resources)
 
       @original.add_edge(@top, @topobject)
       @original.add_edge(@top, @middle)
       @original.add_edge(@middle, @middleobject)
       @original.add_edge(@middle, @bottom)
       @original.add_edge(@bottom, @bottomobject)
 
       @catalog = @original.to_resource
     end
 
     it "should copy over the version" do
       @original.version = "foo"
       @original.to_resource.version.should == "foo"
     end
 
     it "should convert parser resources to plain resources" do
       resource = Puppet::Parser::Resource.new(:file, "foo", :scope => stub("scope", :environment => nil, :namespaces => nil), :source => stub("source"))
       catalog = Puppet::Resource::Catalog.new("whev")
       catalog.add_resource(resource)
       new = catalog.to_resource
       new.resource(:file, "foo").class.should == Puppet::Resource
     end
 
     it "should add all resources as Puppet::Resource instances" do
       @resources.each { |resource| @catalog.resource(resource.ref).should be_instance_of(Puppet::Resource) }
     end
 
     it "should copy the tag list to the new catalog" do
       @catalog.tags.sort.should == @original.tags.sort
     end
 
     it "should copy the class list to the new catalog" do
       @catalog.classes.should == @original.classes
     end
 
     it "should duplicate the original edges" do
       @original.edges.each do |edge|
         @catalog.edge?(@catalog.resource(edge.source.ref), @catalog.resource(edge.target.ref)).should be_true
       end
     end
 
     it "should set itself as the catalog for each converted resource" do
       @catalog.vertices.each { |v| v.catalog.object_id.should equal(@catalog.object_id) }
     end
   end
 
   describe "when converting to a RAL catalog" do
     before do
       @original = Puppet::Resource::Catalog.new("mynode")
       @original.tag(*%w{one two three})
       @original.add_class *%w{four five six}
 
       @top            = Puppet::Resource.new :class, 'top'
       @topobject      = Puppet::Resource.new :file, @basepath+'/topobject'
       @middle         = Puppet::Resource.new :class, 'middle'
       @middleobject   = Puppet::Resource.new :file, @basepath+'/middleobject'
       @bottom         = Puppet::Resource.new :class, 'bottom'
       @bottomobject   = Puppet::Resource.new :file, @basepath+'/bottomobject'
 
       @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject]
 
       @original.add_resource(*@resources)
 
       @original.add_edge(@top, @topobject)
       @original.add_edge(@top, @middle)
       @original.add_edge(@middle, @middleobject)
       @original.add_edge(@middle, @bottom)
       @original.add_edge(@bottom, @bottomobject)
 
       @catalog = @original.to_ral
     end
 
     it "should add all resources as RAL instances" do
       @resources.each { |resource| @catalog.resource(resource.ref).should be_instance_of(Puppet::Type) }
     end
 
     it "should copy the tag list to the new catalog" do
       @catalog.tags.sort.should == @original.tags.sort
     end
 
     it "should copy the class list to the new catalog" do
       @catalog.classes.should == @original.classes
     end
 
     it "should duplicate the original edges" do
       @original.edges.each do |edge|
         @catalog.edge?(@catalog.resource(edge.source.ref), @catalog.resource(edge.target.ref)).should be_true
       end
     end
 
     it "should set itself as the catalog for each converted resource" do
       @catalog.vertices.each { |v| v.catalog.object_id.should equal(@catalog.object_id) }
     end
 
     # This tests #931.
     it "should not lose track of resources whose names vary" do
       changer = Puppet::TransObject.new 'changer', 'test'
 
       config = Puppet::Resource::Catalog.new('test')
       config.add_resource(changer)
       config.add_resource(@top)
 
       config.add_edge(@top, changer)
 
       resource = stub 'resource', :name => "changer2", :title => "changer2", :ref => "Test[changer2]", :catalog= => nil, :remove => nil
 
       #changer is going to get duplicated as part of a fix for aliases 1094
       changer.expects(:dup).returns(changer)
       changer.expects(:to_ral).returns(resource)
 
       newconfig = nil
 
       proc { @catalog = config.to_ral }.should_not raise_error
       @catalog.resource("Test[changer2]").should equal(resource)
     end
 
     after do
       # Remove all resource instances.
       @catalog.clear(true)
     end
   end
 
   describe "when filtering" do
     before :each do
       @original = Puppet::Resource::Catalog.new("mynode")
       @original.tag(*%w{one two three})
       @original.add_class *%w{four five six}
 
       @r1 = stub_everything 'r1', :ref => "File[/a]"
       @r1.stubs(:respond_to?).with(:ref).returns(true)
       @r1.stubs(:dup).returns(@r1)
       @r1.stubs(:is_a?).returns(Puppet::Resource).returns(true)
 
       @r2 = stub_everything 'r2', :ref => "File[/b]"
       @r2.stubs(:respond_to?).with(:ref).returns(true)
       @r2.stubs(:dup).returns(@r2)
       @r2.stubs(:is_a?).returns(Puppet::Resource).returns(true)
 
       @resources = [@r1,@r2]
 
       @original.add_resource(@r1,@r2)
     end
 
     it "should transform the catalog to a resource catalog" do
       @original.expects(:to_catalog).with { |h,b| h == :to_resource }
 
       @original.filter
     end
 
     it "should scan each catalog resource in turn and apply filtering block" do
       @resources.each { |r| r.expects(:test?) }
       @original.filter do |r|
         r.test?
       end
     end
 
     it "should filter out resources which produce true when the filter block is evaluated" do
       @original.filter do |r|
         r == @r1
       end.resource("File[/a]").should be_nil
     end
 
     it "should not consider edges against resources that were filtered out" do
       @original.add_edge(@r1,@r2)
       @original.filter do |r|
         r == @r1
       end.edge?(@r1,@r2).should_not be
     end
   end
 
   describe "when functioning as a resource container" do
     before do
       @catalog = Puppet::Resource::Catalog.new("host")
       @one = Puppet::Type.type(:notify).new :name => "one"
       @two = Puppet::Type.type(:notify).new :name => "two"
       @dupe = Puppet::Type.type(:notify).new :name => "one"
     end
 
     it "should provide a method to add one or more resources" do
       @catalog.add_resource @one, @two
       @catalog.resource(@one.ref).should equal(@one)
       @catalog.resource(@two.ref).should equal(@two)
     end
 
     it "should add resources to the relationship graph if it exists" do
       relgraph = @catalog.relationship_graph
       @catalog.add_resource @one
       relgraph.should be_vertex(@one)
     end
 
-    it "should yield added resources if a block is provided" do
-      yielded = []
-      @catalog.add_resource(@one, @two) { |r| yielded << r }
-      yielded.length.should == 2
-    end
-
     it "should set itself as the resource's catalog if it is not a relationship graph" do
       @one.expects(:catalog=).with(@catalog)
       @catalog.add_resource @one
     end
 
     it "should make all vertices available by resource reference" do
       @catalog.add_resource(@one)
       @catalog.resource(@one.ref).should equal(@one)
       @catalog.vertices.find { |r| r.ref == @one.ref }.should equal(@one)
     end
 
     it "should canonize how resources are referred to during retrieval when both type and title are provided" do
       @catalog.add_resource(@one)
 
       @catalog.resource("notify", "one").should equal(@one)
     end
 
     it "should canonize how resources are referred to during retrieval when just the title is provided" do
       @catalog.add_resource(@one)
 
       @catalog.resource("notify[one]", nil).should equal(@one)
     end
 
     it "should not allow two resources with the same resource reference" do
       @catalog.add_resource(@one)
 
       proc { @catalog.add_resource(@dupe) }.should raise_error(Puppet::Resource::Catalog::DuplicateResourceError)
     end
 
     it "should not store objects that do not respond to :ref" do
       proc { @catalog.add_resource("thing") }.should raise_error(ArgumentError)
     end
 
     it "should remove all resources when asked" do
       @catalog.add_resource @one
       @catalog.add_resource @two
       @one.expects :remove
       @two.expects :remove
       @catalog.clear(true)
     end
 
     it "should support a mechanism for finishing resources" do
       @one.expects :finish
       @two.expects :finish
       @catalog.add_resource @one
       @catalog.add_resource @two
 
       @catalog.finalize
     end
 
     it "should make default resources when finalizing" do
       @catalog.expects(:make_default_resources)
       @catalog.finalize
     end
 
     it "should add default resources to the catalog upon creation" do
       @catalog.make_default_resources
       @catalog.resource(:schedule, "daily").should_not be_nil
     end
 
     it "should optionally support an initialization block and should finalize after such blocks" do
       @one.expects :finish
       @two.expects :finish
       config = Puppet::Resource::Catalog.new("host") do |conf|
         conf.add_resource @one
         conf.add_resource @two
       end
     end
 
     it "should inform the resource that it is the resource's catalog" do
       @one.expects(:catalog=).with(@catalog)
       @catalog.add_resource @one
     end
 
     it "should be able to find resources by reference" do
       @catalog.add_resource @one
       @catalog.resource(@one.ref).should equal(@one)
     end
 
     it "should be able to find resources by reference or by type/title tuple" do
       @catalog.add_resource @one
       @catalog.resource("notify", "one").should equal(@one)
     end
 
     it "should have a mechanism for removing resources" do
       @catalog.add_resource @one
       @one.expects :remove
       @catalog.remove_resource(@one)
       @catalog.resource(@one.ref).should be_nil
       @catalog.vertex?(@one).should be_false
     end
 
     it "should have a method for creating aliases for resources" do
       @catalog.add_resource @one
       @catalog.alias(@one, "other")
       @catalog.resource("notify", "other").should equal(@one)
     end
 
     it "should ignore conflicting aliases that point to the aliased resource" do
       @catalog.alias(@one, "other")
       lambda { @catalog.alias(@one, "other") }.should_not raise_error
     end
 
     it "should create aliases for resources isomorphic resources whose names do not match their titles" do
       resource = Puppet::Type::File.new(:title => "testing", :path => @basepath+"/something")
 
       @catalog.add_resource(resource)
 
       @catalog.resource(:file, @basepath+"/something").should equal(resource)
     end
 
     it "should not create aliases for resources non-isomorphic resources whose names do not match their titles" do
       resource = Puppet::Type.type(:exec).new(:title => "testing", :command => "echo", :path => %w{/bin /usr/bin /usr/local/bin})
 
       @catalog.add_resource(resource)
 
       # Yay, I've already got a 'should' method
       @catalog.resource(:exec, "echo").object_id.should == nil.object_id
     end
 
     # This test is the same as the previous, but the behaviour should be explicit.
     it "should alias using the class name from the resource reference, not the resource class name" do
       @catalog.add_resource @one
       @catalog.alias(@one, "other")
       @catalog.resource("notify", "other").should equal(@one)
     end
 
     it "should ignore conflicting aliases that point to the aliased resource" do
       @catalog.alias(@one, "other")
       lambda { @catalog.alias(@one, "other") }.should_not raise_error
     end
 
     it "should fail to add an alias if the aliased name already exists" do
       @catalog.add_resource @one
       proc { @catalog.alias @two, "one" }.should raise_error(ArgumentError)
     end
 
     it "should not fail when a resource has duplicate aliases created" do
       @catalog.add_resource @one
       proc { @catalog.alias @one, "one" }.should_not raise_error
     end
 
     it "should not create aliases that point back to the resource" do
       @catalog.alias(@one, "one")
       @catalog.resource(:notify, "one").should be_nil
     end
 
     it "should be able to look resources up by their aliases" do
       @catalog.add_resource @one
       @catalog.alias @one, "two"
       @catalog.resource(:notify, "two").should equal(@one)
     end
 
     it "should remove resource aliases when the target resource is removed" do
       @catalog.add_resource @one
       @catalog.alias(@one, "other")
       @one.expects :remove
       @catalog.remove_resource(@one)
       @catalog.resource("notify", "other").should be_nil
     end
 
     it "should add an alias for the namevar when the title and name differ on isomorphic resource types" do
       resource = Puppet::Type.type(:file).new :path => @basepath+"/something", :title => "other", :content => "blah"
       resource.expects(:isomorphic?).returns(true)
       @catalog.add_resource(resource)
       @catalog.resource(:file, "other").should equal(resource)
       @catalog.resource(:file, @basepath+"/something").ref.should == resource.ref
     end
 
     it "should not add an alias for the namevar when the title and name differ on non-isomorphic resource types" do
       resource = Puppet::Type.type(:file).new :path => @basepath+"/something", :title => "other", :content => "blah"
       resource.expects(:isomorphic?).returns(false)
       @catalog.add_resource(resource)
       @catalog.resource(:file, resource.title).should equal(resource)
       # We can't use .should here, because the resources respond to that method.
       raise "Aliased non-isomorphic resource" if @catalog.resource(:file, resource.name)
     end
 
     it "should provide a method to create additional resources that also registers the resource" do
       args = {:name => "/yay", :ensure => :file}
       resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog, :title => "/yay", :[] => "/yay"
       Puppet::Type.type(:file).expects(:new).with(args).returns(resource)
       @catalog.create_resource :file, args
       @catalog.resource("File[/yay]").should equal(resource)
     end
   end
 
   describe "when applying" do
     before :each do
       @catalog = Puppet::Resource::Catalog.new("host")
 
       @transaction = mock 'transaction'
       Puppet::Transaction.stubs(:new).returns(@transaction)
       @transaction.stubs(:evaluate)
       @transaction.stubs(:add_times)
 
       Puppet.settings.stubs(:use)
     end
 
     it "should create and evaluate a transaction" do
       @transaction.expects(:evaluate)
       @catalog.apply
     end
 
     it "should provide the catalog retrieval time to the transaction" do
       @catalog.retrieval_duration = 5
       @transaction.expects(:add_times).with(:config_retrieval => 5)
       @catalog.apply
     end
 
     it "should use a retrieval time of 0 if none is set in the catalog" do
       @catalog.retrieval_duration = nil
       @transaction.expects(:add_times).with(:config_retrieval => 0)
       @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 being a host catalog" do
       @catalog.host_config.should be_true
     end
 
     it "should be able to be set to a non-host_config" do
       @catalog.host_config = false
       @catalog.host_config.should be_false
     end
 
     it "should pass supplied tags on to the transaction" do
       @transaction.expects(:tags=).with(%w{one two})
       @catalog.apply(:tags => %w{one two})
     end
 
     it "should set ignoreschedules on the transaction if specified in apply()" do
       @transaction.expects(:ignoreschedules=).with(true)
       @catalog.apply(:ignoreschedules => true)
     end
 
     it "should expire cached data in the resources both before and after the transaction" do
       @catalog.expects(:expire).times(2)
       @catalog.apply
     end
 
     describe "host catalogs" do
 
       # super() doesn't work in the setup method for some reason
       before do
         @catalog.host_config = true
         Puppet::Util::Storage.stubs(:store)
       end
 
       it "should initialize the state database before applying a catalog" do
         Puppet::Util::Storage.expects(:load)
 
         # Short-circuit the apply, so we know we're loading before the transaction
         Puppet::Transaction.expects(:new).raises ArgumentError
         proc { @catalog.apply }.should raise_error(ArgumentError)
       end
 
       it "should sync the state database after applying" do
         Puppet::Util::Storage.expects(:store)
         @transaction.stubs :any_failed? => false
         @catalog.apply
       end
 
       after { Puppet.settings.clear }
     end
 
     describe "non-host catalogs" do
 
       before do
         @catalog.host_config = false
       end
 
       it "should never send reports" do
         Puppet[:report] = true
         Puppet[:summarize] = true
         @catalog.apply
       end
 
       it "should never modify the state database" do
         Puppet::Util::Storage.expects(:load).never
         Puppet::Util::Storage.expects(:store).never
         @catalog.apply
       end
 
       after { Puppet.settings.clear }
     end
   end
 
   describe "when creating a relationship graph" do
     before do
       Puppet::Type.type(:component)
       @catalog = Puppet::Resource::Catalog.new("host")
       @compone = Puppet::Type::Component.new :name => "one"
       @comptwo = Puppet::Type::Component.new :name => "two", :require => "Class[one]"
       @file = Puppet::Type.type(:file)
       @one = @file.new :path => @basepath+"/one"
       @two = @file.new :path => @basepath+"/two"
       @sub = @file.new :path => @basepath+"/two/subdir"
       @catalog.add_edge @compone, @one
       @catalog.add_edge @comptwo, @two
 
       @three = @file.new :path => @basepath+"/three"
       @four = @file.new :path => @basepath+"/four", :require => "File[#{@basepath}/three]"
       @five = @file.new :path => @basepath+"/five"
       @catalog.add_resource @compone, @comptwo, @one, @two, @three, @four, @five, @sub
 
       @relationships = @catalog.relationship_graph
     end
 
     it "should be able to create a relationship graph" do
       @relationships.should be_instance_of(Puppet::SimpleGraph)
     end
 
     it "should not have any components" do
       @relationships.vertices.find { |r| r.instance_of?(Puppet::Type::Component) }.should be_nil
     end
 
     it "should have all non-component resources from the catalog" do
       # The failures print out too much info, so i just do a class comparison
       @relationships.vertex?(@five).should be_true
     end
 
     it "should have all resource relationships set as edges" do
       @relationships.edge?(@three, @four).should be_true
     end
 
     it "should copy component relationships to all contained resources" do
       @relationships.edge?(@one, @two).should be_true
     end
 
     it "should add automatic relationships to the relationship graph" do
       @relationships.edge?(@two, @sub).should be_true
     end
 
     it "should get removed when the catalog is cleaned up" do
       @relationships.expects(:clear)
       @catalog.clear
       @catalog.instance_variable_get("@relationship_graph").should be_nil
     end
 
     it "should write :relationships and :expanded_relationships graph files if the catalog is a host catalog" do
       @catalog.clear
       graph = Puppet::SimpleGraph.new
       Puppet::SimpleGraph.expects(:new).returns graph
 
       graph.expects(:write_graph).with(:relationships)
       graph.expects(:write_graph).with(:expanded_relationships)
 
       @catalog.host_config = true
 
       @catalog.relationship_graph
     end
 
     it "should not write graph files if the catalog is not a host catalog" do
       @catalog.clear
       graph = Puppet::SimpleGraph.new
       Puppet::SimpleGraph.expects(:new).returns graph
 
       graph.expects(:write_graph).never
 
       @catalog.host_config = false
 
       @catalog.relationship_graph
     end
 
     it "should create a new relationship graph after clearing the old one" do
       @relationships.expects(:clear)
       @catalog.clear
       @catalog.relationship_graph.should be_instance_of(Puppet::SimpleGraph)
     end
 
     it "should remove removed resources from the relationship graph if it exists" do
       @catalog.remove_resource(@one)
       @catalog.relationship_graph.vertex?(@one).should be_false
     end
   end
 
   describe "when writing dot files" do
     before do
       @catalog = Puppet::Resource::Catalog.new("host")
       @name = :test
       @file = File.join(Puppet[:graphdir], @name.to_s + ".dot")
     end
 
     it "should only write when it is a host catalog" do
       File.expects(:open).with(@file).never
       @catalog.host_config = false
       Puppet[:graph] = true
       @catalog.write_graph(@name)
     end
 
     after do
       Puppet.settings.clear
     end
   end
 
   describe "when indirecting" do
     before do
       @real_indirection = Puppet::Resource::Catalog.indirection
 
       @indirection = stub 'indirection', :name => :catalog
 
       Puppet::Util::Cacher.expire
     end
 
     it "should use the value of the 'catalog_terminus' setting to determine its terminus class" do
       # Puppet only checks the terminus setting the first time you ask
       # so this returns the object to the clean state
       # at the expense of making this test less pure
       Puppet::Resource::Catalog.indirection.reset_terminus_class
 
       Puppet.settings[:catalog_terminus] = "rest"
       Puppet::Resource::Catalog.indirection.terminus_class.should == :rest
     end
 
     it "should allow the terminus class to be set manually" do
       Puppet::Resource::Catalog.indirection.terminus_class = :rest
       Puppet::Resource::Catalog.indirection.terminus_class.should == :rest
     end
 
     after do
       Puppet::Util::Cacher.expire
       @real_indirection.reset_terminus_class
     end
   end
 
   describe "when converting to yaml" do
     before do
       @catalog = Puppet::Resource::Catalog.new("me")
       @catalog.add_edge("one", "two")
     end
 
     it "should be able to be dumped to yaml" do
       YAML.dump(@catalog).should be_instance_of(String)
     end
   end
 
   describe "when converting from yaml" do
     before do
       @catalog = Puppet::Resource::Catalog.new("me")
       @catalog.add_edge("one", "two")
 
       text = YAML.dump(@catalog)
       @newcatalog = YAML.load(text)
     end
 
     it "should get converted back to a catalog" do
       @newcatalog.should be_instance_of(Puppet::Resource::Catalog)
     end
 
     it "should have all vertices" do
       @newcatalog.vertex?("one").should be_true
       @newcatalog.vertex?("two").should be_true
     end
 
     it "should have all edges" do
       @newcatalog.edge?("one", "two").should be_true
     end
   end
 end
 
 describe Puppet::Resource::Catalog, "when converting to pson", :if => Puppet.features.pson? do
   before do
     @catalog = Puppet::Resource::Catalog.new("myhost")
   end
 
   def pson_output_should
     @catalog.class.expects(:pson_create).with { |hash| yield hash }.returns(:something)
   end
 
   # LAK:NOTE For all of these tests, we convert back to the resource so we can
   # trap the actual data structure then.
   it "should set its document_type to 'Catalog'" do
     pson_output_should { |hash| hash['document_type'] == "Catalog" }
 
     PSON.parse @catalog.to_pson
   end
 
   it "should set its data as a hash" do
     pson_output_should { |hash| hash['data'].is_a?(Hash) }
     PSON.parse @catalog.to_pson
   end
 
   [:name, :version, :tags, :classes].each do |param|
     it "should set its #{param} to the #{param} of the resource" do
       @catalog.send(param.to_s + "=", "testing") unless @catalog.send(param)
 
       pson_output_should { |hash| hash['data'][param.to_s] == @catalog.send(param) }
       PSON.parse @catalog.to_pson
     end
   end
 
   it "should convert its resources to a PSON-encoded array and store it as the 'resources' data" do
     one = stub 'one', :to_pson_data_hash => "one_resource", :ref => "Foo[one]"
     two = stub 'two', :to_pson_data_hash => "two_resource", :ref => "Foo[two]"
 
     @catalog.add_resource(one)
     @catalog.add_resource(two)
 
     # TODO this should really guarantee sort order
     PSON.parse(@catalog.to_pson,:create_additions => false)['data']['resources'].sort.should == ["one_resource", "two_resource"].sort
 
   end
 
   it "should convert its edges to a PSON-encoded array and store it as the 'edges' data" do
     one   = stub 'one',   :to_pson_data_hash => "one_resource",   :ref => 'Foo[one]'
     two   = stub 'two',   :to_pson_data_hash => "two_resource",   :ref => 'Foo[two]'
     three = stub 'three', :to_pson_data_hash => "three_resource", :ref => 'Foo[three]'
 
     @catalog.add_edge(one, two)
     @catalog.add_edge(two, three)
 
     @catalog.edges_between(one, two  )[0].expects(:to_pson_data_hash).returns "one_two_pson"
     @catalog.edges_between(two, three)[0].expects(:to_pson_data_hash).returns "two_three_pson"
 
     PSON.parse(@catalog.to_pson,:create_additions => false)['data']['edges'].sort.should == %w{one_two_pson two_three_pson}.sort
   end
 end
 
 describe Puppet::Resource::Catalog, "when converting from pson", :if => Puppet.features.pson? do
   def pson_result_should
     Puppet::Resource::Catalog.expects(:new).with { |hash| yield hash }
   end
 
   before do
     @data = {
       'name' => "myhost"
     }
     @pson = {
       'document_type' => 'Puppet::Resource::Catalog',
       'data' => @data,
       'metadata' => {}
     }
 
     @catalog = Puppet::Resource::Catalog.new("myhost")
     Puppet::Resource::Catalog.stubs(:new).returns @catalog
   end
 
   it "should be extended with the PSON utility module" do
     Puppet::Resource::Catalog.singleton_class.ancestors.should be_include(Puppet::Util::Pson)
   end
 
   it "should create it with the provided name" do
     Puppet::Resource::Catalog.expects(:new).with('myhost').returns @catalog
     PSON.parse @pson.to_pson
   end
 
   it "should set the provided version on the catalog if one is set" do
     @data['version'] = 50
     PSON.parse @pson.to_pson
     @catalog.version.should == @data['version']
   end
 
   it "should set any provided tags on the catalog" do
     @data['tags'] = %w{one two}
     PSON.parse @pson.to_pson
     @catalog.tags.should == @data['tags']
   end
 
   it "should set any provided classes on the catalog" do
     @data['classes'] = %w{one two}
     PSON.parse @pson.to_pson
     @catalog.classes.should == @data['classes']
   end
 
   it 'should convert the resources list into resources and add each of them' do
     @data['resources'] = [Puppet::Resource.new(:file, "/foo"), Puppet::Resource.new(:file, "/bar")]
 
     @catalog.expects(:add_resource).times(2).with { |res| res.type == "File" }
     PSON.parse @pson.to_pson
   end
 
   it 'should convert resources even if they do not include "type" information' do
     @data['resources'] = [Puppet::Resource.new(:file, "/foo")]
 
     @data['resources'][0].expects(:to_pson).returns '{"title":"/foo","tags":["file"],"type":"File"}'
 
     @catalog.expects(:add_resource).with { |res| res.type == "File" }
 
     PSON.parse @pson.to_pson
   end
 
   it 'should convert the edges list into edges and add each of them' do
     one = Puppet::Relationship.new("osource", "otarget", :event => "one", :callback => "refresh")
     two = Puppet::Relationship.new("tsource", "ttarget", :event => "two", :callback => "refresh")
 
     @data['edges'] = [one, two]
 
     @catalog.stubs(:resource).returns("eh")
 
     @catalog.expects(:add_edge).with { |edge| edge.event == "one" }
     @catalog.expects(:add_edge).with { |edge| edge.event == "two" }
 
     PSON.parse @pson.to_pson
   end
 
   it "should be able to convert relationships that do not include 'type' information" do
     one = Puppet::Relationship.new("osource", "otarget", :event => "one", :callback => "refresh")
     one.expects(:to_pson).returns "{\"event\":\"one\",\"callback\":\"refresh\",\"source\":\"osource\",\"target\":\"otarget\"}"
 
     @data['edges'] = [one]
 
     @catalog.stubs(:resource).returns("eh")
 
     @catalog.expects(:add_edge).with { |edge| edge.event == "one" }
 
     PSON.parse @pson.to_pson
   end
 
   it "should set the source and target for each edge to the actual resource" do
     edge = Puppet::Relationship.new("source", "target")
 
     @data['edges'] = [edge]
 
     @catalog.expects(:resource).with("source").returns("source_resource")
     @catalog.expects(:resource).with("target").returns("target_resource")
 
     @catalog.expects(:add_edge).with { |edge| edge.source == "source_resource" and edge.target == "target_resource" }
 
     PSON.parse @pson.to_pson
   end
 
   it "should fail if the source resource cannot be found" do
     edge = Puppet::Relationship.new("source", "target")
 
     @data['edges'] = [edge]
 
     @catalog.expects(:resource).with("source").returns(nil)
     @catalog.stubs(:resource).with("target").returns("target_resource")
 
     lambda { PSON.parse @pson.to_pson }.should raise_error(ArgumentError)
   end
 
   it "should fail if the target resource cannot be found" do
     edge = Puppet::Relationship.new("source", "target")
 
     @data['edges'] = [edge]
 
     @catalog.stubs(:resource).with("source").returns("source_resource")
     @catalog.expects(:resource).with("target").returns(nil)
 
     lambda { PSON.parse @pson.to_pson }.should raise_error(ArgumentError)
   end
 
   describe "#title_key_for_ref" do
     it "should parse a resource ref string into a pair" do
       @catalog.title_key_for_ref("Title[name]").should == ["Title", "name"]
     end
     it "should parse a resource ref string into a pair, even if there's a newline inside the name" do
       @catalog.title_key_for_ref("Title[na\nme]").should == ["Title", "na\nme"]
     end
   end
 end
diff --git a/spec/unit/transaction_spec.rb b/spec/unit/transaction_spec.rb
index 3677bfd87..5867f2e83 100755
--- a/spec/unit/transaction_spec.rb
+++ b/spec/unit/transaction_spec.rb
@@ -1,447 +1,449 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 require 'puppet/transaction'
 
 def without_warnings
   flag = $VERBOSE
   $VERBOSE = nil
   yield
   $VERBOSE = flag
 end
 
 describe Puppet::Transaction do
   before do
     @basepath = Puppet.features.posix? ? "/what/ever" : "C:/tmp"
     @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
   end
 
   it "should delegate its event list to the event manager" do
     @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
     @transaction.event_manager.expects(:events).returns %w{my events}
     @transaction.events.should == %w{my events}
   end
 
   it "should delegate adding times to its report" do
     @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
     @transaction.report.expects(:add_times).with(:foo, 10)
     @transaction.report.expects(:add_times).with(:bar, 20)
 
     @transaction.add_times :foo => 10, :bar => 20
   end
 
   it "should be able to accept resource status instances" do
     resource = Puppet::Type.type(:notify).new :title => "foobar"
     status = Puppet::Resource::Status.new(resource)
     @transaction.add_resource_status(status)
     @transaction.resource_status(resource).should equal(status)
   end
 
   it "should be able to look resource status up by resource reference" do
     resource = Puppet::Type.type(:notify).new :title => "foobar"
     status = Puppet::Resource::Status.new(resource)
     @transaction.add_resource_status(status)
     @transaction.resource_status(resource.to_s).should equal(status)
   end
 
   # This will basically only ever be used during testing.
   it "should automatically create resource statuses if asked for a non-existent status" do
     resource = Puppet::Type.type(:notify).new :title => "foobar"
     @transaction.resource_status(resource).should be_instance_of(Puppet::Resource::Status)
   end
 
   it "should add provided resource statuses to its report" do
     resource = Puppet::Type.type(:notify).new :title => "foobar"
     status = Puppet::Resource::Status.new(resource)
     @transaction.add_resource_status(status)
     @transaction.report.resource_statuses[resource.to_s].should equal(status)
   end
 
   it "should consider a resource to be failed if a status instance exists for that resource and indicates it is failed" do
     resource = Puppet::Type.type(:notify).new :name => "yayness"
     status = Puppet::Resource::Status.new(resource)
     status.failed = "some message"
     @transaction.add_resource_status(status)
     @transaction.should be_failed(resource)
   end
 
   it "should not consider a resource to be failed if a status instance exists for that resource but indicates it is not failed" do
     resource = Puppet::Type.type(:notify).new :name => "yayness"
     status = Puppet::Resource::Status.new(resource)
     @transaction.add_resource_status(status)
     @transaction.should_not be_failed(resource)
   end
 
   it "should consider there to be failed resources if any statuses are marked failed" do
     resource = Puppet::Type.type(:notify).new :name => "yayness"
     status = Puppet::Resource::Status.new(resource)
     status.failed = "some message"
     @transaction.add_resource_status(status)
     @transaction.should be_any_failed
   end
 
   it "should not consider there to be failed resources if no statuses are marked failed" do
     resource = Puppet::Type.type(:notify).new :name => "yayness"
     status = Puppet::Resource::Status.new(resource)
     @transaction.add_resource_status(status)
     @transaction.should_not be_any_failed
   end
 
   it "should be possible to replace the report object" do
     report = Puppet::Transaction::Report.new("apply")
     @transaction.report = report
 
     @transaction.report.should == report
   end
 
   it "should consider a resource to have failed dependencies if any of its dependencies are failed"
 
   describe "when initializing" do
     it "should create an event manager" do
       @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
       @transaction.event_manager.should be_instance_of(Puppet::Transaction::EventManager)
       @transaction.event_manager.transaction.should equal(@transaction)
     end
 
     it "should create a resource harness" do
       @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
       @transaction.resource_harness.should be_instance_of(Puppet::Transaction::ResourceHarness)
       @transaction.resource_harness.transaction.should equal(@transaction)
     end
   end
 
   describe "when evaluating a resource" do
     before do
       @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
       @transaction.stubs(:eval_children_and_apply_resource)
       @transaction.stubs(:skip?).returns false
 
       @resource = Puppet::Type.type(:file).new :path => @basepath
     end
 
     it "should check whether the resource should be skipped" do
       @transaction.expects(:skip?).with(@resource).returns false
 
       @transaction.eval_resource(@resource)
     end
 
     it "should eval and apply children" do
       @transaction.expects(:eval_children_and_apply_resource).with(@resource, nil)
 
       @transaction.eval_resource(@resource)
     end
 
     it "should process events" do
       @transaction.event_manager.expects(:process_events).with(@resource)
 
       @transaction.eval_resource(@resource)
     end
 
     describe "and the resource should be skipped" do
       before do
         @transaction.expects(:skip?).with(@resource).returns true
       end
 
       it "should mark the resource's status as skipped" do
         @transaction.eval_resource(@resource)
         @transaction.resource_status(@resource).should be_skipped
       end
     end
   end
 
   describe "when applying a resource" do
     before do
       @resource = Puppet::Type.type(:file).new :path => @basepath
       @status = Puppet::Resource::Status.new(@resource)
 
       @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
       @transaction.event_manager.stubs(:queue_events)
       @transaction.resource_harness.stubs(:evaluate).returns(@status)
     end
 
     it "should use its resource harness to apply the resource" do
       @transaction.resource_harness.expects(:evaluate).with(@resource)
       @transaction.apply(@resource)
     end
 
     it "should add the resulting resource status to its status list" do
       @transaction.apply(@resource)
       @transaction.resource_status(@resource).should be_instance_of(Puppet::Resource::Status)
     end
 
     it "should queue any events added to the resource status" do
       @status.expects(:events).returns %w{a b}
       @transaction.event_manager.expects(:queue_events).with(@resource, ["a", "b"])
       @transaction.apply(@resource)
     end
 
     it "should log and skip any resources that cannot be applied" do
       @transaction.resource_harness.expects(:evaluate).raises ArgumentError
       @resource.expects(:err)
       @transaction.apply(@resource)
       @transaction.report.resource_statuses[@resource.to_s].should be_nil
     end
   end
 
   describe "when generating resources" do
     it "should call 'generate' on all created resources" do
       first = Puppet::Type.type(:notify).new(:name => "first")
       second = Puppet::Type.type(:notify).new(:name => "second")
       third = Puppet::Type.type(:notify).new(:name => "third")
 
       @catalog = Puppet::Resource::Catalog.new
       @transaction = Puppet::Transaction.new(@catalog)
 
       first.expects(:generate).returns [second]
       second.expects(:generate).returns [third]
       third.expects(:generate)
 
       @transaction.generate_additional_resources(first, :generate)
     end
 
     it "should finish all resources" do
       generator = stub 'generator', :depthfirst? => true, :tags => []
       resource = stub 'resource', :tag => nil
 
       @catalog = Puppet::Resource::Catalog.new
       @transaction = Puppet::Transaction.new(@catalog)
 
       generator.expects(:generate).returns [resource]
 
       @catalog.expects(:add_resource).yields(resource)
 
       resource.expects(:finish)
 
       @transaction.generate_additional_resources(generator, :generate)
     end
 
     it "should skip generated resources that conflict with existing resources" do
       generator = mock 'generator', :tags => []
       resource = stub 'resource', :tag => nil
 
       @catalog = Puppet::Resource::Catalog.new
       @transaction = Puppet::Transaction.new(@catalog)
 
       generator.expects(:generate).returns [resource]
 
       @catalog.expects(:add_resource).raises(Puppet::Resource::Catalog::DuplicateResourceError.new("foo"))
 
       resource.expects(:finish).never
       resource.expects(:info) # log that it's skipped
 
       @transaction.generate_additional_resources(generator, :generate).should be_empty
     end
 
     it "should copy all tags to the newly generated resources" do
       child = stub 'child'
       generator = stub 'resource', :tags => ["one", "two"]
 
       @catalog = Puppet::Resource::Catalog.new
       @transaction = Puppet::Transaction.new(@catalog)
 
       generator.stubs(:generate).returns [child]
       @catalog.stubs(:add_resource)
 
       child.expects(:tag).with("one", "two")
+      child.expects(:finish)
+      generator.expects(:depthfirst?)
 
       @transaction.generate_additional_resources(generator, :generate)
     end
   end
 
   describe "when skipping a resource" do
     before :each do
       @resource = Puppet::Type.type(:notify).new :name => "foo"
       @catalog = Puppet::Resource::Catalog.new
       @resource.catalog = @catalog
       @transaction = Puppet::Transaction.new(@catalog)
     end
 
     it "should skip resource with missing tags" do
       @transaction.stubs(:missing_tags?).returns(true)
       @transaction.should be_skip(@resource)
     end
 
     it "should skip unscheduled resources" do
       @transaction.stubs(:scheduled?).returns(false)
       @transaction.should be_skip(@resource)
     end
 
     it "should skip resources with failed dependencies" do
       @transaction.stubs(:failed_dependencies?).returns(true)
       @transaction.should be_skip(@resource)
     end
 
     it "should skip virtual resource" do
       @resource.stubs(:virtual?).returns true
       @transaction.should be_skip(@resource)
     end
   end
 
   describe "when determining if tags are missing" do
     before :each do
       @resource = Puppet::Type.type(:notify).new :name => "foo"
       @catalog = Puppet::Resource::Catalog.new
       @resource.catalog = @catalog
       @transaction = Puppet::Transaction.new(@catalog)
 
       @transaction.stubs(:ignore_tags?).returns false
     end
 
     it "should not be missing tags if tags are being ignored" do
       @transaction.expects(:ignore_tags?).returns true
 
       @resource.expects(:tagged?).never
 
       @transaction.should_not be_missing_tags(@resource)
     end
 
     it "should not be missing tags if the transaction tags are empty" do
       @transaction.tags = []
       @resource.expects(:tagged?).never
       @transaction.should_not be_missing_tags(@resource)
     end
 
     it "should otherwise let the resource determine if it is missing tags" do
       tags = ['one', 'two']
       @transaction.tags = tags
       @resource.expects(:tagged?).with(*tags).returns(false)
       @transaction.should be_missing_tags(@resource)
     end
   end
 
   describe "when determining if a resource should be scheduled" do
     before :each do
       @resource = Puppet::Type.type(:notify).new :name => "foo"
       @catalog = Puppet::Resource::Catalog.new
       @resource.catalog = @catalog
       @transaction = Puppet::Transaction.new(@catalog)
     end
 
     it "should always schedule resources if 'ignoreschedules' is set" do
       @transaction.ignoreschedules = true
       @transaction.resource_harness.expects(:scheduled?).never
 
       @transaction.should be_scheduled(@resource)
     end
 
     it "should let the resource harness determine whether the resource should be scheduled" do
       @transaction.resource_harness.expects(:scheduled?).with(@transaction.resource_status(@resource), @resource).returns "feh"
 
       @transaction.scheduled?(@resource).should == "feh"
     end
   end
 
   describe "when prefetching" do
     it "should match resources by name, not title" do
       @catalog = Puppet::Resource::Catalog.new
       @transaction = Puppet::Transaction.new(@catalog)
 
       # Have both a title and name
       resource = Puppet::Type.type(:sshkey).create :title => "foo", :name => "bar", :type => :dsa, :key => "eh"
       @catalog.add_resource resource
 
       resource.provider.class.expects(:prefetch).with("bar" => resource)
 
       @transaction.prefetch
     end
   end
 
   it "should return all resources for which the resource status indicates the resource has changed when determinig changed resources" do
     @catalog = Puppet::Resource::Catalog.new
     @transaction = Puppet::Transaction.new(@catalog)
     names = []
     2.times do |i|
       name = File.join(@basepath, "file#{i}")
       resource = Puppet::Type.type(:file).new :path => name
       names << resource.to_s
       @catalog.add_resource resource
       @transaction.add_resource_status Puppet::Resource::Status.new(resource)
     end
 
     @transaction.resource_status(names[0]).changed = true
 
     @transaction.changed?.should == [@catalog.resource(names[0])]
   end
 
   describe 'when checking application run state' do
     before do
       without_warnings { Puppet::Application = Class.new(Puppet::Application) }
       @catalog = Puppet::Resource::Catalog.new
       @transaction = Puppet::Transaction.new(@catalog)
     end
 
     after do
       without_warnings { Puppet::Application = Puppet::Application.superclass }
     end
 
     it 'should return true for :stop_processing? if Puppet::Application.stop_requested? is true' do
       Puppet::Application.stubs(:stop_requested?).returns(true)
       @transaction.stop_processing?.should be_true
     end
 
     it 'should return false for :stop_processing? if Puppet::Application.stop_requested? is false' do
       Puppet::Application.stubs(:stop_requested?).returns(false)
       @transaction.stop_processing?.should be_false
     end
 
     describe 'within an evaluate call' do
       before do
         @resource = stub 'resource', :ref => 'some_ref'
         @catalog.add_resource @resource
         @transaction.stubs(:prepare)
-        @transaction.sorted_resources = [@resource]
+        @transaction.stubs(:visit_resources).yields(@resource)
       end
 
       it 'should stop processing if :stop_processing? is true' do
         @transaction.expects(:stop_processing?).returns(true)
         @transaction.expects(:eval_resource).never
         @transaction.evaluate
       end
 
       it 'should continue processing if :stop_processing? is false' do
         @transaction.expects(:stop_processing?).returns(false)
         @transaction.expects(:eval_resource).returns(nil)
         @transaction.evaluate
       end
     end
   end
 end
 
 describe Puppet::Transaction, " when determining tags" do
   before do
     @config = Puppet::Resource::Catalog.new
     @transaction = Puppet::Transaction.new(@config)
   end
 
   it "should default to the tags specified in the :tags setting" do
     Puppet.expects(:[]).with(:tags).returns("one")
     @transaction.tags.should == %w{one}
   end
 
   it "should split tags based on ','" do
     Puppet.expects(:[]).with(:tags).returns("one,two")
     @transaction.tags.should == %w{one two}
   end
 
   it "should use any tags set after creation" do
     Puppet.expects(:[]).with(:tags).never
     @transaction.tags = %w{one two}
     @transaction.tags.should == %w{one two}
   end
 
   it "should always convert assigned tags to an array" do
     @transaction.tags = "one::two"
     @transaction.tags.should == %w{one::two}
   end
 
   it "should accept a comma-delimited string" do
     @transaction.tags = "one, two"
     @transaction.tags.should == %w{one two}
   end
 
   it "should accept an empty string" do
     @transaction.tags = ""
     @transaction.tags.should == []
   end
 end