diff --git a/lib/puppet/metatype/closure.rb b/lib/puppet/metatype/closure.rb
index 259854411..673a2359d 100644
--- a/lib/puppet/metatype/closure.rb
+++ b/lib/puppet/metatype/closure.rb
@@ -1,45 +1,49 @@
 class Puppet::Type
     attr_writer :implicit
 
     # Is this type's name isomorphic with the object?  That is, if the
     # name conflicts, does it necessarily mean that the objects conflict?
     # Defaults to true.
     def self.isomorphic?
         if defined? @isomorphic
             return @isomorphic
         else
             return true
         end
     end
 
     def implicit?
         if defined? @implicit and @implicit
             return true
         else
             return false
         end
     end
 
+    def isomorphic?
+        self.class.isomorphic?
+    end
+
     # is the instance a managed instance?  A 'yes' here means that
     # the instance was created from the language, vs. being created
     # in order resolve other questions, such as finding a package
     # in a list
     def managed?
         # Once an object is managed, it always stays managed; but an object
         # that is listed as unmanaged might become managed later in the process,
         # so we have to check that every time
         if defined? @managed and @managed
             return @managed
         else
             @managed = false
             properties.each { |property|
                 s = property.should
                 if s and ! property.class.unmanaged
                     @managed = true
                     break
                 end
             }
             return @managed
         end
     end
 end
diff --git a/lib/puppet/node/catalog.rb b/lib/puppet/node/catalog.rb
index d680de9a0..f885a41ee 100644
--- a/lib/puppet/node/catalog.rb
+++ b/lib/puppet/node/catalog.rb
@@ -1,512 +1,512 @@
 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.class.isomorphic?
+                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)
         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?
 
             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/parser/resource.rb b/lib/puppet/parser/resource.rb
index fb0799011..46be89ca2 100644
--- a/lib/puppet/parser/resource.rb
+++ b/lib/puppet/parser/resource.rb
@@ -1,434 +1,443 @@
 # A resource that we're managing.  This handles making sure that only subclasses
 # can set parameters.
 class Puppet::Parser::Resource
     require 'puppet/parser/resource/param'
     require 'puppet/parser/resource/reference'
     require 'puppet/util/tagging'
     include Puppet::Util
     include Puppet::Util::MethodHelper
     include Puppet::Util::Errors
     include Puppet::Util::Logging
     include Puppet::Util::Tagging
 
     attr_accessor :source, :line, :file, :scope, :rails_id
     attr_accessor :virtual, :override, :translated
 
     attr_reader :exported, :evaluated, :params
 
     # Determine whether the provided parameter name is a relationship parameter.
     def self.relationship_parameter?(name)
         unless defined?(@relationship_names)
             @relationship_names = Puppet::Type.relationship_params.collect { |p| p.name }
         end
         @relationship_names.include?(name)
     end
 
     # Proxy a few methods to our @ref object.
     [:builtin?, :type, :title].each do |method|
         define_method(method) do
             @ref.send(method)
         end
     end
 
     # Set up some boolean test methods
     [:exported, :translated, :override, :virtual, :evaluated].each do |method|
         newmeth = (method.to_s + "?").intern
         define_method(newmeth) do
             self.send(method)
         end
     end
 
     def [](param)
         param = symbolize(param)
         if param == :title
             return self.title
         end
         if @params.has_key?(param)
             @params[param].value
         else
             nil
         end
     end
 
     def builtin=(bool)
         @ref.builtin = bool
     end
 
     # Retrieve the associated definition and evaluate it.
     def evaluate
         if klass = @ref.definedtype
             finish()
             return klass.evaluate_code(self)
         elsif builtin?
             devfail "Cannot evaluate a builtin type"
         else
             self.fail "Cannot find definition %s" % self.type
         end
     ensure
         @evaluated = true
     end
 
     # Mark this resource as both exported and virtual,
     # or remove the exported mark.
     def exported=(value)
         if value
             @virtual = true
             @exported = value
         else
             @exported = value
         end
     end
 
     # Do any finishing work on this object, called before evaluation or
     # before storage/translation.
     def finish
         add_defaults()
         add_metaparams()
         add_scope_tags()
         validate()
     end
 
     def initialize(options)
         # Set all of the options we can.
         options.each do |option, value|
             if respond_to?(option.to_s + "=")
                 send(option.to_s + "=", value)
                 options.delete(option)
             end
         end
 
         unless self.scope
             raise ArgumentError, "Resources require a scope"
         end
         @source ||= scope.source
 
         options = symbolize_options(options)
 
         # Set up our reference.
         if type = options[:type] and title = options[:title]
             options.delete(:type)
             options.delete(:title)
         else
             raise ArgumentError, "Resources require a type and title"
         end
 
         @ref = Reference.new(:type => type, :title => title, :scope => self.scope)
 
         @params = {}
 
         # Define all of the parameters
         if params = options[:params]
             options.delete(:params)
             params.each do |param|
                 set_parameter(param)
             end
         end
 
         # Throw an exception if we've got any arguments left to set.
         unless options.empty?
             raise ArgumentError, "Resources do not accept %s" % options.keys.collect { |k| k.to_s }.join(", ")
         end
 
         tag(@ref.type)
         tag(@ref.title) if valid_tag?(@ref.title.to_s)
     end
 
