diff --git a/lib/puppet/node/catalog.rb b/lib/puppet/node/catalog.rb
index f885a41ee..ecda472be 100644
--- a/lib/puppet/node/catalog.rb
+++ b/lib/puppet/node/catalog.rb
@@ -1,512 +1,522 @@
 require 'puppet/indirector'
 require 'puppet/pgraph'
 require 'puppet/transaction'
 
 require 'puppet/util/tagging'
 
 # This class models a node catalog.  It is the thing
 # meant to be passed from server to client, and it contains all
 # of the information in the catalog, including the resources
 # and the relationships between them.
 class Puppet::Node::Catalog < Puppet::PGraph
     extend Puppet::Indirector
     indirects :catalog, :terminus_class => :compiler
 
     include Puppet::Util::Tagging
 
     # The host name this is a catalog for.
     attr_accessor :name
 
     # The catalog version.  Used for testing whether a catalog
     # is up to date.
     attr_accessor :version
 
     # How long this catalog took to retrieve.  Used for reporting stats.
     attr_accessor :retrieval_duration
 
     # How we should extract the catalog for sending to the client.
     attr_reader :extraction_format
 
     # We need the ability to set this externally, so we can yaml-dump the
     # catalog.
     attr_accessor :edgelist_class
 
     # Whether this is a host catalog, which behaves very differently.
     # In particular, reports are sent, graphs are made, and state is
     # stored in the state database.  If this is set incorrectly, then you often
     # end up in infinite loops, because catalogs are used to make things
     # that the host catalog needs.
     attr_accessor :host_config
 
     # Whether this graph is another catalog's relationship graph.
     # We don't want to accidentally create a relationship graph for another
     # relationship graph.
     attr_accessor :is_relationship_graph
 
     # Whether this catalog was retrieved from the cache, which affects
     # whether it is written back out again.
     attr_accessor :from_cache
 
     # Add classes to our class list.
     def add_class(*classes)
         classes.each do |klass|
             @classes << klass
         end
 
         # Add the class names as tags, too.
         tag(*classes)
     end
 
     # Add one or more resources to our graph and to our resource table.
     def add_resource(*resources)
         resources.each do |resource|
             unless resource.respond_to?(:ref)
                 raise ArgumentError, "Can only add objects that respond to :ref"
             end
 
             fail_unless_unique(resource)
 
             ref = resource.ref
 
             @resource_table[ref] = resource
 
             # If the name and title differ, set up an alias
             #self.alias(resource, resource.name) if resource.respond_to?(:name) and resource.respond_to?(:title) and resource.name != resource.title
             if resource.respond_to?(:name) and resource.respond_to?(:title) and resource.name != resource.title
                 self.alias(resource, resource.name) if resource.isomorphic?
             end
 
             resource.catalog = self if resource.respond_to?(:catalog=) and ! is_relationship_graph
 
             add_vertex(resource)
         end
     end
 
     # Create an alias for a resource.
     def alias(resource, name)