+    # Is this resource modeling an isomorphic resource type?
+    def isomorphic?
+        if builtin?
+            return @ref.builtintype.isomorphic?
+        else
+            return true
+        end
+    end
+
     # Merge an override resource in.  This will throw exceptions if
     # any overrides aren't allowed.
     def merge(resource)
         # Test the resource scope, to make sure the resource is even allowed
         # to override.
         unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
             raise Puppet::ParseError.new("Only subclasses can override parameters", resource.line, resource.file)
         end
         # Some of these might fail, but they'll fail in the way we want.
         resource.params.each do |name, param|
             override_parameter(param)
         end
     end
 
     # Modify this resource in the Rails database.  Poor design, yo.
     def modify_rails(db_resource)
         args = rails_args
         args.each do |param, value|
             db_resource[param] = value unless db_resource[param] == value
         end
 
         # Handle file specially
         if (self.file and  
             (!db_resource.file or db_resource.file != self.file))
             db_resource.file = self.file
         end
         
         updated_params = @params.inject({}) do |hash, ary|
             hash[ary[0].to_s] = ary[1]
             hash
         end
         
         db_resource.ar_hash_merge(db_resource.get_params_hash(db_resource.param_values), updated_params,
                                   :create => Proc.new { |name, parameter|
                                       parameter.to_rails(db_resource)
                                   }, :delete => Proc.new { |values|
                                       values.each { |value| db_resource.param_values.delete(value) }
                                   }, :modify => Proc.new { |db, mem|
                                       mem.modify_rails_values(db)
                                   })
         
         updated_tags = tags.inject({}) { |hash, tag| 
             hash[tag] = tag
             hash
         }
             
         db_resource.ar_hash_merge(db_resource.get_tag_hash(), 
                                   updated_tags,
                                   :create => Proc.new { |name, tag|
                                       db_resource.add_resource_tag(name)
                                   }, :delete => Proc.new { |tag|
                                       db_resource.resource_tags.delete(tag)
                                   }, :modify => Proc.new { |db, mem|
                                       # nothing here
                                   })
     end
 
     # Return the resource name, or the title if no name
     # was specified.
     def name
         unless defined? @name
             @name = self[:name] || self.title
         end
         @name
     end
 
     # This *significantly* reduces the number of calls to Puppet.[].
     def paramcheck?
         unless defined? @@paramcheck
             @@paramcheck = Puppet[:paramcheck]
         end
         @@paramcheck
     end
 
     # A temporary occasion, until I get paths in the scopes figured out.
     def path
         to_s
     end
 
     # Return the short version of our name.
     def ref
         @ref.to_s
     end
 
     def to_hash
         @params.inject({}) do |hash, ary|
             param = ary[1]
             # Skip "undef" values.
             if param.value != :undef
                 hash[param.name] = param.value
             end
             hash
         end
     end
 
     # Turn our parser resource into a Rails resource.  
     def to_rails(host)
         args = rails_args
 
         db_resource = host.resources.build(args)
 
         # Handle file specially
         db_resource.file = self.file
 
         db_resource.save
 
         @params.each { |name, param|
             param.to_rails(db_resource)
         }
         
         tags.each { |tag| db_resource.add_resource_tag(tag) }
 
         return db_resource
     end
 
     def to_s
         self.ref
     end
 
     # Translate our object to a transportable object.
     def to_trans
         return nil if virtual?
 
         if builtin?
             to_transobject
         else
             to_transbucket
         end
     end
 
     def to_transbucket
         bucket = Puppet::TransBucket.new([])
 
         bucket.type = self.type
         bucket.name = self.title
 
         # TransBuckets don't support parameters, which is why they're being deprecated.
         return bucket
     end
 
     def to_transobject
         # Now convert to a transobject
         obj = Puppet::TransObject.new(@ref.title, @ref.type)
         to_hash.each do |p, v|
             if v.is_a?(Reference)
                 v = v.to_ref
             elsif v.is_a?(Array)
                 v = v.collect { |av|
                     if av.is_a?(Reference)
                         av = av.to_ref
                     end
                     av
                 }
             end
 
             # If the value is an array with only one value, then
             # convert it to a single value.  This is largely so that
             # the database interaction doesn't have to worry about
             # whether it returns an array or a string.
             obj[p.to_s] = if v.is_a?(Array) and v.length == 1
                               v[0]
                           else
                               v
                           end
         end
 
         obj.file = self.file
         obj.line = self.line
 
         obj.tags = self.tags
 
         return obj
     end
     
     private
 
     # Add default values from our definition.
     def add_defaults
         scope.lookupdefaults(self.type).each do |name, param|
             unless @params.include?(name)
                 self.debug "Adding default for %s" % name
 
                 @params[name] = param
             end
         end
     end
 
     # Add any metaparams defined in our scope. This actually adds any metaparams
     # from any parent scope, and there's currently no way to turn that off.
     def add_metaparams
         Puppet::Type.eachmetaparam do |name|
             # Skip metaparams that we already have defined, unless they're relationship metaparams.
             # LAK:NOTE Relationship metaparams get treated specially -- we stack them, instead of
             # overriding.
             next if @params[name] and not self.class.relationship_parameter?(name)
 
             # Skip metaparams for which we get no value.
             next unless val = scope.lookupvar(name.to_s, false) and val != :undefined
 
             # The default case: just set the value
             return set_parameter(name, val) unless @params[name]
 
             # For relationship params, though, join the values (a la #446).
             @params[name].value = [@params[name].value, val].flatten
         end
     end
 
     def add_scope_tags
         if scope_resource = scope.resource
             tag(*scope_resource.tags)
         end
     end
 
     # Accept a parameter from an override.
     def override_parameter(param)
         # This can happen if the override is defining a new parameter, rather
         # than replacing an existing one.
         (@params[param.name] = param and return) unless current = @params[param.name]
 
         # The parameter is already set.  Fail if they're not allowed to override it.
         unless param.source.child_of?(current.source)
             if Puppet[:trace]
                 puts caller
             end
             msg = "Parameter '%s' is already set on %s" % 
                 [param.name, self.to_s]
             if current.source.to_s != ""
                 msg += " by %s" % current.source
             end
             if current.file or current.line
                 fields = []
                 fields << current.file if current.file
                 fields << current.line.to_s if current.line
                 msg += " at %s" % fields.join(":")
             end
             msg += "; cannot redefine"
             raise Puppet::ParseError.new(msg, param.line, param.file)
         end
 
         # If we've gotten this far, we're allowed to override.
 
         # Merge with previous value, if the parameter was generated with the +> syntax.
         # It's important that we use the new param instance here, not the old one,
         # so that the source is registered correctly for later overrides.
         param.value = [current.value, param.value].flatten if param.add
 
         @params[param.name] = param
     end
 
     # Verify that all passed parameters are valid.  This throws an error if
     #  there's a problem, so we don't have to worry about the return value.
     def paramcheck(param)
         param = param.to_s
         # Now make sure it's a valid argument to our class.  These checks
         # are organized in order of commonhood -- most types, it's a valid 
         # argument and paramcheck is enabled.
         if @ref.typeclass.validattr?(param)
             true
         elsif %w{name title}.include?(param) # always allow these
             true
         elsif paramcheck?
             self.fail Puppet::ParseError, "Invalid parameter '%s' for type '%s'" %
                     [param, @ref.type]
         end
     end
 
     def rails_args
         return [:type, :title, :line, :exported].inject({}) do |hash, param|
             # 'type' isn't a valid column name, so we have to use another name.
             to = (param == :type) ? :restype : param
             if value = self.send(param)
                 hash[to] = value 
             end
             hash
         end
     end
 
     # Define a parameter in our resource.
     def set_parameter(param, value = nil)
         if value
             param = Puppet::Parser::Resource::Param.new(
                 :name => param, :value => value, :source => self.source
             )
         elsif ! param.is_a?(Puppet::Parser::Resource::Param)
             raise ArgumentError, "Must pass a parameter or all necessary values"
         end
 
         # And store it in our parameter hash.
         @params[param.name] = param
     end
 
     # Make sure the resource's parameters are all valid for the type.
     def validate
         @params.each do |name, param|
             # Make sure it's a valid parameter.
             paramcheck(name)
         end
     end
 end