+        #set $1 
         resource.ref =~ /^(.+)\[/
 
         newref = "%s[%s]" % [$1 || resource.class.name, name]
         if existing = @resource_table[newref]
             return if existing == resource
             raise(ArgumentError, "Cannot alias %s to %s; resource %s already exists" % [resource.ref, name, newref])
         end
         @resource_table[newref] = resource
         @aliases[resource.ref] << newref
     end
 
     # Apply our catalog to the local host.  Valid options
     # are:
     #   :tags - set the tags that restrict what resources run
     #       during the transaction
     #   :ignoreschedules - tell the transaction to ignore schedules
     #       when determining the resources to run
     def apply(options = {})
         @applying = true
 
         Puppet::Util::Storage.load if host_config?
         transaction = Puppet::Transaction.new(self)
 
         transaction.tags = options[:tags] if options[:tags]
         transaction.ignoreschedules = true if options[:ignoreschedules]
 
         transaction.addtimes :config_retrieval => @retrieval_duration
 
 
         begin
             transaction.evaluate
         rescue Puppet::Error => detail
             Puppet.err "Could not apply complete catalog: %s" % detail
         rescue => detail
             puts detail.backtrace if Puppet[:trace]
             Puppet.err "Got an uncaught exception of type %s: %s" % [detail.class, detail]
         ensure
             # Don't try to store state unless we're a host config
             # too recursive.
             Puppet::Util::Storage.store if host_config?
         end
 
         yield transaction if block_given?
         
         transaction.send_report if host_config and (Puppet[:report] or Puppet[:summarize])
 
         return transaction
     ensure
         @applying = false
         cleanup()
         transaction.cleanup if defined? transaction and transaction
     end
 
     # Are we in the middle of applying the catalog?
     def applying?
         @applying
     end
     
     def clear(remove_resources = true)
         super()
         # We have to do this so that the resources clean themselves up.
         @resource_table.values.each { |resource| resource.remove } if remove_resources
         @resource_table.clear
 
         if defined?(@relationship_graph) and @relationship_graph
             @relationship_graph.clear(false)
             @relationship_graph = nil
         end
     end
 
     def classes
         @classes.dup
     end
 
     # Create an implicit resource, meaning that it will lose out
     # to any explicitly defined resources.  This method often returns
     # nil.
     #  The quirk of this method is that it's not possible to create
     # an implicit resource before an explicit resource of the same name,
     # because all explicit resources are created before any generate()
     # methods are called on the individual resources.  Thus, this
     # method can safely just check if an explicit resource already exists
     # and toss this implicit resource if so.
     def create_implicit_resource(type, options)
         unless options.include?(:implicit)
             options[:implicit] = true
         end
 
         # This will return nil if an equivalent explicit resource already exists.
         # When resource classes no longer retain references to resource instances,
         # this will need to be modified to catch that conflict and discard
         # implicit resources.
         if resource = create_resource(type, options)
             resource.implicit = true
 
             return resource
         else
             return nil
         end
     end
 
     # Create a new resource and register it in the catalog.
     def create_resource(type, options)
         unless klass = Puppet::Type.type(type)
             raise ArgumentError, "Unknown resource type %s" % type
         end
         return unless resource = klass.create(options)
 
         @transient_resources << resource if applying?
         add_resource(resource)
         if @relationship_graph
             @relationship_graph.add_resource(resource) unless @relationship_graph.resource(resource.ref)
         end
         resource
     end
 
     # Make sure we support the requested extraction format.
     def extraction_format=(value)
         unless respond_to?("extract_to_%s" % value)
             raise ArgumentError, "Invalid extraction format %s" % value
         end
         @extraction_format = value
     end
 
     # Turn our catalog graph into whatever the client is expecting.
     def extract
         send("extract_to_%s" % extraction_format)
     end
 
     # Create the traditional TransBuckets and TransObjects from our catalog
     # graph.  This will hopefully be deprecated soon.
     def extract_to_transportable
         top = nil
         current = nil
         buckets = {}
 
         unless main = vertices.find { |res| res.type == "Class" and res.title == :main }
             raise Puppet::DevError, "Could not find 'main' class; cannot generate catalog"
         end
 
         # Create a proc for examining edges, which we'll use to build our tree
         # of TransBuckets and TransObjects.
         bucket = nil
         walk(main, :out) do |source, target|
             # The sources are always non-builtins.
             unless tmp = buckets[source.to_s]
                 if tmp = buckets[source.to_s] = source.to_trans
                     bucket = tmp
                 else
                     # This is because virtual resources return nil.  If a virtual
                     # container resource contains realized resources, we still need to get
                     # to them.  So, we keep a reference to the last valid bucket
                     # we returned and use that if the container resource is virtual.
                 end
             end
             bucket = tmp || bucket
             if child = target.to_trans
                 unless bucket
                     raise "No bucket created for %s" % source
                 end
                 bucket.push child
 
                 # It's important that we keep a reference to any TransBuckets we've created, so
                 # we don't create multiple buckets for children.
                 unless target.builtin?
                     buckets[target.to_s] = child
                 end
             end
         end
 
         # Retrieve the bucket for the top-level scope and set the appropriate metadata.
         unless result = buckets[main.to_s]
             # This only happens when the catalog is entirely empty.
             result = buckets[main.to_s] = main.to_trans
         end
 
         result.classes = classes
 
         # Clear the cache to encourage the GC
         buckets.clear
         return result
     end
 
     # Make sure all of our resources are "finished".
     def finalize
         make_default_resources
 
         @resource_table.values.each { |resource| resource.finish }
         
         write_graph(:resources)
     end
 
     def host_config?
         host_config || false
     end
 
     def initialize(name = nil)
         super()
         @name = name if name
         @extraction_format ||= :transportable
         @classes = []
         @resource_table = {}
         @transient_resources = []
         @applying = false
         @relationship_graph = nil
 
         @aliases = Hash.new { |hash, key| hash[key] = [] }
 
         if block_given?
             yield(self)
             finalize()
         end
     end
 
     # Make the default objects necessary for function.
     def make_default_resources
         # We have to add the resources to the catalog, or else they won't get cleaned up after
         # the transaction.
 
         # First create the default scheduling objects
         Puppet::Type.type(:schedule).mkdefaultschedules.each { |res| add_resource(res) unless resource(res.ref) }
         
         # And filebuckets
         if bucket = Puppet::Type.type(:filebucket).mkdefaultbucket
             add_resource(bucket)
         end
     end
     
     # Create a graph of all of the relationships in our catalog.
     def relationship_graph
         raise(Puppet::DevError, "Tried get a relationship graph for a relationship graph") if self.is_relationship_graph
 
         unless defined? @relationship_graph and @relationship_graph
             # It's important that we assign the graph immediately, because
             # the debug messages below use the relationships in the
             # relationship graph to determine the path to the resources
             # spitting out the messages.  If this is not set,
             # then we get into an infinite loop.
             @relationship_graph = Puppet::Node::Catalog.new
             @relationship_graph.host_config = host_config?
             @relationship_graph.is_relationship_graph = true
             
             # First create the dependency graph
             self.vertices.each do |vertex|
                 @relationship_graph.add_vertex vertex
                 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.each do |edge|
                     unless @relationship_graph.edge?(edge.source, edge.target) # don't let automatic relationships conflict with manual ones.
                         unless @relationship_graph.edge?(edge.target, edge.source)
                             vertex.debug "Autorequiring %s" % [edge.source]
                             @relationship_graph.add_edge(edge)
                         else
                             vertex.debug "Skipping automatic relationship with %s" % (edge.source == vertex ? edge.target : edge.source)
                         end
                     end
                 end
             end
             
             @relationship_graph.write_graph(:relationships)
             
             # Then splice in the container information
             @relationship_graph.splice!(self, Puppet::Type::Component)
 
             @relationship_graph.write_graph(:expanded_relationships)
         end
         @relationship_graph
     end
 
     # Remove the resource from our catalog.  Notice that we also call
     # 'remove' on the resource, at least until resource classes no longer maintain
     # references to the resource instances.
     def remove_resource(*resources)
         resources.each do |resource|
             @resource_table.delete(resource.ref)
             @aliases[resource.ref].each { |res_alias| @resource_table.delete(res_alias) }
             @aliases[resource.ref].clear
             remove_vertex!(resource) if vertex?(resource)
             @relationship_graph.remove_vertex!(resource) if @relationship_graph and @relationship_graph.vertex?(resource)
             resource.remove
         end
     end
 
     # Look a resource up by its reference (e.g., File[/etc/passwd]).
     def resource(type, title = nil)
         # Always create a resource reference, so that it always canonizes how we
         # are referring to them.
         if title
             ref = Puppet::ResourceReference.new(type, title).to_s
         else
             # If they didn't provide a title, then we expect the first
             # argument to be of the form 'Class[name]', which our
             # Reference class canonizes for us.
             ref = Puppet::ResourceReference.new(nil, type).to_s
         end
         if resource = @resource_table[ref]
             return resource
         elsif defined?(@relationship_graph) and @relationship_graph
             @relationship_graph.resource(ref)
         end
     end
 
     # Return an array of all resources.
     def resources
         @resource_table.keys
     end
 
     # Convert our catalog into a RAL catalog.
     def to_ral
         to_catalog :to_type
     end
 
     # Turn our parser catalog into a transportable catalog.
     def to_transportable
         to_catalog :to_transobject
     end
 
     # Produce the graph files if requested.
     def write_graph(name)
         # We only want to graph the main host catalog.
         return unless host_config?
         
         return unless Puppet[:graph]
 
         Puppet.settings.use(:graphing)
 
         file = File.join(Puppet[:graphdir], "%s.dot" % name.to_s)
         File.open(file, "w") { |f|
             f.puts to_dot("name" => name.to_s.capitalize)
         }
     end
 
     # LAK:NOTE We cannot yaml-dump the class in the edgelist_class, because classes cannot be
     # dumped by default, nor does yaml-dumping # the edge-labels work at this point (I don't
     # know why).
     #  Neither of these matters right now, but I suppose it could at some point.
     # We also have to have the vertex_dict dumped after the resource table, because yaml can't
     # seem to handle the output of yaml-dumping the vertex_dict.
     def to_yaml_properties
         props = instance_variables.reject { |v| %w{@edgelist_class @edge_labels @vertex_dict}.include?(v) }
         props << "@vertex_dict"
         props
     end
 
     private
 
     def cleanup
         unless @transient_resources.empty?
             remove_resource(*@transient_resources)
             @transient_resources.clear
             @relationship_graph = nil
         end
     end
 
     # Verify that the given resource isn't defined elsewhere.
     def fail_unless_unique(resource)
         # Short-curcuit the common case, 
         return unless existing_resource = @resource_table[resource.ref]
 
         # Either it's a defined type, which are never
         # isomorphic, or it's a non-isomorphic type, so
         # we should throw an exception.
         msg = "Duplicate definition: %s is already defined" % resource.ref
 
         if existing_resource.file and existing_resource.line
             msg << " in file %s at line %s" %
                 [existing_resource.file, existing_resource.line]
         end
 
         if resource.line or resource.file
             msg << "; cannot redefine"
         end
 
         raise ArgumentError.new(msg)
     end
 
     # An abstracted method for converting one catalog into another type of catalog.
     # This pretty much just converts all of the resources from one class to another, using
     # a conversion method.
     def to_catalog(convert)
         result = self.class.new(self.name)
 
         map = {}
         vertices.each do |resource|
             next if resource.respond_to?(:virtual?) and resource.virtual?
 
+            #This is hackity hack for 1094
+            #Aliases aren't working in the ral catalog because the current instance of the resource
+            #has a reference to the catalog being converted. . . So, give it a reference to the new one
+            #problem solved. . .
+            if resource.is_a?(Puppet::TransObject)
+                resource = resource.dup
+                resource.catalog = result
+            end
+
             newres = resource.send(convert)
 
             # We can't guarantee that resources don't munge their names
             # (like files do with trailing slashes), so we have to keep track
             # of what a resource got converted to.
             map[resource.ref] = newres
 
             result.add_resource newres
         end
 
         message = convert.to_s.gsub "_", " "
         edges.each do |edge|
             # Skip edges between virtual resources.
             next if edge.source.respond_to?(:virtual?) and edge.source.virtual?
             next if edge.target.respond_to?(:virtual?) and edge.target.virtual?
 
             unless source = map[edge.source.ref]
                 raise Puppet::DevError, "Could not find resource %s when converting %s resources" % [edge.source.ref, message]
             end
 
             unless target = map[edge.target.ref]
                 raise Puppet::DevError, "Could not find resource %s when converting %s resources" % [edge.target.ref, message]
             end
 
             result.add_edge(source, target, edge.label)
         end
 
         map.clear
 
         result.add_class(*self.classes)
         result.tag(*self.tags)
 
         return result
     end
 end
diff --git a/lib/puppet/util/settings.rb b/lib/puppet/util/settings.rb
index 259e2045b..6e0b4b66d 100644
--- a/lib/puppet/util/settings.rb
+++ b/lib/puppet/util/settings.rb
@@ -1,1245 +1,1245 @@
 require 'puppet'
 require 'sync'
 require 'puppet/transportable'
 require 'getoptlong'
 
 
 # The class for handling configuration files.
 class Puppet::Util::Settings
     include Enumerable
     include Puppet::Util
 
     @@sync = Sync.new
 
     attr_accessor :file
     attr_reader :timer
 
     # Retrieve a config value
     def [](param)
         value(param)
     end
 
     # Set a config value.  This doesn't set the defaults, it sets the value itself.
     def []=(param, value)
         @@sync.synchronize do # yay, thread-safe
             param = symbolize(param)
             unless element = @config[param]
                 raise ArgumentError,
                     "Attempt to assign a value to unknown configuration parameter %s" % param.inspect
             end
             if element.respond_to?(:munge)
                 value = element.munge(value)
             end
             if element.respond_to?(:handle)
                 element.handle(value)
             end
             # Reset the name, so it's looked up again.
             if param == :name
                 @name = nil
             end
             @values[:memory][param] = value
             @cache.clear
         end
 
         return value
     end
 
     # A simplified equality operator.
     # LAK: For some reason, this causes mocha to not be able to mock
     # the 'value' method, and it's not used anywhere.
 #    def ==(other)
 #        self.each { |myname, myobj|
 #            unless other[myname] == value(myname)
 #                return false
 #            end
 #        }
 #
 #        return true
 #    end
 
     # Generate the list of valid arguments, in a format that GetoptLong can
     # understand, and add them to the passed option list.
     def addargs(options)
         # Hackish, but acceptable.  Copy the current ARGV for restarting.
         Puppet.args = ARGV.dup
 
         # Add all of the config parameters as valid options.
         self.each { |name, element|
             element.getopt_args.each { |args| options << args }
         }
 
         return options
     end
 
     # Turn the config into a Puppet configuration and apply it
     def apply
         trans = self.to_transportable
         begin
             config = trans.to_catalog
             config.store_state = false
             config.apply
             config.clear
         rescue => detail
             if Puppet[:trace]
                 puts detail.backtrace
             end
             Puppet.err "Could not configure myself: %s" % detail
         end
     end
 
     # Is our parameter a boolean parameter?
     def boolean?(param)
         param = symbolize(param)
         if @config.include?(param) and @config[param].kind_of? CBoolean
             return true
         else
             return false
         end
     end
 
     # Remove all set values, potentially skipping cli values.
     def clear(exceptcli = false)
         @config.each { |name, obj|
             unless exceptcli and obj.setbycli
                 obj.clear
             end
         }
         @values.each do |name, values|
             next if name == :cli and exceptcli
             @values.delete(name) 
         end
 
         # Don't clear the 'used' in this case, since it's a config file reparse,
         # and we want to retain this info.
         unless exceptcli
             @used = []
         end
 
         @cache.clear
 
         @name = nil
     end
 
     # This is mostly just used for testing.
     def clearused
         @cache.clear
         @used = []
     end
 
     # Do variable interpolation on the value.
     def convert(value)
         return value unless value
         return value unless value.is_a? String
         newval = value.gsub(/\$(\w+)|\$\{(\w+)\}/) do |value|
             varname = $2 || $1
             if pval = self.value(varname)
                 pval
             else
                 raise Puppet::DevError, "Could not find value for %s" % parent
             end
         end
 
         return newval
     end
 
     # Return a value's description.
     def description(name)
         if obj = @config[symbolize(name)]
             obj.desc
         else
             nil
         end
     end
 
     def each
         @config.each { |name, object|
             yield name, object
         }
     end
 
     # Iterate over each section name.
     def eachsection
         yielded = []
         @config.each do |name, object|
             section = object.section
             unless yielded.include? section
                 yield section
                 yielded << section
             end
         end
     end
 
     # Return an object by name.
     def element(param)
         param = symbolize(param)
         @config[param]
     end
 
     # Handle a command-line argument.
     def handlearg(opt, value = nil)
         @cache.clear
         value = munge_value(value) if value
         str = opt.sub(/^--/,'')
         bool = true
         newstr = str.sub(/^no-/, '')
         if newstr != str
             str = newstr
             bool = false
         end
         str = str.intern
         if self.valid?(str)
             if self.boolean?(str)
                 @values[:cli][str] = bool
             else
                 @values[:cli][str] = value
             end
         else
             raise ArgumentError, "Invalid argument %s" % opt
         end
     end
 
     def include?(name)
         name = name.intern if name.is_a? String
         @config.include?(name)
     end
 
     # check to see if a short name is already defined
     def shortinclude?(short)
         short = short.intern if name.is_a? String
         @shortnames.include?(short)
     end
 
     # Create a new config object
     def initialize
         @config = {}
         @shortnames = {}
 
         @created = []
         @searchpath = nil
 
         # Keep track of set values.
         @values = Hash.new { |hash, key| hash[key] = {} }
 
         # And keep a per-environment cache
         @cache = Hash.new { |hash, key| hash[key] = {} }
 
         # A central concept of a name.
         @name = nil
     end
 
     # Return a given object's file metadata.
     def metadata(param)
         if obj = @config[symbolize(param)] and obj.is_a?(CFile)
             return [:owner, :group, :mode].inject({}) do |meta, p|
                 if v = obj.send(p)
                     meta[p] = v
                 end
                 meta
             end
         else
             nil
         end
     end
 
     # Make a directory with the appropriate user, group, and mode
     def mkdir(default)
-        obj = get_config_default(default)
+        obj = get_config_file_default(default)
 
         Puppet::Util::SUIDManager.asuser(obj.owner, obj.group) do
             mode = obj.mode || 0750
             Dir.mkdir(obj.value, mode)
         end
     end
 
     # Figure out our name.
     def name
         unless @name
             unless @config[:name]
                 return nil
             end
             searchpath.each do |source|
                 next if source == :name
                 break if @name = @values[source][:name]
             end
             unless @name
                 @name = convert(@config[:name].default).intern
             end
         end
         @name
     end
 
     # Return all of the parameters associated with a given section.
     def params(section = nil)
         if section
             section = section.intern if section.is_a? String
             @config.find_all { |name, obj|
                 obj.section == section
             }.collect { |name, obj|
                 name
             }
         else
             @config.keys
         end
     end
 
     # Parse the configuration file.
     def parse(file)
         clear(true)
 
         parse_file(file).each do |area, values|
             @values[area] = values
         end
 
         # Determine our environment, if we have one.
         if @config[:environment]
             env = self.value(:environment).to_sym
         else
             env = "none"
         end
 
         # Call any hooks we should be calling.
         settings_with_hooks.each do |setting|
             each_source(env) do |source|
                 if value = @values[source][setting.name]
                     # We still have to use value() to retrieve the value, since
                     # we want the fully interpolated value, not $vardir/lib or whatever.
                     # This results in extra work, but so few of the settings
                     # will have associated hooks that it ends up being less work this
                     # way overall.
                     setting.handle(self.value(setting.name, env))
                     break
                 end
             end
         end
 
         # We have to do it in the reverse of the search path,
         # because multiple sections could set the same value
         # and I'm too lazy to only set the metadata once.
         searchpath.reverse.each do |source|
             if meta = @values[source][:_meta]
                 set_metadata(meta)
             end
         end
     end
 
     # Parse the configuration file.  As of May 2007, this is a backward-compatibility method and
     # will be deprecated soon.
     def old_parse(file)
         text = nil
 
         if file.is_a? Puppet::Util::LoadedFile
             @file = file
         else
             @file = Puppet::Util::LoadedFile.new(file)
         end
 
         # Don't create a timer for the old style parsing.
         # settimer()
 
         begin
             text = File.read(@file.file)
         rescue Errno::ENOENT
             raise Puppet::Error, "No such file %s" % file
         rescue Errno::EACCES
             raise Puppet::Error, "Permission denied to file %s" % file
         end
 
         @values = Hash.new { |names, name|
             names[name] = {}
         }
 
         # Get rid of the values set by the file, keeping cli values.
         self.clear(true)
 
         section = "puppet"
         metas = %w{owner group mode}
         values = Hash.new { |hash, key| hash[key] = {} }
         text.split(/\n/).each { |line|
             case line
             when /^\[(\w+)\]$/: section = $1 # Section names
             when /^\s*#/: next # Skip comments
             when /^\s*$/: next # Skip blanks
             when /^\s*(\w+)\s*=\s*(.+)$/: # settings
                 var = $1.intern
                 if var == :mode
                     value = $2
                 else
                     value = munge_value($2)
                 end
 
                 # Only warn if we don't know what this config var is.  This
                 # prevents exceptions later on.
                 unless @config.include?(var) or metas.include?(var.to_s)
                     Puppet.warning "Discarded unknown configuration parameter %s" % var.inspect
                     next # Skip this line.
                 end
 
                 # Mmm, "special" attributes
                 if metas.include?(var.to_s)
                     unless values.include?(section)
                         values[section] = {}
                     end
                     values[section][var.to_s] = value
 
                     # If the parameter is valid, then set it.
                     if section == Puppet[:name] and @config.include?(var)
                         #@config[var].value = value
                         @values[:main][var] = value
                     end
                     next
                 end
 
                 # Don't override set parameters, since the file is parsed
                 # after cli arguments are handled.
                 unless @config.include?(var) and @config[var].setbycli
                     Puppet.debug "%s: Setting %s to '%s'" % [section, var, value]
                     @values[:main][var] = value
                 end
                 @config[var].section = symbolize(section)
 
                 metas.each { |meta|
                     if values[section][meta]
                         if @config[var].respond_to?(meta + "=")
                             @config[var].send(meta + "=", values[section][meta])
                         end
                     end
                 }
             else
                 raise Puppet::Error, "Could not match line %s" % line
             end
         }
     end
 
     # Create a new element.  The value is passed in because it's used to determine
     # what kind of element we're creating, but the value itself might be either
     # a default or a value, so we can't actually assign it.
     def newelement(hash)
         value = hash[:value] || hash[:default]
         klass = nil
         if hash[:section]
             hash[:section] = symbolize(hash[:section])
         end
         case value
         when true, false, "true", "false":
             klass = CBoolean
         when /^\$\w+\//, /^\//:
             klass = CFile
         when String, Integer, Float: # nothing
             klass = CElement
         else
             raise Puppet::Error, "Invalid value '%s' for %s" % [value.inspect, hash[:name]]
         end
         hash[:parent] = self
         element = klass.new(hash)
 
         return element
     end
 
     # This has to be private, because it doesn't add the elements to @config
     private :newelement
 
     # Iterate across all of the objects in a given section.
     def persection(section)
         section = symbolize(section)
         self.each { |name, obj|
             if obj.section == section
                 yield obj
             end
         }
     end
 
     # Reparse our config file, if necessary.
     def reparse
         if defined? @file and @file.changed?
             Puppet.notice "Reparsing %s" % @file.file
             @@sync.synchronize do
                 parse(@file)
             end
             reuse()
         end
     end
 
     def reuse
         return unless defined? @used
         @@sync.synchronize do # yay, thread-safe
             @used.each do |section|
                 @used.delete(section)
                 self.use(section)
             end
         end
     end
 
     # The order in which to search for values.
     def searchpath(environment = nil)
         if environment
             [:cli, :memory, environment, :name, :main]
         else
             [:cli, :memory, :name, :main]
         end
     end
 
     # Get a list of objects per section
     def sectionlist
         sectionlist = []
         self.each { |name, obj|
             section = obj.section || "puppet"
             sections[section] ||= []
             unless sectionlist.include?(section)
                 sectionlist << section
             end
             sections[section] << obj
         }
 
         return sectionlist, sections
     end
 
     # Convert a single section into transportable objects.
     def section_to_transportable(section, done = nil)
         done ||= Hash.new { |hash, key| hash[key] = {} }
         objects = []
         persection(section) do |obj|
             if @config[:mkusers] and value(:mkusers)
                 objects += add_user_resources(section, obj, done)
             end
 
             value = obj.value
 
             # Only files are convertable to transportable resources.
             next unless obj.respond_to? :to_transportable and transobjects = obj.to_transportable
 
             transobjects = [transobjects] unless transobjects.is_a? Array
             transobjects.each do |trans|
                 # transportable could return nil
                 next unless trans
                 unless done[:file].include? trans.name
                     @created << trans.name
                     objects << trans
                     done[:file][trans.name] = trans
                 end
             end
         end
 
         bucket = Puppet::TransBucket.new
         bucket.type = "Settings"
         bucket.name = section
         bucket.push(*objects)
         bucket.keyword = "class"
 
         return bucket
     end
 
     # Set a bunch of defaults in a given section.  The sections are actually pretty
     # pointless, but they help break things up a bit, anyway.
     def setdefaults(section, defs)
         section = symbolize(section)
         call = []
         defs.each { |name, hash|
             if hash.is_a? Array
                 unless hash.length == 2
                     raise ArgumentError, "Defaults specified as an array must contain only the default value and the decription"
                 end
                 tmp = hash
                 hash = {}
                 [:default, :desc].zip(tmp).each { |p,v| hash[p] = v }
             end
             name = symbolize(name)
             hash[:name] = name
             hash[:section] = section
             name = hash[:name]
             if @config.include?(name)
                 raise ArgumentError, "Parameter %s is already defined" % name
             end
             tryconfig = newelement(hash)
             if short = tryconfig.short
                 if other = @shortnames[short]
                     raise ArgumentError, "Parameter %s is already using short name '%s'" % [other.name, short]
                 end
                 @shortnames[short] = tryconfig
             end
             @config[name] = tryconfig
 
             # Collect the settings that need to have their hooks called immediately.
             # We have to collect them so that we can be sure we're fully initialized before
             # the hook is called.
             call << tryconfig if tryconfig.call_on_define
         }
 
         call.each { |setting| setting.handle(self.value(setting.name)) }
     end
 
     # Create a timer to check whether the file should be reparsed.
     def settimer
         if Puppet[:filetimeout] > 0
             @timer = Puppet.newtimer(
                 :interval => Puppet[:filetimeout],
                 :tolerance => 1,
                 :start? => true
             ) do
                 self.reparse()
             end
         end
     end
 
     # Convert our list of objects into a component that can be applied.
     def to_configuration
         transport = self.to_transportable
         return transport.to_catalog
     end
 
     # Convert our list of config elements into a configuration file.
     def to_config
         str = %{The configuration file for #{Puppet[:name]}.  Note that this file
 is likely to have unused configuration parameters in it; any parameter that's
 valid anywhere in Puppet can be in any config file, even if it's not used.
 
 Every section can specify three special parameters: owner, group, and mode.
 These parameters affect the required permissions of any files specified after
 their specification.  Puppet will sometimes use these parameters to check its
 own configured state, so they can be used to make Puppet a bit more self-managing.
 
 Note also that the section names are entirely for human-level organizational
 purposes; they don't provide separate namespaces.  All parameters are in a
 single namespace.
 
 Generated on #{Time.now}.
 
 }.gsub(/^/, "# ")
 
         # Add a section heading that matches our name.
         if @config.include?(:name)
             str += "[%s]\n" % self[:name]
         end
         eachsection do |section|
             persection(section) do |obj|
                 str += obj.to_config + "\n"
             end
         end
 
         return str
     end
 
     # Convert our configuration into a list of transportable objects.
     def to_transportable(*sections)
         done = Hash.new { |hash, key|
             hash[key] = {}
         }
 
         topbucket = Puppet::TransBucket.new
         if defined? @file.file and @file.file
             topbucket.name = @file.file
         else
             topbucket.name = "top"
         end
         topbucket.type = "Settings"
         topbucket.top = true
 
         # Now iterate over each section
         if sections.empty?
             eachsection do |section|
                 sections << section
             end
         end
         sections.each do |section|
             obj = section_to_transportable(section, done)
             topbucket.push obj
         end
 
         topbucket
     end
 
     # Convert to a parseable manifest
     def to_manifest
         transport = self.to_transportable
 
         manifest = transport.to_manifest + "\n"
         eachsection { |section|
             manifest += "include #{section}\n"
         }
 
         return manifest
     end
 
     # Create the necessary objects to use a section.  This is idempotent;
     # you can 'use' a section as many times as you want.
     def use(*sections)
         @@sync.synchronize do # yay, thread-safe
             unless defined? @used
                 @used = []
             end
 
             bucket = to_transportable(*sections)
 
             config = bucket.to_catalog
             config.host_config = false
             config.apply do |transaction|
                 if failures = transaction.any_failed?
                     raise "Could not configure for running; got %s failure(s)" % failures
                 end
             end
             config.clear
 
             sections.each { |s| @used << s }
             @used.uniq
         end
     end
 
     def valid?(param)
         param = symbolize(param)
         @config.has_key?(param)
     end
 
     # Find the correct value using our search path.  Optionally accept an environment
     # in which to search before the other configuration sections.
     def value(param, environment = nil)
         param = symbolize(param)
         environment = symbolize(environment) if environment
 
         # Short circuit to nil for undefined parameters.
         return nil unless @config.include?(param)
 
         # Yay, recursion.
         self.reparse() unless param == :filetimeout
 
         # Check the cache first.  It needs to be a per-environment
         # cache so that we don't spread values from one env
         # to another.
         if cached = @cache[environment||"none"][param]
             return cached
         end
 
         # See if we can find it within our searchable list of values
         val = nil
         each_source(environment) do |source|
             # Look for the value.  We have to test the hash for whether
             # it exists, because the value might be false.
             if @values[source].include?(param)
                 val = @values[source][param]
                 break
             end
         end
 
         # If we didn't get a value, use the default
         val = @config[param].default if val.nil?
 
         # Convert it if necessary
         val = convert(val)
 
         # And cache it
         @cache[environment||"none"][param] = val
         return val
     end
 
     # Open a file with the appropriate user, group, and mode
     def write(default, *args, &bloc)
-        obj = get_config_default(default)
+        obj = get_config_file_default(default)
         writesub(default, value(obj.name), *args, &bloc)
     end
 
     # Open a non-default file under a default dir with the appropriate user,
     # group, and mode
     def writesub(default, file, *args, &bloc)
-        obj = get_config_default(default)
+        obj = get_config_file_default(default)
         chown = nil
         if Puppet::Util::SUIDManager.uid == 0
             chown = [obj.owner, obj.group]
         else
             chown = [nil, nil]
         end
 
         Puppet::Util::SUIDManager.asuser(*chown) do
             mode = obj.mode || 0640
             if args.empty?
                 args << "w"
             end
 
             args << mode
 
             # Update the umask to make non-executable files
             Puppet::Util.withumask(File.umask ^ 0111) do
                 File.open(file, *args) do |file|
                     yield file
                 end
             end
         end
     end
 
     def readwritelock(default, *args, &bloc)
-        file = value(get_config_default(default).name)
+        file = value(get_config_file_default(default).name)
         tmpfile = file + ".tmp"
         sync = Sync.new
         unless FileTest.directory?(File.dirname(tmpfile))
             raise Puppet::DevError, "Cannot create %s; directory %s does not exist" %
                 [file, File.dirname(file)]
         end
 
         sync.synchronize(Sync::EX) do
             File.open(file, "r+", 0600) do |rf|
                 rf.lock_exclusive do
                     if File.exist?(tmpfile)
                         raise Puppet::Error, ".tmp file already exists for %s; Aborting locked write. Check the .tmp file and delete if appropriate" %
                             [file]
                     end
 
                     writesub(default, tmpfile, *args, &bloc)
 
                     begin
                         File.rename(tmpfile, file)
                     rescue => detail
                         Puppet.err "Could not rename %s to %s: %s" %
                             [file, tmpfile, detail]
                     end
                 end
             end
         end
     end
 
     private
 
-    def get_config_default(default)
+    def get_config_file_default(default)
         obj = nil
         unless obj = @config[default]
             raise ArgumentError, "Unknown default %s" % default
         end
 
         unless obj.is_a? CFile
             raise ArgumentError, "Default %s is not a file" % default
         end
 
         return obj
     end
     
     # Create the transportable objects for users and groups.
     def add_user_resources(section, obj, done)
         resources = []
         [:owner, :group].each do |attr|
             type = nil
             if attr == :owner
                 type = :user
             else
                 type = attr
             end
             # If a user and/or group is set, then make sure we're
             # managing that object
             if obj.respond_to? attr and name = obj.send(attr)
                 # Skip root or wheel
                 next if %w{root wheel}.include?(name.to_s)
 
                 # Skip owners and groups we've already done, but tag
                 # them with our section if necessary
                 if done[type].include?(name)
                     tags = done[type][name].tags
                     unless tags.include?(section)
                         done[type][name].tags = tags << section
                     end
                 else
                     newobj = Puppet::TransObject.new(name, type.to_s)
                     newobj.tags = ["puppet", "configuration", section]
                     newobj[:ensure] = :present
                     if type == :user
                         newobj[:comment] ||= "%s user" % name
                     end
                     # Set the group appropriately for the user
                     if type == :user
                         newobj[:gid] = Puppet[:group]
                     end
                     done[type][name] = newobj
                     resources << newobj
                 end
             end
         end
         resources
     end
 
     # Yield each search source in turn.
     def each_source(environment)
         searchpath(environment).each do |source|
             # Modify the source as necessary.
             source = self.name if source == :name
             yield source
         end
     end
 
     # Return all elements that have associated hooks; this is so
     # we can call them after parsing the configuration file.
     def settings_with_hooks
         @config.values.find_all { |setting| setting.respond_to?(:handle) }
     end
 
     # Extract extra setting information for files.
     def extract_fileinfo(string)
         result = {}
         value = string.sub(/\{\s*([^}]+)\s*\}/) do
             params = $1
             params.split(/\s*,\s*/).each do |str|
                 if str =~ /^\s*(\w+)\s*=\s*([\w\d]+)\s*$/
                     param, value = $1.intern, $2
                     result[param] = value
                     unless [:owner, :mode, :group].include?(param)
                         raise ArgumentError, "Invalid file option '%s'" % param
                     end
 
                     if param == :mode and value !~ /^\d+$/
                         raise ArgumentError, "File modes must be numbers"
                     end
                 else
                     raise ArgumentError, "Could not parse '%s'" % string
                 end
             end
             ''
         end
         result[:value] = value.sub(/\s*$/, '')
         return result
 
         return nil
     end
 
     # Convert arguments into booleans, integers, or whatever.
     def munge_value(value)
         # Handle different data types correctly
         return case value
             when /^false$/i: false
             when /^true$/i: true
             when /^\d+$/i: Integer(value)
             else
                 value.gsub(/^["']|["']$/,'').sub(/\s+$/, '')
         end
     end
 
     # This is an abstract method that just turns a file in to a hash of hashes.
     # We mostly need this for backward compatibility -- as of May 2007 we need to
     # support parsing old files with any section, or new files with just two
     # valid sections.
     def parse_file(file)
         text = read_file(file)
 
         # Create a timer so that this file will get checked automatically
         # and reparsed if necessary.
         settimer()
 
         result = Hash.new { |names, name|
             names[name] = {}
         }
 
         count = 0
 
         # Default to 'main' for the section.
         section = :main
         result[section][:_meta] = {}
         text.split(/\n/).each { |line|
             count += 1
             case line
             when /^\s*\[(\w+)\]$/:
                 section = $1.intern # Section names
                 # Add a meta section
                 result[section][:_meta] ||= {}
             when /^\s*#/: next # Skip comments
             when /^\s*$/: next # Skip blanks
             when /^\s*(\w+)\s*=\s*(.*)$/: # settings
                 var = $1.intern
 
                 # We don't want to munge modes, because they're specified in octal, so we'll
                 # just leave them as a String, since Puppet handles that case correctly.
                 if var == :mode
                     value = $2
                 else
                     value = munge_value($2)
                 end
 
                 # Check to see if this is a file argument and it has extra options
                 begin
                     if value.is_a?(String) and options = extract_fileinfo(value)
                         value = options[:value]
                         options.delete(:value)
                         result[section][:_meta][var] = options
                     end
                     result[section][var] = value
                 rescue Puppet::Error => detail
                     detail.file = file
                     detail.line = line
                     raise
                 end
             else
                 error = Puppet::Error.new("Could not match line %s" % line)
                 error.file = file
                 error.line = line
                 raise error
             end
         }
 
         return result
     end
 
     # Read the file in.
     def read_file(file)
         if file.is_a? Puppet::Util::LoadedFile
             @file = file
         else
             @file = Puppet::Util::LoadedFile.new(file)
         end
 
         begin
             return File.read(@file.file)
         rescue Errno::ENOENT
             raise ArgumentError, "No such file %s" % file
         rescue Errno::EACCES
             raise ArgumentError, "Permission denied to file %s" % file
         end
     end
 
     # Set file metadata.
     def set_metadata(meta)
         meta.each do |var, values|
             values.each do |param, value|
                 @config[var].send(param.to_s + "=", value)
             end
         end
     end
 
     # The base element type.
     class CElement
         attr_accessor :name, :section, :default, :parent, :setbycli, :call_on_define
         attr_reader :desc, :short
 
         # Unset any set value.
         def clear
             @value = nil
         end
 
         def desc=(value)
             @desc = value.gsub(/^\s*/, '')
         end
 
         # get the arguments in getopt format
         def getopt_args
             if short
                 [["--#{name}", "-#{short}", GetoptLong::REQUIRED_ARGUMENT]]
             else
                 [["--#{name}", GetoptLong::REQUIRED_ARGUMENT]]
             end
         end
 
         def hook=(block)
             meta_def :handle, &block
         end
 
         # Create the new element.  Pretty much just sets the name.
         def initialize(args = {})
             if args.include?(:parent)
                 self.parent = args[:parent]
                 args.delete(:parent)
             end
             args.each do |param, value|
                 method = param.to_s + "="
                 unless self.respond_to? method
                     raise ArgumentError, "%s does not accept %s" % [self.class, param]
                 end
 
                 self.send(method, value)
             end
 
             unless self.desc
                 raise ArgumentError, "You must provide a description for the %s config option" % self.name
             end
         end
 
         def iscreated
             @iscreated = true
         end
 
         def iscreated?
             if defined? @iscreated
                 return @iscreated
             else
                 return false
             end
         end
 
         def set?
             if defined? @value and ! @value.nil?
                 return true
             else
                 return false
             end
         end
 
         # short name for the celement
         def short=(value)
             if value.to_s.length != 1
                 raise ArgumentError, "Short names can only be one character."
             end
             @short = value.to_s
         end
 
         # Convert the object to a config statement.
         def to_config
             str = @desc.gsub(/^/, "# ") + "\n"
 
             # Add in a statement about the default.
             if defined? @default and @default
                 str += "# The default value is '%s'.\n" % @default
             end
 
             # If the value has not been overridden, then print it out commented
             # and unconverted, so it's clear that that's the default and how it
             # works.
             value = @parent.value(self.name)
 
             if value != @default
                 line = "%s = %s" % [@name, value]
             else
                 line = "# %s = %s" % [@name, @default]
             end
 
             str += line + "\n"
 
             str.gsub(/^/, "    ")
         end
 
         # Retrieves the value, or if it's not set, retrieves the default.
         def value
             @parent.value(self.name)
         end
     end
 
     # A file.
     class CFile < CElement
         attr_writer :owner, :group
         attr_accessor :mode, :create
 
         def group
             if defined? @group
                 return @parent.convert(@group)
             else
                 return nil
             end
         end
 
         def owner
             if defined? @owner
                 return @parent.convert(@owner)
             else
                 return nil
             end
         end
 
         # Set the type appropriately.  Yep, a hack.  This supports either naming
         # the variable 'dir', or adding a slash at the end.
         def munge(value)
             # If it's not a fully qualified path...
             if value.is_a?(String) and value !~ /^\$/ and value !~ /^\// and value != 'false'
                 # Make it one
                 value = File.join(Dir.getwd, value)
             end
             if value.to_s =~ /\/$/
                 @type = :directory
                 return value.sub(/\/$/, '')
             end
             return value
         end
 
         # Return the appropriate type.
         def type
             value = @parent.value(self.name)
             if @name.to_s =~ /dir/
                 return :directory
             elsif value.to_s =~ /\/$/
                 return :directory
             elsif value.is_a? String
                 return :file
             else
                 return nil
             end
         end
 
         # Convert the object to a TransObject instance.
         def to_transportable
             type = self.type
             return nil unless type
 
             path = self.value
 
             return nil unless path.is_a?(String)
             return nil if path =~ /^\/dev/
             return nil if Puppet::Type.type(:file)[path] # skip files that are in our global resource list.
 
             objects = []
 
             # Skip plain files that don't exist, since we won't be managing them anyway.
             return nil unless self.name.to_s =~ /dir$/ or File.exist?(path) or self.create
             obj = Puppet::TransObject.new(path, "file")
 
             # Only create directories, or files that are specifically marked to
             # create.
             if type == :directory or self.create
                 obj[:ensure] = type
             end
             [:mode].each { |var|
                 if value = self.send(var)
                     # Don't bother converting the mode, since the file type
                     # can handle it any old way.
                     obj[var] = value
                 end
             }
 
             # Only chown or chgrp when root
             if Puppet.features.root?
                 [:group, :owner].each { |var|
                     if value = self.send(var)
                         obj[var] = value
                     end
                 }
             end
 
             # And set the loglevel to debug for everything
             obj[:loglevel] = "debug"
             
             # We're not actually modifying any files here, and if we allow a
             # filebucket to get used here we get into an infinite recursion
             # trying to set the filebucket up.
             obj[:backup] = false
 
             if self.section
                 obj.tags += ["puppet", "configuration", self.section, self.name]
             end
             objects << obj
             objects
         end
 
         # Make sure any provided variables look up to something.
         def validate(value)
             return true unless value.is_a? String
             value.scan(/\$(\w+)/) { |name|
                 name = $1
                 unless @parent.include?(name)
                     raise ArgumentError,
                         "Settings parameter '%s' is undefined" %
                         name
                 end
             }
         end
     end
 
     # A simple boolean.
     class CBoolean < CElement
         # get the arguments in getopt format
         def getopt_args
             if short
                 [["--#{name}", "-#{short}", GetoptLong::NO_ARGUMENT],
                  ["--no-#{name}", GetoptLong::NO_ARGUMENT]]
             else
                 [["--#{name}", GetoptLong::NO_ARGUMENT],
                  ["--no-#{name}", GetoptLong::NO_ARGUMENT]]
             end
         end
 
         def munge(value)
             case value
             when true, "true": return true
             when false, "false": return false
             else
                 raise ArgumentError, "Invalid value '%s' for %s" %
                     [value.inspect, @name]
             end
         end
     end
 end
diff --git a/spec/unit/node/catalog.rb b/spec/unit/node/catalog.rb
index 604dabbb6..360dd87f2 100755
--- a/spec/unit/node/catalog.rb
+++ b/spec/unit/node/catalog.rb
@@ -1,831 +1,833 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Node::Catalog, " when compiling" do
     it "should accept tags" do
         config = Puppet::Node::Catalog.new("mynode")
         config.tag("one")
         config.tags.should == %w{one}
     end
 
     it "should accept multiple tags at once" do
         config = Puppet::Node::Catalog.new("mynode")
         config.tag("one", "two")
         config.tags.should == %w{one two}
     end
 
     it "should convert all tags to strings" do
         config = Puppet::Node::Catalog.new("mynode")
         config.tag("one", :two)
         config.tags.should == %w{one two}
     end
 
     it "should tag with both the qualified name and the split name" do
         config = Puppet::Node::Catalog.new("mynode")
         config.tag("one::two")
         config.tags.include?("one").should be_true
         config.tags.include?("one::two").should be_true
     end
 
     it "should accept classes" do
         config = Puppet::Node::Catalog.new("mynode")
         config.add_class("one")
         config.classes.should == %w{one}
         config.add_class("two", "three")
         config.classes.should == %w{one two three}
     end
 
     it "should tag itself with passed class names" do
         config = Puppet::Node::Catalog.new("mynode")
         config.add_class("one")
         config.tags.should == %w{one}
     end
 end
 
 describe Puppet::Node::Catalog, " when extracting" do
     it "should return extraction result as the method result" do
         config = Puppet::Node::Catalog.new("mynode")
         config.expects(:extraction_format).returns(:whatever)
         config.expects(:extract_to_whatever).returns(:result)
         config.extract.should == :result
     end
 end
 
 describe Puppet::Node::Catalog, " when extracting transobjects" do
 
     def mkscope
         @parser = Puppet::Parser::Parser.new :Code => ""
         @node = Puppet::Node.new("mynode")
         @compiler = Puppet::Parser::Compiler.new(@node, @parser)
 
         # XXX This is ridiculous.
         @compiler.send(:evaluate_main)
         @scope = @compiler.topscope
     end
 
     def mkresource(type, name)
         Puppet::Parser::Resource.new(:type => type, :title => name, :source => @source, :scope => @scope)
     end
 
     it "should always create a TransBucket for the 'main' class" do
         config = Puppet::Node::Catalog.new("mynode")
 
         @scope = mkscope
         @source = mock 'source'
 
         main = mkresource("class", :main)
         config.add_vertex(main)
 
         bucket = mock 'bucket'
         bucket.expects(:classes=).with(config.classes)
         main.stubs(:builtin?).returns(false)
         main.expects(:to_transbucket).returns(bucket)
 
         config.extract_to_transportable.should equal(bucket)
     end
 
     # This isn't really a spec-style test, but I don't know how better to do it.
     it "should transform the resource graph into a tree of TransBuckets and TransObjects" do
         config = Puppet::Node::Catalog.new("mynode")
 
         @scope = mkscope
         @source = mock 'source'
 
         defined = mkresource("class", :main)
         builtin = mkresource("file", "/yay")
 
         config.add_edge(defined, builtin)
 
         bucket = []
         bucket.expects(:classes=).with(config.classes)
         defined.stubs(:builtin?).returns(false)
         defined.expects(:to_transbucket).returns(bucket)
         builtin.expects(:to_transobject).returns(:builtin)
 
         config.extract_to_transportable.should == [:builtin]
     end
 
     # Now try it with a more complicated graph -- a three tier graph, each tier
     it "should transform arbitrarily deep graphs into isomorphic trees" do
         config = Puppet::Node::Catalog.new("mynode")
 
         @scope = mkscope
         @scope.stubs(:tags).returns([])
         @source = mock 'source'
 
         # Create our scopes.
         top = mkresource "class", :main
         topbucket = []
         topbucket.expects(:classes=).with([])
         top.expects(:to_trans).returns(topbucket)
         topres = mkresource "file", "/top"
         topres.expects(:to_trans).returns(:topres)
         config.add_edge top, topres
 
         middle = mkresource "class", "middle"
         middle.expects(:to_trans).returns([])
         config.add_edge top, middle
         midres = mkresource "file", "/mid"
         midres.expects(:to_trans).returns(:midres)
         config.add_edge middle, midres
 
         bottom = mkresource "class", "bottom"
         bottom.expects(:to_trans).returns([])
         config.add_edge middle, bottom
         botres = mkresource "file", "/bot"
         botres.expects(:to_trans).returns(:botres)
         config.add_edge bottom, botres
 
         toparray = config.extract_to_transportable
 
         # This is annoying; it should look like:
         #   [[[:botres], :midres], :topres]
         # but we can't guarantee sort order.
         toparray.include?(:topres).should be_true
 
         midarray = toparray.find { |t| t.is_a?(Array) }
         midarray.include?(:midres).should be_true
         botarray = midarray.find { |t| t.is_a?(Array) }
         botarray.include?(:botres).should be_true
     end
 end
 
 describe Puppet::Node::Catalog, " when converting to a transobject catalog" do
     class TestResource
         attr_accessor :name, :virtual, :builtin
         def initialize(name, options = {})
             @name = name
             options.each { |p,v| send(p.to_s + "=", v) }
         end
 
         def ref
             if builtin?
                 "File[%s]" % name
             else
                 "Class[%s]" % name
             end
         end
 
         def virtual?
             virtual
         end
 
         def builtin?
             builtin
         end
 
         def to_transobject
             Puppet::TransObject.new(name, builtin? ? "file" : "class")
         end
     end
 
     before do
         @original = Puppet::Node::Catalog.new("mynode")
         @original.tag(*%w{one two three})
         @original.add_class *%w{four five six}
 
         @top            = TestResource.new 'top'
         @topobject      = TestResource.new 'topobject', :builtin => true
         @virtual        = TestResource.new 'virtual', :virtual => true
         @virtualobject  = TestResource.new 'virtualobject', :builtin => true, :virtual => true
         @middle         = TestResource.new 'middle'
         @middleobject   = TestResource.new 'middleobject', :builtin => true
         @bottom         = TestResource.new 'bottom'
         @bottomobject   = TestResource.new 'bottomobject', :builtin => true
 
         @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject]
 
         @original.add_edge(@top, @topobject)
         @original.add_edge(@top, @virtual)
         @original.add_edge(@virtual, @virtualobject)
         @original.add_edge(@top, @middle)
         @original.add_edge(@middle, @middleobject)
         @original.add_edge(@middle, @bottom)
         @original.add_edge(@bottom, @bottomobject)
 
         @catalog = @original.to_transportable
     end
 
     it "should add all resources as TransObjects" do
         @resources.each { |resource| @catalog.resource(resource.ref).should be_instance_of(Puppet::TransObject) }
     end
 
     it "should not extract defined virtual resources" do
         @catalog.vertices.find { |v| v.name == "virtual" }.should be_nil
     end
 
     it "should not extract builtin virtual resources" do
         @catalog.vertices.find { |v| v.name == "virtualobject" }.should be_nil
     end
 
     it "should copy the tag list to the new catalog" do
         @catalog.tags.sort.should == @original.tags.sort
     end
 
     it "should copy the class list to the new catalog" do
         @catalog.classes.should == @original.classes
     end
 
     it "should duplicate the original edges" do
         @original.edges.each do |edge|
             next if edge.source.virtual? or edge.target.virtual?
             source = @catalog.resource(edge.source.ref)
             target = @catalog.resource(edge.target.ref)
 
             source.should_not be_nil
             target.should_not be_nil
             @catalog.edge?(source, target).should be_true
         end
     end
 
     it "should set itself as the catalog for each converted resource" do
         @catalog.vertices.each { |v| v.catalog.object_id.should equal(@catalog.object_id) }
     end
 end
 
 describe Puppet::Node::Catalog, " when converting to a RAL catalog" do
     before do
         @original = Puppet::Node::Catalog.new("mynode")
         @original.tag(*%w{one two three})
         @original.add_class *%w{four five six}
 
         @top            = Puppet::TransObject.new 'top', "class"
         @topobject      = Puppet::TransObject.new '/topobject', "file"
         @middle         = Puppet::TransObject.new 'middle', "class"
         @middleobject   = Puppet::TransObject.new '/middleobject', "file"
         @bottom         = Puppet::TransObject.new 'bottom', "class"
         @bottomobject   = Puppet::TransObject.new '/bottomobject', "file"
 
         @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject]
 
         @original.add_resource(*@resources)
 
         @original.add_edge(@top, @topobject)
         @original.add_edge(@top, @middle)
         @original.add_edge(@middle, @middleobject)
         @original.add_edge(@middle, @bottom)
         @original.add_edge(@bottom, @bottomobject)
 
         @catalog = @original.to_ral
     end
 
     it "should add all resources as RAL instances" do
         @resources.each { |resource| @catalog.resource(resource.ref).should be_instance_of(Puppet::Type) }
     end
 
     it "should copy the tag list to the new catalog" do
         @catalog.tags.sort.should == @original.tags.sort
     end
 
     it "should copy the class list to the new catalog" do
         @catalog.classes.should == @original.classes
     end
 
     it "should duplicate the original edges" do
         @original.edges.each do |edge|
             @catalog.edge?(@catalog.resource(edge.source.ref), @catalog.resource(edge.target.ref)).should be_true
         end
     end
 
     it "should set itself as the catalog for each converted resource" do
         @catalog.vertices.each { |v| v.catalog.object_id.should equal(@catalog.object_id) }
     end
 
     # This tests #931.
     it "should not lose track of resources whose names vary" do
         changer = Puppet::TransObject.new 'changer', 'test'
 
         config = Puppet::Node::Catalog.new('test')
         config.add_resource(changer)
         config.add_resource(@top)
 
         config.add_edge(@top, changer)
 
         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_type).returns(resource)
 
         newconfig = nil
 
         Puppet::Type.allclear
 
         proc { @catalog = config.to_ral }.should_not raise_error
         @catalog.resource("Test[changer2]").should equal(resource)
     end
 
     after do
         # Remove all resource instances.
         @catalog.clear(true)
     end
 end
 
 describe Puppet::Node::Catalog, " when functioning as a resource container" do
     before do
         @catalog = Puppet::Node::Catalog.new("host")
         @one = stub 'resource1', :ref => "Me[one]", :catalog= => nil
         @two = stub 'resource2', :ref => "Me[two]", :catalog= => nil
         @dupe = stub 'resource3', :ref => "Me[one]", :catalog= => nil
     end
 
     it "should provide a method to add one or more resources" do
         @catalog.add_resource @one, @two
         @catalog.resource(@one.ref).should equal(@one)
         @catalog.resource(@two.ref).should equal(@two)
     end
 
     it "should set itself as the resource's catalog if it is not a relationship graph" do
         @one.expects(:catalog=).with(@catalog)
         @catalog.add_resource @one
     end
 
     it "should not set itself as the resource's catalog if it is a relationship graph" do
         @one.expects(:catalog=).never
         @catalog.is_relationship_graph = true
         @catalog.add_resource @one
     end
 
     it "should make all vertices available by resource reference" do
         @catalog.add_resource(@one)
         @catalog.resource(@one.ref).should equal(@one)
         @catalog.vertices.find { |r| r.ref == @one.ref }.should equal(@one)
     end
 
     it "should canonize how resources are referred to during retrieval when both type and title are provided" do
         @catalog.add_resource(@one)
 
         @catalog.resource("me", "one").should equal(@one)
     end
 
     it "should canonize how resources are referred to during retrieval when just the title is provided" do
         @catalog.add_resource(@one)
 
         @catalog.resource("me[one]", nil).should equal(@one)
     end
 
     it "should not allow two resources with the same resource reference" do
         @catalog.add_resource(@one)
 
         # These are used to build the failure
         @dupe.stubs(:file)
         @dupe.stubs(:line)
         @one.stubs(:file)
         @one.stubs(:line)
         proc { @catalog.add_resource(@dupe) }.should raise_error(ArgumentError)
     end
 
     it "should not store objects that do not respond to :ref" do
         proc { @catalog.add_resource("thing") }.should raise_error(ArgumentError)
     end
 
     it "should remove all resources when asked" do
         @catalog.add_resource @one
         @catalog.add_resource @two
         @one.expects :remove
         @two.expects :remove
         @catalog.clear(true)
     end
 
     it "should support a mechanism for finishing resources" do
         @one.expects :finish
         @two.expects :finish
         @catalog.add_resource @one
         @catalog.add_resource @two
 
         @catalog.finalize
     end
 
     it "should make default resources when finalizing" do
         @catalog.expects(:make_default_resources)
         @catalog.finalize
     end
 
     it "should add default resources to the catalog upon creation" do
         @catalog.make_default_resources
         @catalog.resource(:schedule, "daily").should_not be_nil
     end
     
     it "should optionally support an initialization block and should finalize after such blocks" do
         @one.expects :finish
         @two.expects :finish
         config = Puppet::Node::Catalog.new("host") do |conf|
             conf.add_resource @one
             conf.add_resource @two
         end
     end
 
     it "should inform the resource that it is the resource's catalog" do
         @one.expects(:catalog=).with(@catalog)
         @catalog.add_resource @one
     end
 
     it "should be able to find resources by reference" do
         @catalog.add_resource @one
         @catalog.resource(@one.ref).should equal(@one)
     end
 
     it "should be able to find resources by reference or by type/title tuple" do
         @catalog.add_resource @one
         @catalog.resource("me", "one").should equal(@one)
     end
 
     it "should have a mechanism for removing resources" do
         @catalog.add_resource @one
         @one.expects :remove
         @catalog.remove_resource(@one)
         @catalog.resource(@one.ref).should be_nil
         @catalog.vertex?(@one).should be_false
     end
 
     it "should have a method for creating aliases for resources" do
         @catalog.add_resource @one
         @catalog.alias(@one, "other")
         @catalog.resource("me", "other").should equal(@one)
     end
 
     # This test is the same as the previous, but the behaviour should be explicit.
     it "should alias using the class name from the resource reference, not the resource class name" do
         @catalog.add_resource @one
         @catalog.alias(@one, "other")
         @catalog.resource("me", "other").should equal(@one)
     end
 
     it "should fail to add an alias if the aliased name already exists" do
         @catalog.add_resource @one
         proc { @catalog.alias @two, "one" }.should raise_error(ArgumentError)
     end
 
     it "should 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 be able to look resources up by their aliases" do
         @catalog.add_resource @one
         @catalog.alias @one, "two"
         @catalog.resource(:me, "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("me", "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).create :path => "/something", :title => "other", :content => "blah"
         resource.expects(:isomorphic?).returns(true)
         @catalog.add_resource(resource)
         @catalog.resource(:file, "other").should equal(resource)
         @catalog.resource(:file, "/something").ref.should == resource.ref
     end
 
     it "should not add an alias for the namevar when the title and name differ on non-isomorphic resource types" do
         resource = Puppet::Type.type(:file).create :path => "/something", :title => "other", :content => "blah"
         resource.expects(:isomorphic?).returns(false)
         @catalog.add_resource(resource)
         @catalog.resource(:file, resource.title).should equal(resource)
         # We can't use .should here, because the resources respond to that method.
         if @catalog.resource(:file, resource.name)
             raise "Aliased non-isomorphic resource"
         end
     end
 
     after do
         Puppet::Type.allclear
     end
 end
 
 describe Puppet::Node::Catalog do
     before :each do
         @catalog = Puppet::Node::Catalog.new("host")
 
         @catalog.retrieval_duration = Time.now
         @transaction = mock 'transaction'
         Puppet::Transaction.stubs(:new).returns(@transaction)
         @transaction.stubs(:evaluate)
         @transaction.stubs(:cleanup)
         @transaction.stubs(:addtimes)
     end
 
     describe Puppet::Node::Catalog, " when applying" do
 
         it "should create and evaluate a transaction" do
             @transaction.expects(:evaluate)
             @catalog.apply
         end
 
         it "should provide the catalog time to the transaction" do
             @transaction.expects(:addtimes).with do |arg|
                 arg[:config_retrieval].should be_instance_of(Time)
                 true
             end
             @catalog.apply
         end
 
         it "should clean up the transaction" do
             @transaction.expects :cleanup
             @catalog.apply
         end
     
         it "should return the transaction" do
             @catalog.apply.should equal(@transaction)
         end
 
         it "should yield the transaction if a block is provided" do
             @catalog.apply do |trans|
                 trans.should equal(@transaction)
             end
         end
     
         it "should default to not being a host catalog" do
             @catalog.host_config.should be_nil
         end
 
         it "should pass supplied tags on to the transaction" do
             @transaction.expects(:tags=).with(%w{one two})
             @catalog.apply(:tags => %w{one two})
         end
 
         it "should set ignoreschedules on the transaction if specified in apply()" do
             @transaction.expects(:ignoreschedules=).with(true)
             @catalog.apply(:ignoreschedules => true)
         end
     end
 
     describe Puppet::Node::Catalog, " when applying host catalogs" do
 
         # super() doesn't work in the setup method for some reason
         before do
             @catalog.host_config = true
         end
 
         it "should send a report if reporting is enabled" do
             Puppet[:report] = true
             @transaction.expects :send_report
             @transaction.stubs :any_failed? => false
             @catalog.apply
         end
 
         it "should send a report if report summaries are enabled" do
             Puppet[:summarize] = true
             @transaction.expects :send_report
             @transaction.stubs :any_failed? => false
             @catalog.apply
         end
 
         it "should initialize the state database before applying a catalog" do
             Puppet::Util::Storage.expects(:load)
 
             # Short-circuit the apply, so we know we're loading before the transaction
             Puppet::Transaction.expects(:new).raises ArgumentError
             proc { @catalog.apply }.should raise_error(ArgumentError)
         end
 
         it "should sync the state database after applying" do
             Puppet::Util::Storage.expects(:store)
             @transaction.stubs :any_failed? => false
             @catalog.apply
         end
 
         after { Puppet.settings.clear }
     end
 
     describe Puppet::Node::Catalog, " when applying non-host catalogs" do
 
         before do
             @catalog.host_config = false
         end
     
         it "should never send reports" do
             Puppet[:report] = true
             Puppet[:summarize] = true
             @transaction.expects(:send_report).never
             @catalog.apply
         end
 
         it "should never modify the state database" do
             Puppet::Util::Storage.expects(:load).never
             Puppet::Util::Storage.expects(:store).never
             @catalog.apply
         end
 
         after { Puppet.settings.clear }
     end
 end
 
 describe Puppet::Node::Catalog, " when creating a relationship graph" do
     before do
         Puppet::Type.type(:component)
         @catalog = Puppet::Node::Catalog.new("host")
         @compone = Puppet::Type::Component.create :name => "one"
         @comptwo = Puppet::Type::Component.create :name => "two", :require => ["class", "one"]
         @file = Puppet::Type.type(:file)
         @one = @file.create :path => "/one"
         @two = @file.create :path => "/two"
         @catalog.add_edge @compone, @one
         @catalog.add_edge @comptwo, @two
 
         @three = @file.create :path => "/three"
         @four = @file.create :path => "/four", :require => ["file", "/three"]
         @five = @file.create :path => "/five"
         @catalog.add_resource @compone, @comptwo, @one, @two, @three, @four, @five
         @relationships = @catalog.relationship_graph
     end
 
     it "should fail when trying to create a relationship graph for a relationship graph" do
         proc { @relationships.relationship_graph }.should raise_error(Puppet::DevError)
     end
 
     it "should be able to create a relationship graph" do
         @relationships.should be_instance_of(Puppet::Node::Catalog)
     end
 
     it "should copy its host_config setting to the relationship graph" do
         config = Puppet::Node::Catalog.new
         config.host_config = true
         config.relationship_graph.host_config.should be_true
     end
 
     it "should not have any components" do
         @relationships.vertices.find { |r| r.instance_of?(Puppet::Type::Component) }.should be_nil
     end
 
     it "should have all non-component resources from the catalog" do
         # The failures print out too much info, so i just do a class comparison
         @relationships.vertex?(@five).should be_true
     end
 
     it "should have all resource relationships set as edges" do
         @relationships.edge?(@three, @four).should be_true
     end
 
     it "should copy component relationships to all contained resources" do
         @relationships.edge?(@one, @two).should be_true
     end
 
     it "should get removed when the catalog is cleaned up" do
         @relationships.expects(:clear).with(false)
         @catalog.clear
         @catalog.instance_variable_get("@relationship_graph").should be_nil
     end
 
     it "should create a new relationship graph after clearing the old one" do
         @relationships.expects(:clear).with(false)
         @catalog.clear
         @catalog.relationship_graph.should be_instance_of(Puppet::Node::Catalog)
     end
 
     it "should look up resources in the relationship graph if not found in the main catalog" do
         five = stub 'five', :ref => "File[five]", :catalog= => nil
         @relationships.add_resource five
         @catalog.resource(five.ref).should equal(five)
     end
 
     it "should provide a method to create additional resources that also registers the resource" do
         args = {:name => "/yay", :ensure => :file}
         resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog
         Puppet::Type.type(:file).expects(:create).with(args).returns(resource)
         @catalog.create_resource :file, args
         @catalog.resource("File[/yay]").should equal(resource)
     end
 
     it "should provide a mechanism for creating implicit resources" do
         args = {:name => "/yay", :ensure => :file}
         resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog
         Puppet::Type.type(:file).expects(:create).with(args).returns(resource)
         resource.expects(:implicit=).with(true)
         @catalog.create_implicit_resource :file, args
         @catalog.resource("File[/yay]").should equal(resource)
     end
 
     it "should add implicit resources to the relationship graph if there is one" do
         args = {:name => "/yay", :ensure => :file}
         resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog
         resource.expects(:implicit=).with(true)
         Puppet::Type.type(:file).expects(:create).with(args).returns(resource)
         # build the graph
         relgraph = @catalog.relationship_graph
 
         @catalog.create_implicit_resource :file, args
         relgraph.resource("File[/yay]").should equal(resource)
     end
 
     it "should remove resources created mid-transaction" do
         args = {:name => "/yay", :ensure => :file}
         resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog
         @transaction = mock 'transaction'
         Puppet::Transaction.stubs(:new).returns(@transaction)
         @transaction.stubs(:evaluate)
         @transaction.stubs(:cleanup)
         @transaction.stubs(:addtimes)
         Puppet::Type.type(:file).expects(:create).with(args).returns(resource)
         resource.expects :remove
         @catalog.apply do |trans|
             @catalog.create_resource :file, args
             @catalog.resource("File[/yay]").should equal(resource)
         end
         @catalog.resource("File[/yay]").should be_nil
     end
 
     it "should remove resources from the relationship graph if it exists" do
         @catalog.remove_resource(@one)
         @catalog.relationship_graph.vertex?(@one).should be_false
     end
 
     after do
         Puppet::Type.allclear
     end
 end
 
 describe Puppet::Node::Catalog, " when writing dot files" do
     before do
         @catalog = Puppet::Node::Catalog.new("host")
         @name = :test
         @file = File.join(Puppet[:graphdir], @name.to_s + ".dot")
     end
     it "should only write when it is a host catalog" do
         File.expects(:open).with(@file).never
         @catalog.host_config = false
         Puppet[:graph] = true
         @catalog.write_graph(@name)
     end
 
     it "should only write when graphing is enabled" do
         File.expects(:open).with(@file).never
         @catalog.host_config = true
         Puppet[:graph] = false
         @catalog.write_graph(@name)
     end
 
     it "should write a dot file based on the passed name" do
         File.expects(:open).with(@file, "w").yields(stub("file", :puts => nil))
         @catalog.expects(:to_dot).with("name" => @name.to_s.capitalize)
         @catalog.host_config = true
         Puppet[:graph] = true
         @catalog.write_graph(@name)
     end
 
     after do
         Puppet.settings.clear
     end
 end
 
 describe Puppet::Node::Catalog, " when indirecting" do
     before do
         @indirection = mock 'indirection'
 
         Puppet::Indirector::Indirection.clear_cache
     end
 
     it "should redirect to the indirection for retrieval" do
         Puppet::Node::Catalog.stubs(:indirection).returns(@indirection)
         @indirection.expects(:find).with(:myconfig)
         Puppet::Node::Catalog.find(:myconfig)
     end
 
     it "should default to the 'compiler' terminus" do
         Puppet::Node::Catalog.indirection.terminus_class.should == :compiler
     end
 
     after do
         mocha_verify
         Puppet::Indirector::Indirection.clear_cache
     end
 end
 
 describe Puppet::Node::Catalog, " when converting to yaml" do
     before do
         @catalog = Puppet::Node::Catalog.new("me")
         @catalog.add_edge("one", "two")
     end
 
     it "should be able to be dumped to yaml" do
         YAML.dump(@catalog).should be_instance_of(String)
     end
 end
 
 describe Puppet::Node::Catalog, " when converting from yaml" do
     before do
         @catalog = Puppet::Node::Catalog.new("me")
         @catalog.add_edge("one", "two")
 
         text = YAML.dump(@catalog)
         @newcatalog = YAML.load(text)
     end
 
     it "should get converted back to a catalog" do
         @newcatalog.should be_instance_of(Puppet::Node::Catalog)
     end
 
     it "should have all vertices" do
         @newcatalog.vertex?("one").should be_true
         @newcatalog.vertex?("two").should be_true
     end
 
     it "should have all edges" do
         @newcatalog.edge?("one", "two").should be_true
     end
 end