diff --git a/spec/unit/node/catalog.rb b/spec/unit/node/catalog.rb
index b1bf5abaa..604dabbb6 100755
--- a/spec/unit/node/catalog.rb
+++ b/spec/unit/node/catalog.rb
@@ -1,829 +1,831 @@
 #!/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.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(:exec).create :command => "/bin/true", :title => "other"
+        resource = Puppet::Type.type(:file).create :path => "/something", :title => "other", :content => "blah"
+        resource.expects(:isomorphic?).returns(false)
         @catalog.add_resource(resource)
-        @catalog.resource(:exec, resource.title).should equal(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(:exec, resource.name)
+        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
diff --git a/spec/unit/parser/resource.rb b/spec/unit/parser/resource.rb
index a5a49e2a6..035590341 100755
--- a/spec/unit/parser/resource.rb
+++ b/spec/unit/parser/resource.rb
@@ -1,149 +1,164 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 # LAK: FIXME This is just new tests for resources; I have
 # not moved all tests over yet.
 
-describe Puppet::Parser::Resource, " when evaluating" do
+describe Puppet::Parser::Resource do
     before do
-        @type = Puppet::Parser::Resource
-
         @parser = Puppet::Parser::Parser.new :Code => ""
         @source = @parser.newclass ""
-        @definition = @parser.newdefine "mydefine"
-        @class = @parser.newclass "myclass"
-        @nodedef = @parser.newnode("mynode")[0]
         @node = Puppet::Node.new("yaynode")
         @compiler = Puppet::Parser::Compiler.new(@node, @parser)
         @scope = @compiler.topscope
     end
 
-    it "should evaluate the associated AST definition" do
-        res = @type.new(:type => "mydefine", :title => "whatever", :scope => @scope, :source => @source)
-        @definition.expects(:evaluate_code).with(res)
-
-        res.evaluate
+    it "should be isomorphic if it is builtin and models an isomorphic type" do
+        Puppet::Type.type(:file).expects(:isomorphic?).returns(true)
+        @resource = Puppet::Parser::Resource.new(:type => "file", :title => "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
     end
 
-    it "should evaluate the associated AST class" do
-        res = @type.new(:type => "class", :title => "myclass", :scope => @scope, :source => @source)
-        @class.expects(:evaluate_code).with(res)
-        res.evaluate
+    it "should not be isomorphic if it is builtin and models a non-isomorphic type" do
+        Puppet::Type.type(:file).expects(:isomorphic?).returns(false)
+        @resource = Puppet::Parser::Resource.new(:type => "file", :title => "whatever", :scope => @scope, :source => @source).isomorphic?.should be_false
     end
 
-    it "should evaluate the associated AST node" do
-        res = @type.new(:type => "node", :title => "mynode", :scope => @scope, :source => @source)
-        @nodedef.expects(:evaluate_code).with(res)
-        res.evaluate
+    it "should be isomorphic if it is not builtin" do
+        @parser.newdefine "whatever"
+        @resource = Puppet::Parser::Resource.new(:type => "whatever", :title => "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
     end
-end
 
-describe Puppet::Parser::Resource, " when finishing" do
-    before do
-        @parser = Puppet::Parser::Parser.new :Code => ""
-        @source = @parser.newclass ""
-        @definition = @parser.newdefine "mydefine"
-        @class = @parser.newclass "myclass"
-        @nodedef = @parser.newnode("mynode")[0]
-        @node = Puppet::Node.new("yaynode")
-        @compiler = Puppet::Parser::Compiler.new(@node, @parser)
-        @scope = @compiler.topscope
+    describe "when evaluating" do
+        before do
+            @type = Puppet::Parser::Resource
 
-        @resource = Puppet::Parser::Resource.new(:type => "mydefine", :title => "whatever", :scope => @scope, :source => @source)
-    end
+            @definition = @parser.newdefine "mydefine"
+            @class = @parser.newclass "myclass"
+            @nodedef = @parser.newnode("mynode")[0]
+        end
 
-    it "should copy metaparams from its scope" do
-        @scope.setvar("noop", "true")
+        it "should evaluate the associated AST definition" do
+            res = @type.new(:type => "mydefine", :title => "whatever", :scope => @scope, :source => @source)
+            @definition.expects(:evaluate_code).with(res)
 
-        @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
+            res.evaluate
+        end
 
-        @resource["noop"].should == "true"
+        it "should evaluate the associated AST class" do
+            res = @type.new(:type => "class", :title => "myclass", :scope => @scope, :source => @source)
+            @class.expects(:evaluate_code).with(res)
+            res.evaluate
+        end
+
+        it "should evaluate the associated AST node" do
+            res = @type.new(:type => "node", :title => "mynode", :scope => @scope, :source => @source)
+            @nodedef.expects(:evaluate_code).with(res)
+            res.evaluate
+        end
     end
 
-    it "should not copy metaparams that it already has" do
-        @resource.class.publicize_methods(:set_parameter)  { @resource.set_parameter("noop", "false") }
-        @scope.setvar("noop", "true")
+    describe "when finishing" do
+        before do
+            @definition = @parser.newdefine "mydefine"
+            @class = @parser.newclass "myclass"
+            @nodedef = @parser.newnode("mynode")[0]
 
-        @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
+            @resource = Puppet::Parser::Resource.new(:type => "mydefine", :title => "whatever", :scope => @scope, :source => @source)
+        end
 
-        @resource["noop"].should == "false"
-    end
+        it "should copy metaparams from its scope" do
+            @scope.setvar("noop", "true")
 
-    it "should stack relationship metaparams from its container if it already has them" do
-        @resource.class.publicize_methods(:set_parameter)  { @resource.set_parameter("require", "resource") }
-        @scope.setvar("require", "container")
+            @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
 
-        @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
+            @resource["noop"].should == "true"
+        end
 
-        @resource["require"].sort.should == %w{container resource}
-    end
+        it "should not copy metaparams that it already has" do
+            @resource.class.publicize_methods(:set_parameter)  { @resource.set_parameter("noop", "false") }
+            @scope.setvar("noop", "true")
 
-    it "should flatten the array resulting from stacking relationship metaparams" do
-        @resource.class.publicize_methods(:set_parameter)  { @resource.set_parameter("require", ["resource1", "resource2"]) }
-        @scope.setvar("require", %w{container1 container2})
+            @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
 
-        @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
+            @resource["noop"].should == "false"
+        end
 
-        @resource["require"].sort.should == %w{container1 container2 resource1 resource2}
-    end
+        it "should stack relationship metaparams from its container if it already has them" do
+            @resource.class.publicize_methods(:set_parameter)  { @resource.set_parameter("require", "resource") }
+            @scope.setvar("require", "container")
 
-    it "should add any tags from the scope resource" do
-        scope_resource = stub 'scope_resource', :tags => %w{one two}
-        @scope.stubs(:resource).returns(scope_resource)
+            @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
 
-        @resource.class.publicize_methods(:add_scope_tags)  { @resource.add_scope_tags }
+            @resource["require"].sort.should == %w{container resource}
+        end
 
-        @resource.tags.should be_include("one")
-        @resource.tags.should be_include("two")
-    end
-end
+        it "should flatten the array resulting from stacking relationship metaparams" do
+            @resource.class.publicize_methods(:set_parameter)  { @resource.set_parameter("require", ["resource1", "resource2"]) }
+            @scope.setvar("require", %w{container1 container2})
 
-describe Puppet::Parser::Resource, "when being tagged" do
-    before do
-        @scope_resource = stub 'scope_resource', :tags => %w{srone srtwo}
-        @scope = stub 'scope', :resource => @scope_resource
-        @resource = Puppet::Parser::Resource.new(:type => "file", :title => "yay", :scope => @scope, :source => mock('source'))
-    end
+            @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
 
-    it "should get tagged with the resource type" do
-        @resource.tags.should be_include("file")
-    end
+            @resource["require"].sort.should == %w{container1 container2 resource1 resource2}
+        end
 
-    it "should get tagged with the title" do
-        @resource.tags.should be_include("yay")
-    end
+        it "should add any tags from the scope resource" do
+            scope_resource = stub 'scope_resource', :tags => %w{one two}
+            @scope.stubs(:resource).returns(scope_resource)
 
-    it "should get tagged with each name in the title if the title is a qualified class name" do
-        resource = Puppet::Parser::Resource.new(:type => "file", :title => "one::two", :scope => @scope, :source => mock('source'))
-        resource.tags.should be_include("one")
-        resource.tags.should be_include("two")
-    end
+            @resource.class.publicize_methods(:add_scope_tags)  { @resource.add_scope_tags }
 
-    it "should get tagged with each name in the type if the type is a qualified class name" do
-        resource = Puppet::Parser::Resource.new(:type => "one::two", :title => "whatever", :scope => @scope, :source => mock('source'))
-        resource.tags.should be_include("one")
-        resource.tags.should be_include("two")
+            @resource.tags.should be_include("one")
+            @resource.tags.should be_include("two")
+        end
     end
 
-    it "should not get tagged with non-alphanumeric titles" do
-        resource = Puppet::Parser::Resource.new(:type => "file", :title => "this is a test", :scope => @scope, :source => mock('source'))
-        resource.tags.should_not be_include("this is a test")
-    end
+    describe "when being tagged" do
+        before do
+            @scope_resource = stub 'scope_resource', :tags => %w{srone srtwo}
+            @scope = stub 'scope', :resource => @scope_resource
+            @resource = Puppet::Parser::Resource.new(:type => "file", :title => "yay", :scope => @scope, :source => mock('source'))
+        end
 
-    it "should fail on tags containing '*' characters" do
-        lambda { @resource.tag("bad*tag") }.should raise_error(Puppet::ParseError)
-    end
+        it "should get tagged with the resource type" do
+            @resource.tags.should be_include("file")
+        end
 
-    it "should fail on tags starting with '-' characters" do
-        lambda { @resource.tag("-badtag") }.should raise_error(Puppet::ParseError)
-    end
+        it "should get tagged with the title" do
+            @resource.tags.should be_include("yay")
+        end
 
-    it "should fail on tags containing ' ' characters" do
-        lambda { @resource.tag("bad tag") }.should raise_error(Puppet::ParseError)
-    end
+        it "should get tagged with each name in the title if the title is a qualified class name" do
+            resource = Puppet::Parser::Resource.new(:type => "file", :title => "one::two", :scope => @scope, :source => mock('source'))
+            resource.tags.should be_include("one")
+            resource.tags.should be_include("two")
+        end
+
+        it "should get tagged with each name in the type if the type is a qualified class name" do
+            resource = Puppet::Parser::Resource.new(:type => "one::two", :title => "whatever", :scope => @scope, :source => mock('source'))
+            resource.tags.should be_include("one")
+            resource.tags.should be_include("two")
+        end
+
+        it "should not get tagged with non-alphanumeric titles" do
+            resource = Puppet::Parser::Resource.new(:type => "file", :title => "this is a test", :scope => @scope, :source => mock('source'))
+            resource.tags.should_not be_include("this is a test")
+        end
+
+        it "should fail on tags containing '*' characters" do
+            lambda { @resource.tag("bad*tag") }.should raise_error(Puppet::ParseError)
+        end
+
+        it "should fail on tags starting with '-' characters" do
+            lambda { @resource.tag("-badtag") }.should raise_error(Puppet::ParseError)
+        end
+
+        it "should fail on tags containing ' ' characters" do
+            lambda { @resource.tag("bad tag") }.should raise_error(Puppet::ParseError)
+        end
 
-    it "should allow alpha tags" do
-        lambda { @resource.tag("good_tag") }.should_not raise_error(Puppet::ParseError)
+        it "should allow alpha tags" do
+            lambda { @resource.tag("good_tag") }.should_not raise_error(Puppet::ParseError)
+        end
     end
 end