diff --git a/lib/puppet/parser/ast/resource.rb b/lib/puppet/parser/ast/resource.rb
index ce3c499c5..5f5f1ab06 100644
--- a/lib/puppet/parser/ast/resource.rb
+++ b/lib/puppet/parser/ast/resource.rb
@@ -1,67 +1,67 @@
 require 'puppet/parser/ast/resource_reference'
 
 # Any normal puppet resource declaration.  Can point to a definition or a
 # builtin type.
 class Puppet::Parser::AST
 class Resource < AST::Branch
 
   associates_doc
 
   attr_accessor :type, :instances, :exported, :virtual
 
   # Does not actually return an object; instead sets an object
   # in the current scope.
   def evaluate(scope)
     # We want virtual to be true if exported is true.  We can't
     # just set :virtual => self.virtual in the initialization,
     # because sometimes the :virtual attribute is set *after*
     # :exported, in which case it clobbers :exported if :exported
     # is true.  Argh, this was a very tough one to track down.
     virt = self.virtual || self.exported
 
     # First level of implicit iteration: build a resource for each
     # instance.  This handles things like:
     # file { '/foo': owner => blah; '/bar': owner => blah }
     @instances.collect { |instance|
 
       # Evaluate all of the specified params.
       paramobjects = instance.parameters.collect { |param|
         param.safeevaluate(scope)
       }
 
       resource_titles = instance.title.safeevaluate(scope)
 
       # it's easier to always use an array, even for only one name
       resource_titles = [resource_titles] unless resource_titles.is_a?(Array)
 
       fully_qualified_type, resource_titles = scope.resolve_type_and_titles(type, resource_titles)
 
       # Second level of implicit iteration; build a resource for each
       # title.  This handles things like:
       # file { ['/foo', '/bar']: owner => blah }
       resource_titles.flatten.collect { |resource_title|
         exceptwrap :type => Puppet::ParseError do
           resource = Puppet::Parser::Resource.new(
             fully_qualified_type, resource_title,
             :parameters => paramobjects,
             :file => self.file,
             :line => self.line,
             :exported => self.exported,
             :virtual => virt,
             :source => scope.source,
             :scope => scope,
             :strict => true
           )
 
           if resource.resource_type.is_a? Puppet::Resource::Type
             resource.resource_type.instantiate_resource(scope, resource)
           end
           scope.compiler.add_resource(scope, resource)
-          scope.compiler.evaluate_classes([resource_title],scope,false) if fully_qualified_type == 'class'
+          scope.compiler.evaluate_classes([resource_title], scope, false, true) if fully_qualified_type == 'class'
           resource
         end
       }
     }.flatten.reject { |resource| resource.nil? }
   end
 end
 end
diff --git a/lib/puppet/parser/compiler.rb b/lib/puppet/parser/compiler.rb
index ec3e7a889..172ffe67a 100644
--- a/lib/puppet/parser/compiler.rb
+++ b/lib/puppet/parser/compiler.rb
@@ -1,481 +1,489 @@
 require 'puppet/node'
 require 'puppet/resource/catalog'
 require 'puppet/util/errors'
 
 require 'puppet/resource/type_collection_helper'
 
 # Maintain a graph of scopes, along with a bunch of data
 # about the individual catalog we're compiling.
 class Puppet::Parser::Compiler
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Resource::TypeCollectionHelper
 
   def self.compile(node)
     # We get these from the environment and only cache them in a thread
     # variable for the duration of the compilation.  If nothing else is using
     # the thread, though, we can leave 'em hanging round with no ill effects,
     # and this is safer than cleaning them at the end and assuming that will
     # stick until the next entry to this function.
     Thread.current[:known_resource_types] = nil
     Thread.current[:env_module_directories] = nil
 
     # ...and we actually do the compile now we have caching ready.
     new(node).compile.to_resource
   rescue => detail
     message = "#{detail} on node #{node.name}"
     Puppet.log_exception(detail, message)
     raise Puppet::Error, message
  end
 
   attr_reader :node, :facts, :collections, :catalog, :resources, :relationships, :topscope
 
   # Add a collection to the global list.
   def add_collection(coll)
     @collections << coll
   end
 
   def add_relationship(dep)
     @relationships << dep
   end
 
   # Store a resource override.
   def add_override(override)
     # If possible, merge the override in immediately.
     if resource = @catalog.resource(override.ref)
       resource.merge(override)
     else
       # Otherwise, store the override for later; these
       # get evaluated in Resource#finish.
       @resource_overrides[override.ref] << override
     end
   end
 
   # Store a resource in our resource table.
   def add_resource(scope, resource)
     @resources << resource
 
     # Note that this will fail if the resource is not unique.
     @catalog.add_resource(resource)
 
     if resource.type.to_s.downcase != "class" && resource[:stage]
       raise ArgumentError, "Only classes can set 'stage'; normal resources like #{resource} cannot change run stage"
     end
 
     # Stages should not be inside of classes.  They are always a
     # top-level container, regardless of where they appear in the
     # manifest.
     return if resource.type.to_s.downcase == "stage"
 
     # This adds a resource to the class it lexically appears in in the
     # manifest.
     if resource.type.to_s.downcase != "class"
       return @catalog.add_edge(scope.resource, resource)
     end
   end
 
   # Do we use nodes found in the code, vs. the external node sources?
   def ast_nodes?
     known_resource_types.nodes?
   end
 
   # Store the fact that we've evaluated a class
   def add_class(name)
     @catalog.add_class(name) unless name == ""
   end
 
 
   # Return a list of all of the defined classes.
   def classlist
     @catalog.classes
   end
 
   # Compiler our catalog.  This mostly revolves around finding and evaluating classes.
   # This is the main entry into our catalog.
   def compile
     # Set the client's parameters into the top scope.
     set_node_parameters
     create_settings_scope
 
     evaluate_main
 
     evaluate_ast_node
 
     evaluate_node_classes
 
     evaluate_generators
 
     finish
 
     fail_on_unevaluated
 
     @catalog
   end
 
   # LAK:FIXME There are no tests for this.
   def delete_collection(coll)
     @collections.delete(coll) if @collections.include?(coll)
   end
 
   # Return the node's environment.
   def environment
     unless defined?(@environment)
       @environment = (node.environment and node.environment != "") ? node.environment : nil
     end
     Puppet::Node::Environment.current = @environment
     @environment
   end
 
   # Evaluate all of the classes specified by the node.
   def evaluate_node_classes
     evaluate_classes(@node.classes, @node_scope || topscope)
   end
 
   # Evaluate each specified class in turn.  If there are any classes we can't
   # find, raise an error.  This method really just creates resource objects
   # that point back to the classes, and then the resources are themselves
   # evaluated later in the process.
-  def evaluate_classes(classes, scope, lazy_evaluate = true)
+  #
+  # Sometimes we evaluate classes with a fully qualified name already, in which
+  # case, we tell scope.find_hostclass we've pre-qualified the name so it
+  # doesn't need to search it's namespaces again.  This gets around a weird
+  # edge case of duplicate class names, one at top scope and one nested in our
+  # namespace and the wrong one (or both!) getting selected. See ticket #13349
+  # for more detail.  --jeffweiss 26 apr 2012
+  def evaluate_classes(classes, scope, lazy_evaluate = true, fqname = false)
     raise Puppet::DevError, "No source for scope passed to evaluate_classes" unless scope.source
     class_parameters = nil
     # if we are a param class, save the classes hash
     # and transform classes to be the keys
     if classes.class == Hash
       class_parameters = classes
       classes = classes.keys
     end
     classes.each do |name|
       # If we can find the class, then make a resource that will evaluate it.
-      if klass = scope.find_hostclass(name)
+      
+      if klass = scope.find_hostclass(name, :assume_fqname => fqname)
 
         # If parameters are passed, then attempt to create a duplicate resource
         # so the appropriate error is thrown.
         if class_parameters
           resource = klass.ensure_in_catalog(scope, class_parameters[name] || {})
         else
           next if scope.class_scope(klass)
           resource = klass.ensure_in_catalog(scope)
         end
 
         # If they've disabled lazy evaluation (which the :include function does),
         # then evaluate our resource immediately.
         resource.evaluate unless lazy_evaluate
       else
         raise Puppet::Error, "Could not find class #{name} for #{node.name}"
       end
     end
   end
 
   def evaluate_relationships
     @relationships.each { |rel| rel.evaluate(catalog) }
   end
 
   # Return a resource by either its ref or its type and title.
   def findresource(*args)
     @catalog.resource(*args)
   end
 
   def initialize(node, options = {})
     @node = node
 
     options.each do |param, value|
       begin
         send(param.to_s + "=", value)
       rescue NoMethodError
         raise ArgumentError, "Compiler objects do not accept #{param}"
       end
     end
 
     initvars
   end
 
   # Create a new scope, with either a specified parent scope or
   # using the top scope.
   def newscope(parent, options = {})
     parent ||= topscope
     options[:compiler] = self
     scope = Puppet::Parser::Scope.new(options)
     scope.parent = parent
     scope
   end
 
   # Return any overrides for the given resource.
   def resource_overrides(resource)
     @resource_overrides[resource.ref]
   end
 
   private
 
   # If ast nodes are enabled, then see if we can find and evaluate one.
   def evaluate_ast_node
     return unless ast_nodes?
 
     # Now see if we can find the node.
     astnode = nil
     @node.names.each do |name|
       break if astnode = known_resource_types.node(name.to_s.downcase)
     end
 
     unless (astnode ||= known_resource_types.node("default"))
       raise Puppet::ParseError, "Could not find default node or by name with '#{node.names.join(", ")}'"
     end
 
     # Create a resource to model this node, and then add it to the list
     # of resources.
     resource = astnode.ensure_in_catalog(topscope)
 
     resource.evaluate
 
     @node_scope = topscope.class_scope(astnode)
   end
 
   # Evaluate our collections and return true if anything returned an object.
   # The 'true' is used to continue a loop, so it's important.
   def evaluate_collections
     return false if @collections.empty?
 
     found_something = false
     exceptwrap do
       # We have to iterate over a dup of the array because
       # collections can delete themselves from the list, which
       # changes its length and causes some collections to get missed.
       @collections.dup.each do |collection|
         found_something = true if collection.evaluate
       end
     end
 
     found_something
   end
 
   # Make sure all of our resources have been evaluated into native resources.
   # We return true if any resources have, so that we know to continue the
   # evaluate_generators loop.
   def evaluate_definitions
     exceptwrap do
       !unevaluated_resources.each { |resource| resource.evaluate }.empty?
     end
   end
 
   # Iterate over collections and resources until we're sure that the whole
   # compile is evaluated.  This is necessary because both collections
   # and defined resources can generate new resources, which themselves could
   # be defined resources.
   def evaluate_generators
     count = 0
     loop do
       done = true
 
       # Call collections first, then definitions.
       done = false if evaluate_collections
       done = false if evaluate_definitions
       break if done
 
       count += 1
 
       if count > 1000
         raise Puppet::ParseError, "Somehow looped more than 1000 times while evaluating host catalog"
       end
     end
   end
 
   # Find and evaluate our main object, if possible.
   def evaluate_main
     @main = known_resource_types.find_hostclass([""], "") || known_resource_types.add(Puppet::Resource::Type.new(:hostclass, ""))
     @topscope.source = @main
     @main_resource = Puppet::Parser::Resource.new("class", :main, :scope => @topscope, :source => @main)
     @topscope.resource = @main_resource
 
     add_resource(@topscope, @main_resource)
 
     @main_resource.evaluate
   end
 
   # Make sure the entire catalog is evaluated.
   def fail_on_unevaluated
     fail_on_unevaluated_overrides
     fail_on_unevaluated_resource_collections
   end
 
   # If there are any resource overrides remaining, then we could
   # not find the resource they were supposed to override, so we
   # want to throw an exception.
   def fail_on_unevaluated_overrides
     remaining = []
     @resource_overrides.each do |name, overrides|
       remaining.concat overrides
     end
 
     unless remaining.empty?
       fail Puppet::ParseError,
         "Could not find resource(s) %s for overriding" % remaining.collect { |o|
           o.ref
         }.join(", ")
     end
   end
 
   # Make sure we don't have any remaining collections that specifically
   # look for resources, because we want to consider those to be
   # parse errors.
   def fail_on_unevaluated_resource_collections
     remaining = []
     @collections.each do |coll|
       # We're only interested in the 'resource' collections,
       # which result from direct calls of 'realize'.  Anything
       # else is allowed not to return resources.
       # Collect all of them, so we have a useful error.
       if r = coll.resources
         if r.is_a?(Array)
           remaining += r
         else
           remaining << r
         end
       end
     end
 
     raise Puppet::ParseError, "Failed to realize virtual resources #{remaining.join(', ')}" unless remaining.empty?
   end
 
   # Make sure all of our resources and such have done any last work
   # necessary.
   def finish
     evaluate_relationships
 
     resources.each do |resource|
       # Add in any resource overrides.
       if overrides = resource_overrides(resource)
         overrides.each do |over|
           resource.merge(over)
         end
 
         # Remove the overrides, so that the configuration knows there
         # are none left.
         overrides.clear
       end
 
       resource.finish if resource.respond_to?(:finish)
     end
 
     add_resource_metaparams
   end
 
   def add_resource_metaparams
     unless main = catalog.resource(:class, :main)
       raise "Couldn't find main"
     end
 
     names = []
     Puppet::Type.eachmetaparam do |name|
       next if Puppet::Parser::Resource.relationship_parameter?(name)
       names << name
     end
 
     data = {}
     catalog.walk(main, :out) do |source, target|
       if source_data = data[source] || metaparams_as_data(source, names)
         # only store anything in the data hash if we've actually got
         # data
         data[source] ||= source_data
         source_data.each do |param, value|
           target[param] = value if target[param].nil?
         end
         data[target] = source_data.merge(metaparams_as_data(target, names))
       end
 
       target.tag(*(source.tags))
     end
   end
 
   def metaparams_as_data(resource, params)
     data = nil
     params.each do |param|
       unless resource[param].nil?
         # Because we could be creating a hash for every resource,
         # and we actually probably don't often have any data here at all,
         # we're optimizing a bit by only creating a hash if there's
         # any data to put in it.
         data ||= {}
         data[param] = resource[param]
       end
     end
     data
   end
 
   # Set up all of our internal variables.
   def initvars
     # The list of objects that will available for export.
     @exported_resources = {}
 
     # The list of overrides.  This is used to cache overrides on objects
     # that don't exist yet.  We store an array of each override.
     @resource_overrides = Hash.new do |overs, ref|
       overs[ref] = []
     end
 
     # The list of collections that have been created.  This is a global list,
     # but they each refer back to the scope that created them.
     @collections = []
 
     # The list of relationships to evaluate.
     @relationships = []
 
     # For maintaining the relationship between scopes and their resources.
     @catalog = Puppet::Resource::Catalog.new(@node.name)
     @catalog.version = known_resource_types.version
 
     @catalog.environment = @node.environment.to_s
 
     # Create our initial scope and a resource that will evaluate main.
     @topscope = Puppet::Parser::Scope.new(:compiler => self)
 
     @main_stage_resource = Puppet::Parser::Resource.new("stage", :main, :scope => @topscope)
     @catalog.add_resource(@main_stage_resource)
 
     # local resource array to maintain resource ordering
     @resources = []
 
     # Make sure any external node classes are in our class list
     if @node.classes.class == Hash
       @catalog.add_class(*@node.classes.keys)
     else
       @catalog.add_class(*@node.classes)
     end
   end
 
   # Set the node's parameters into the top-scope as variables.
   def set_node_parameters
     node.parameters.each do |param, value|
       @topscope[param] = value
     end
 
     # These might be nil.
     catalog.client_version = node.parameters["clientversion"]
     catalog.server_version = node.parameters["serverversion"]
   end
 
   def create_settings_scope
     unless settings_type = environment.known_resource_types.hostclass("settings")
       settings_type = Puppet::Resource::Type.new :hostclass, "settings"
       environment.known_resource_types.add(settings_type)
     end
 
     settings_resource = Puppet::Parser::Resource.new("class", "settings", :scope => @topscope)
 
     @catalog.add_resource(settings_resource)
 
     settings_type.evaluate_code(settings_resource)
 
     scope = @topscope.class_scope(settings_type)
 
     Puppet.settings.each do |name, setting|
       next if name.to_s == "name"
       scope[name.to_s] = environment[name]
     end
   end
 
   # Return an array of all of the unevaluated resources.  These will be definitions,
   # which need to get evaluated into native resources.
   def unevaluated_resources
     # The order of these is significant for speed due to short-circuting
     resources.reject { |resource| resource.evaluated? or resource.virtual? or resource.builtin_type? }
   end
 end
diff --git a/lib/puppet/parser/scope.rb b/lib/puppet/parser/scope.rb
index cd851cfb4..1d50abbd9 100644
--- a/lib/puppet/parser/scope.rb
+++ b/lib/puppet/parser/scope.rb
@@ -1,457 +1,457 @@
 # The scope class, which handles storing and retrieving variables and types and
 # such.
 
 require 'puppet/parser/parser'
 require 'puppet/parser/templatewrapper'
 require 'strscan'
 
 require 'puppet/resource/type_collection_helper'
 
 class Puppet::Parser::Scope
   include Puppet::Resource::TypeCollectionHelper
   require 'puppet/parser/resource'
 
   AST = Puppet::Parser::AST
 
   Puppet::Util.logmethods(self)
 
   include Enumerable
   include Puppet::Util::Errors
   attr_accessor :source, :resource
   attr_accessor :base, :keyword
   attr_accessor :top, :translated, :compiler
   attr_accessor :parent
   attr_reader :namespaces
 
   # thin wrapper around an ephemeral
   # symbol table.
   # when a symbol
   class Ephemeral
     def initialize(parent=nil)
       @symbols = {}
       @parent = parent
     end
 
     [:include?, :delete, :[]=].each do |m|
       define_method(m) do |*args|
         @symbols.send(m, *args)
       end
     end
 
     def [](name)
       unless @symbols.include?(name) or @parent.nil?
         @parent[name]
       else
         @symbols[name]
       end
     end
   end
 
   def [](name, options = {})
     lookupvar(name, options)
   end
 
   def []=(var, value)
     setvar(var, value)
   end
 
   # A demeterific shortcut to the catalog.
   def catalog
     compiler.catalog
   end
 
   def each
     to_hash.each { |name, value| yield(name, value) }
   end
 
   # Proxy accessors
   def host
     @compiler.node.name
   end
 
   def include?(name)
     ! self[name].nil?
   end
 
   # Is the value true?  This allows us to control the definition of truth
   # in one place.
   def self.true?(value)
     (value != false and value != "" and value != :undef)
   end
 
   # Is the value a number?, return the correct object or nil if not a number
   def self.number?(value)
     return nil unless value.is_a?(Fixnum) or value.is_a?(Bignum) or value.is_a?(Float) or value.is_a?(String)
 
     if value.is_a?(String)
       if value =~ /^-?\d+(:?\.\d+|(:?\.\d+)?e\d+)$/
         return value.to_f
       elsif value =~ /^0x[0-9a-f]+$/i
         return value.to_i(16)
       elsif value =~ /^0[0-7]+$/
         return value.to_i(8)
       elsif value =~ /^-?\d+$/
         return value.to_i
       else
         return nil
       end
     end
     # it is one of Fixnum,Bignum or Float
     value
   end
 
   # Add to our list of namespaces.
   def add_namespace(ns)
     return false if @namespaces.include?(ns)
     if @namespaces == [""]
       @namespaces = [ns]
     else
       @namespaces << ns
     end
   end
 
   def environment
     compiler ? compiler.environment : Puppet::Node::Environment.new
   end
 
-  def find_hostclass(name)
-    known_resource_types.find_hostclass(namespaces, name)
+  def find_hostclass(name, options = {})
+    known_resource_types.find_hostclass(namespaces, name, options)
   end
 
   def find_definition(name)
     known_resource_types.find_definition(namespaces, name)
   end
 
   def findresource(string, name = nil)
     compiler.findresource(string, name)
   end
 
   # Initialize our new scope.  Defaults to having no parent.
   def initialize(hash = {})
     if hash.include?(:namespace)
       if n = hash[:namespace]
         @namespaces = [n]
       end
       hash.delete(:namespace)
     else
       @namespaces = [""]
     end
     hash.each { |name, val|
       method = name.to_s + "="
       if self.respond_to? method
         self.send(method, val)
       else
         raise Puppet::DevError, "Invalid scope argument #{name}"
       end
     }
 
     extend_with_functions_module
 
     @tags = []
 
     # The symbol table for this scope.  This is where we store variables.
     @symtable = {}
 
     # the ephemeral symbol tables
     # those should not persist long, and are used for the moment only
     # for $0..$xy capture variables of regexes
     # this is actually implemented as a stack, with each ephemeral scope
     # shadowing the previous one
     @ephemeral = [ Ephemeral.new ]
 
     # All of the defaults set for types.  It's a hash of hashes,
     # with the first key being the type, then the second key being
     # the parameter.
     @defaults = Hash.new { |dhash,type|
       dhash[type] = {}
     }
 
     # The table for storing class singletons.  This will only actually
     # be used by top scopes and node scopes.
     @class_scopes = {}
   end
 
   # Store the fact that we've evaluated a class, and store a reference to
   # the scope in which it was evaluated, so that we can look it up later.
   def class_set(name, scope)
     return parent.class_set(name,scope) if parent
     @class_scopes[name] = scope
   end
 
   # Return the scope associated with a class.  This is just here so
   # that subclasses can set their parent scopes to be the scope of
   # their parent class, and it's also used when looking up qualified
   # variables.
   def class_scope(klass)
     # They might pass in either the class or class name
     k = klass.respond_to?(:name) ? klass.name : klass
     @class_scopes[k] || (parent && parent.class_scope(k))
   end
 
   # Collect all of the defaults set at any higher scopes.
   # This is a different type of lookup because it's additive --
   # it collects all of the defaults, with defaults in closer scopes
   # overriding those in later scopes.
   def lookupdefaults(type)
     values = {}
 
     # first collect the values from the parents
     unless parent.nil?
       parent.lookupdefaults(type).each { |var,value|
         values[var] = value
       }
     end
 
     # then override them with any current values
     # this should probably be done differently
     if @defaults.include?(type)
       @defaults[type].each { |var,value|
         values[var] = value
       }
     end
 
     values
   end
 
   # Look up a defined type.
   def lookuptype(name)
     find_definition(name) || find_hostclass(name)
   end
 
   def undef_as(x,v)
     if v.nil? or v == :undef
       x
     else
       v
     end
   end
 
   def lookupvar(name, options = {})
     # Save the originating scope for the request
     options[:origin] = self unless options[:origin]
     table = ephemeral?(name) ? @ephemeral.last : @symtable
     if name =~ /^(.*)::(.+)$/
       begin
         qualified_scope($1).lookupvar($2, options.merge({:origin => nil}))
       rescue RuntimeError => e
         location = (options[:file] && options[:line]) ? " at #{options[:file]}:#{options[:line]}" : ''
         warning "Could not look up qualified variable '#{name}'; #{e.message}#{location}"
         nil
       end
     # If the value is present and either we are top/node scope or originating scope...
     elsif (ephemeral_include?(name) or table.include?(name)) and (compiler and self == compiler.topscope or (self.resource and self.resource.type == "Node") or self == options[:origin])
       table[name]
     elsif resource and resource.type == "Class" and parent_type = resource.resource_type.parent
       class_scope(parent_type).lookupvar(name,options.merge({:origin => nil}))
     elsif parent
       parent.lookupvar(name, options)
     else
       nil
     end
   end
 
   def qualified_scope(classname)
     raise "class #{classname} could not be found"     unless klass = find_hostclass(classname)
     raise "class #{classname} has not been evaluated" unless kscope = class_scope(klass)
     kscope
   end
   private :qualified_scope
 
   # Return a hash containing our variables and their values, optionally (and
   # by default) including the values defined in our parent.  Local values
   # shadow parent values.
   def to_hash(recursive = true)
     target = parent.to_hash(recursive) if recursive and parent
     target ||= Hash.new
     @symtable.keys.each { |name|
       value = @symtable[name]
       if value == :undef
         target.delete(name)
       else
         target[name] = value
       end
     }
     target
   end
 
   def namespaces
     @namespaces.dup
   end
 
   # Create a new scope and set these options.
   def newscope(options = {})
     compiler.newscope(self, options)
   end
 
   def parent_module_name
     return nil unless @parent
     return nil unless @parent.source
     @parent.source.module_name
   end
 
   # Set defaults for a type.  The typename should already be downcased,
   # so that the syntax is isolated.  We don't do any kind of type-checking
   # here; instead we let the resource do it when the defaults are used.
   def define_settings(type, params)
     table = @defaults[type]
 
     # if we got a single param, it'll be in its own array
     params = [params] unless params.is_a?(Array)
 
     params.each { |param|
       if table.include?(param.name)
         raise Puppet::ParseError.new("Default already defined for #{type} { #{param.name} }; cannot redefine", param.line, param.file)
       end
       table[param.name] = param
     }
   end
 
   # Set a variable in the current scope.  This will override settings
   # in scopes above, but will not allow variables in the current scope
   # to be reassigned.
   #   It's preferred that you use self[]= instead of this; only use this
   # when you need to set options.
   def setvar(name, value, options = {})
     table = options[:ephemeral] ? @ephemeral.last : @symtable
     if table.include?(name)
       if options[:append]
         error = Puppet::ParseError.new("Cannot append, variable #{name} is defined in this scope")
       else
         error = Puppet::ParseError.new("Cannot reassign variable #{name}")
       end
       error.file = options[:file] if options[:file]
       error.line = options[:line] if options[:line]
       raise error
     end
 
     if options[:append]
       table[name] = append_value(undef_as('', self[name]), value)
     else 
       table[name] = value
     end
   end
 
   def append_value(bound_value, new_value)
     case new_value
     when Array
       bound_value + new_value
     when Hash
       bound_value.merge(new_value)
     else
       if bound_value.is_a?(Hash)
         raise ArgumentError, "Trying to append to a hash with something which is not a hash is unsupported" 
       end
       bound_value + new_value
     end
   end
   private :append_value
 
   # Return the tags associated with this scope.
   def tags
     resource.tags
   end
 
   # Used mainly for logging
   def to_s
     "Scope(#{@resource})"
   end
 
   # remove ephemeral scope up to level
   def unset_ephemeral_var(level=:all)
     if level == :all
       @ephemeral = [ Ephemeral.new ]
     else
       (@ephemeral.size - level).times do
         @ephemeral.pop
       end
     end
   end
 
   # check if name exists in one of the ephemeral scope.
   def ephemeral_include?(name)
     @ephemeral.reverse_each do |eph|
       return true if eph.include?(name)
     end
     false
   end
 
   # is name an ephemeral variable?
   def ephemeral?(name)
     name =~ /^\d+$/
   end
 
   def ephemeral_level
     @ephemeral.size
   end
 
   def new_ephemeral
     @ephemeral.push(Ephemeral.new(@ephemeral.last))
   end
 
   def ephemeral_from(match, file = nil, line = nil)
     raise(ArgumentError,"Invalid regex match data") unless match.is_a?(MatchData)
 
     new_ephemeral
 
     setvar("0", match[0], :file => file, :line => line, :ephemeral => true)
     match.captures.each_with_index do |m,i|
       setvar("#{i+1}", m, :file => file, :line => line, :ephemeral => true)
     end
   end
 
   def find_resource_type(type)
     # It still works fine without the type == 'class' short-cut, but it is a lot slower.
     return nil if ["class", "node"].include? type.to_s.downcase
     find_builtin_resource_type(type) || find_defined_resource_type(type)
   end
 
   def find_builtin_resource_type(type)
     Puppet::Type.type(type.to_s.downcase.to_sym)
   end
 
   def find_defined_resource_type(type)
     environment.known_resource_types.find_definition(namespaces, type.to_s.downcase)
   end
 
   def method_missing(method, *args, &block)
     method.to_s =~ /^function_(.*)$/
     super unless $1
     super unless Puppet::Parser::Functions.function($1)
 
     # Calling .function(name) adds "function_#{name}" as a callable method on
     # self if it's found, so now we can just send it
     # NOTE: I have watched this method end up in an infinite recursion / stack overflow.  It seems
     #  to me that we ought to be checkign with "respond_to?" before calling send, and throwing an
     #  exception if we get a "false" back.  However, I tried this, and it broke 1 test in scope_spec...
     #  and I don't have time to debug it further right now.  --cprice 2012-03-15
     send(method, *args)
   end
 
   def resolve_type_and_titles(type, titles)
     raise ArgumentError, "titles must be an array" unless titles.is_a?(Array)
 
     case type.downcase
     when "class"
       # resolve the titles
       titles = titles.collect do |a_title|
         hostclass = find_hostclass(a_title)
         hostclass ?  hostclass.name : a_title
       end
     when "node"
       # no-op
     else
       # resolve the type
       resource_type = find_resource_type(type)
       type = resource_type.name if resource_type
     end
 
     return [type, titles]
   end
 
   private
 
   def extend_with_functions_module
     extend Puppet::Parser::Functions.environment_module(Puppet::Node::Environment.root)
     extend Puppet::Parser::Functions.environment_module(environment) if environment != Puppet::Node::Environment.root
   end
 end
diff --git a/lib/puppet/resource/type_collection.rb b/lib/puppet/resource/type_collection.rb
index 082a11c1c..8306b778d 100644
--- a/lib/puppet/resource/type_collection.rb
+++ b/lib/puppet/resource/type_collection.rb
@@ -1,214 +1,215 @@
 class Puppet::Resource::TypeCollection
   attr_reader :environment
   attr_accessor :parse_failed
 
   def clear
     @hostclasses.clear
     @definitions.clear
     @nodes.clear
     @watched_files.clear
   end
 
   def initialize(env)
     @environment = env.is_a?(String) ? Puppet::Node::Environment.new(env) : env
     @hostclasses = {}
     @definitions = {}
     @nodes = {}
 
     # So we can keep a list and match the first-defined regex
     @node_list = []
 
     @watched_files = {}
   end
 
   def import_ast(ast, modname)
     ast.instantiate(modname).each do |instance|
       add(instance)
     end
   end
 
   def inspect
     "TypeCollection" + { :hostclasses => @hostclasses.keys, :definitions => @definitions.keys, :nodes => @nodes.keys }.inspect
   end
 
   def <<(thing)
     add(thing)
     self
   end
 
   def add(instance)
     if instance.type == :hostclass and other = @hostclasses[instance.name] and other.type == :hostclass
       other.merge(instance)
       return other
     end
     method = "add_#{instance.type}"
     send(method, instance)
     instance.resource_type_collection = self
     instance
   end
 
   def add_hostclass(instance)
     dupe_check(instance, @hostclasses) { |dupe| "Class '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
     dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined as a class" }
 
     @hostclasses[instance.name] = instance
     instance
   end
 
   def hostclass(name)
     @hostclasses[munge_name(name)]
   end
 
   def add_node(instance)
     dupe_check(instance, @nodes) { |dupe| "Node '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
 
     @node_list << instance
     @nodes[instance.name] = instance
     instance
   end
 
   def loader
     require 'puppet/parser/type_loader'
     @loader ||= Puppet::Parser::TypeLoader.new(environment)
   end
 
   def node(name)
     name = munge_name(name)
 
     if node = @nodes[name]
       return node
     end
 
     @node_list.each do |node|
       next unless node.name_is_regex?
       return node if node.match(name)
     end
     nil
   end
 
   def node_exists?(name)
     @nodes[munge_name(name)]
   end
 
   def nodes?
     @nodes.length > 0
   end
 
   def add_definition(instance)
     dupe_check(instance, @hostclasses) { |dupe| "'#{instance.name}' is already defined#{dupe.error_context} as a class; cannot redefine as a definition" }
     dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined" }
     @definitions[instance.name] = instance
   end
 
   def definition(name)
     @definitions[munge_name(name)]
   end
 
   def find_node(namespaces, name)
     @nodes[munge_name(name)]
   end
 
-  def find_hostclass(namespaces, name)
-    find_or_load(namespaces, name, :hostclass)
+  def find_hostclass(namespaces, name, options = {})
+    find_or_load(namespaces, name, :hostclass, options)
   end
 
   def find_definition(namespaces, name)
     find_or_load(namespaces, name, :definition)
   end
 
   [:hostclasses, :nodes, :definitions].each do |m|
     define_method(m) do
       instance_variable_get("@#{m}").dup
     end
   end
 
   def require_reparse?
     @parse_failed || stale?
   end
 
   def stale?
     @watched_files.values.detect { |file| file.changed? }
   end
 
   def version
     return @version if defined?(@version)
 
     if environment[:config_version] == ""
       @version = Time.now.to_i
       return @version
     end
 
     @version = Puppet::Util::Execution.execute([environment[:config_version]]).strip
 
   rescue Puppet::ExecutionFailure => e
     raise Puppet::ParseError, "Unable to set config_version: #{e.message}"
   end
 
   def watch_file(file)
     @watched_files[file] = Puppet::Util::LoadedFile.new(file)
   end
 
   def watching_file?(file)
     @watched_files.include?(file)
   end
 
   private
 
   # Return a list of all possible fully-qualified names that might be
   # meant by the given name, in the context of namespaces.
   def resolve_namespaces(namespaces, name)
     name      = name.downcase
     if name =~ /^::/
       # name is explicitly fully qualified, so just return it, sans
       # initial "::".
       return [name.sub(/^::/, '')]
     end
     if name == ""
       # The name "" has special meaning--it always refers to a "main"
       # hostclass which contains all toplevel resources.
       return [""]
     end
 
     namespaces = [namespaces] unless namespaces.is_a?(Array)
     namespaces = namespaces.collect { |ns| ns.downcase }
 
     result = []
     namespaces.each do |namespace|
       ary = namespace.split("::")
 
       # Search each namespace nesting in innermost-to-outermost order.
       while ary.length > 0
         result << "#{ary.join("::")}::#{name}"
         ary.pop
       end
 
       # Finally, search the toplevel namespace.
       result << name
     end
 
     return result.uniq
   end
 
   # Resolve namespaces and find the given object.  Autoload it if
   # necessary.
-  def find_or_load(namespaces, name, type)
-    resolve_namespaces(namespaces, name).each do |fqname|
+  def find_or_load(namespaces, name, type, options = {})
+    searchspace = options[:assume_fqname] ? [name].flatten : resolve_namespaces(namespaces, name)
+    searchspace.each do |fqname|
       if result = send(type, fqname) || loader.try_load_fqname(type, fqname)
         return result
       end
     end
 
     # Nothing found.
     return nil
   end
 
   def munge_name(name)
     name.to_s.downcase
   end
 
   def dupe_check(instance, hash)
     return unless dupe = hash[instance.name]
     message = yield dupe
     instance.fail Puppet::ParseError, message
   end
 end
diff --git a/spec/integration/parser/compiler_spec.rb b/spec/integration/parser/compiler_spec.rb
index 0c817be80..88d2ea9a9 100755
--- a/spec/integration/parser/compiler_spec.rb
+++ b/spec/integration/parser/compiler_spec.rb
@@ -1,282 +1,309 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Parser::Compiler do
   before :each do
     @node = Puppet::Node.new "testnode"
 
     @scope_resource = stub 'scope_resource', :builtin? => true, :finish => nil, :ref => 'Class[main]'
     @scope = stub 'scope', :resource => @scope_resource, :source => mock("source")
   end
 
   after do
     Puppet.settings.clear
   end
 
   it "should be able to determine the configuration version from a local version control repository" do
     pending("Bug #14071 about semantics of Puppet::Util::Execute on Windows", :if => Puppet.features.microsoft_windows?) do
       # This should always work, because we should always be
       # in the puppet repo when we run this.
       version = %x{git rev-parse HEAD}.chomp
 
       Puppet.settings[:config_version] = 'git rev-parse HEAD'
 
       @parser = Puppet::Parser::Parser.new "development"
       @compiler = Puppet::Parser::Compiler.new(@node)
 
       @compiler.catalog.version.should == version
     end
   end
 
   it "should not create duplicate resources when a class is referenced both directly and indirectly by the node classifier (4792)" do
     Puppet[:code] = <<-PP
       class foo
       {
         notify { foo_notify: }
         include bar
       }
       class bar
       {
         notify { bar_notify: }
       }
     PP
 
     @node.stubs(:classes).returns(['foo', 'bar'])
 
     catalog = Puppet::Parser::Compiler.compile(@node)
 
     catalog.resource("Notify[foo_notify]").should_not be_nil
     catalog.resource("Notify[bar_notify]").should_not be_nil
   end
 
   describe "when resolving class references" do
     it "should favor local scope, even if there's an included class in topscope" do
       Puppet[:code] = <<-PP
         class experiment {
           class baz {
           }
           notify {"x" : require => Class[Baz] }
         }
         class baz {
         }
         include baz
         include experiment
         include experiment::baz
       PP
 
       catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
 
       notify_resource = catalog.resource( "Notify[x]" )
 
       notify_resource[:require].title.should == "Experiment::Baz"
     end
 
     it "should favor local scope, even if there's an unincluded class in topscope" do
       Puppet[:code] = <<-PP
         class experiment {
           class baz {
           }
           notify {"x" : require => Class[Baz] }
         }
         class baz {
         }
         include experiment
         include experiment::baz
       PP
 
       catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
 
       notify_resource = catalog.resource( "Notify[x]" )
 
       notify_resource[:require].title.should == "Experiment::Baz"
     end
   end
+  describe "(ticket #13349) when explicitly specifying top scope" do
+    ["class {'::bar::baz':}", "include ::bar::baz"].each do |include|
+      describe "with #{include}" do
+        it "should find the top level class" do
+          Puppet[:code] = <<-MANIFEST
+            class { 'foo::test': }
+            class foo::test {
+            	#{include}
+            }
+            class bar::baz {
+            	notify { 'good!': }
+            }
+            class foo::bar::baz {
+            	notify { 'bad!': }
+            }
+          MANIFEST
+
+          catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
+
+          catalog.resource("Class[Bar::Baz]").should_not be_nil
+          catalog.resource("Notify[good!]").should_not be_nil
+          catalog.resource("Class[Foo::Bar::Baz]").should be_nil
+          catalog.resource("Notify[bad!]").should be_nil
+        end
+      end
+    end
+  end
 
   it "should recompute the version after input files are re-parsed" do
     Puppet[:code] = 'class foo { }'
     Time.stubs(:now).returns(1)
     node = Puppet::Node.new('mynode')
     Puppet::Parser::Compiler.compile(node).version.should == 1
     Time.stubs(:now).returns(2)
     Puppet::Parser::Compiler.compile(node).version.should == 1 # no change because files didn't change
     Puppet::Resource::TypeCollection.any_instance.stubs(:stale?).returns(true).then.returns(false) # pretend change
     Puppet::Parser::Compiler.compile(node).version.should == 2
   end
 
   ['class', 'define', 'node'].each do |thing|
     it "should not allow #{thing} inside evaluated conditional constructs" do
       Puppet[:code] = <<-PP
         if true {
           #{thing} foo {
           }
           notify { decoy: }
         }
       PP
 
       begin
         Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
         raise "compilation should have raised Puppet::Error"
       rescue Puppet::Error => e
         e.message.should =~ /at line 2/
       end
     end
   end
 
   it "should not allow classes inside unevaluated conditional constructs" do
     Puppet[:code] = <<-PP
       if false {
         class foo {
         }
       }
     PP
 
     lambda { Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode")) }.should raise_error(Puppet::Error)
   end
 
   describe "when defining relationships" do
     def extract_name(ref)
       ref.sub(/File\[(\w+)\]/, '\1')
     end
 
     let(:node) { Puppet::Node.new('mynode') }
     let(:code) do
       <<-MANIFEST
         file { [a,b,c]:
           mode => 0644,
         }
         file { [d,e]:
           mode => 0755,
         }
       MANIFEST
     end
     let(:expected_relationships) { [] }
     let(:expected_subscriptions) { [] }
 
     before :each do
       Puppet[:code] = code
     end
 
     after :each do
       catalog = described_class.compile(node)
 
       resources = catalog.resources.select { |res| res.type == 'File' }
 
       actual_relationships, actual_subscriptions = [:before, :notify].map do |relation|
         resources.map do |res|
           dependents = Array(res[relation])
           dependents.map { |ref| [res.title, extract_name(ref)] }
         end.inject(&:concat)
       end
 
       actual_relationships.should =~ expected_relationships
       actual_subscriptions.should =~ expected_subscriptions
     end
 
     it "should create a relationship" do
       code << "File[a] -> File[b]"
 
       expected_relationships << ['a','b']
     end
 
     it "should create a subscription" do
       code << "File[a] ~> File[b]"
 
       expected_subscriptions << ['a', 'b']
     end
 
     it "should create relationships using title arrays" do
       code << "File[a,b] -> File[c,d]"
 
       expected_relationships.concat [
         ['a', 'c'],
         ['b', 'c'],
         ['a', 'd'],
         ['b', 'd'],
       ]
     end
 
     it "should create relationships using collection expressions" do
       code << "File <| mode == 0644 |> -> File <| mode == 0755 |>"
 
       expected_relationships.concat [
         ['a', 'd'],
         ['b', 'd'],
         ['c', 'd'],
         ['a', 'e'],
         ['b', 'e'],
         ['c', 'e'],
       ]
     end
 
     it "should create relationships using resource names" do
       code << "'File[a]' -> 'File[b]'"
 
       expected_relationships << ['a', 'b']
     end
 
     it "should create relationships using variables" do
       code << <<-MANIFEST
         $var = File[a]
         $var -> File[b]
       MANIFEST
 
       expected_relationships << ['a', 'b']
     end
 
     it "should create relationships using case statements" do
       code << <<-MANIFEST
         $var = 10
         case $var {
           10: {
             file { s1: }
           }
           12: {
             file { s2: }
           }
         }
         ->
         case $var + 2 {
           10: {
             file { t1: }
           }
           12: {
             file { t2: }
           }
         }
       MANIFEST
 
       expected_relationships << ['s1', 't2']
     end
 
     it "should create relationships using array members" do
       code << <<-MANIFEST
         $var = [ [ [ File[a], File[b] ] ] ]
         $var[0][0][0] -> $var[0][0][1]
       MANIFEST
 
       expected_relationships << ['a', 'b']
     end
 
     it "should create relationships using hash members" do
       code << <<-MANIFEST
         $var = {'foo' => {'bar' => {'source' => File[a], 'target' => File[b]}}}
         $var[foo][bar][source] -> $var[foo][bar][target]
       MANIFEST
 
       expected_relationships << ['a', 'b']
     end
 
     it "should create relationships using resource declarations" do
       code << "file { l: } -> file { r: }"
 
       expected_relationships << ['l', 'r']
     end
 
     it "should chain relationships" do
       code << "File[a] -> File[b] ~> File[c] <- File[d] <~ File[e]"
 
       expected_relationships << ['a', 'b'] << ['d', 'c']
       expected_subscriptions << ['b', 'c'] << ['e', 'd']
     end
   end
 end
diff --git a/spec/unit/parser/ast/resource_spec.rb b/spec/unit/parser/ast/resource_spec.rb
index 68ad9c229..e4fb946c4 100755
--- a/spec/unit/parser/ast/resource_spec.rb
+++ b/spec/unit/parser/ast/resource_spec.rb
@@ -1,183 +1,183 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Parser::AST::Resource do
   ast = Puppet::Parser::AST
 
   describe "for builtin types" do
     before :each do
       @title = Puppet::Parser::AST::String.new(:value => "mytitle")
       @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
       @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
       @scope.stubs(:resource).returns(stub_everything)
       @instance = ast::ResourceInstance.new(:title => @title, :parameters => ast::ASTArray.new(:children => []))
       @resource = ast::Resource.new(:type => "file", :instances => ast::ASTArray.new(:children => [@instance]))
       @resource.stubs(:qualified_type).returns("Resource")
     end
 
     it "should evaluate all its parameters" do
       param = stub 'param'
       param.expects(:safeevaluate).with(@scope).returns Puppet::Parser::Resource::Param.new(:name => "myparam", :value => "myvalue", :source => stub("source"))
       @instance.stubs(:parameters).returns [param]
 
       @resource.evaluate(@scope)
     end
 
     it "should evaluate its title" do
       @resource.evaluate(@scope)[0].title.should == "mytitle"
     end
 
     it "should flatten the titles array" do
       titles = []
       %w{one two}.each do |title|
         titles << Puppet::Parser::AST::String.new(:value => title)
       end
 
       array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
       @instance.title = array
       result = @resource.evaluate(@scope).collect { |r| r.title }
       result.should be_include("one")
       result.should be_include("two")
     end
 
     it "should create and return one resource objects per title" do
       titles = []
       %w{one two}.each do |title|
         titles << Puppet::Parser::AST::String.new(:value => title)
       end
 
       array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
       @instance.title = array
       result = @resource.evaluate(@scope).collect { |r| r.title }
       result.should be_include("one")
       result.should be_include("two")
     end
 
     it "should implicitly iterate over instances" do
       new_title = Puppet::Parser::AST::String.new(:value => "other_title")
       new_instance = ast::ResourceInstance.new(:title => new_title, :parameters => ast::ASTArray.new(:children => []))
       @resource.instances.push(new_instance)
       @resource.evaluate(@scope).collect { |r| r.title }.should == ["mytitle", "other_title"]
     end
 
     it "should handover resources to the compiler" do
       titles = []
       %w{one two}.each do |title|
         titles << Puppet::Parser::AST::String.new(:value => title)
       end
 
       array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
       @instance.title = array
       result = @resource.evaluate(@scope)
 
       result.each do |res|
         @compiler.catalog.resource(res.ref).should be_instance_of(Puppet::Parser::Resource)
       end
     end
 
     it "should generate virtual resources if it is virtual" do
       @resource.virtual = true
 
       result = @resource.evaluate(@scope)
       result[0].should be_virtual
     end
 
     it "should generate virtual and exported resources if it is exported" do
       @resource.exported = true
 
       result = @resource.evaluate(@scope)
       result[0].should be_virtual
       result[0].should be_exported
     end
 
     # Related to #806, make sure resources always look up the full path to the resource.
     describe "when generating qualified resources" do
       before do
         @scope = Puppet::Parser::Scope.new :compiler => Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
         @parser = Puppet::Parser::Parser.new(Puppet::Node::Environment.new)
         ["one", "one::two", "three"].each do |name|
           @parser.environment.known_resource_types.add(Puppet::Resource::Type.new(:definition, name, {}))
         end
         @twoscope = @scope.newscope(:namespace => "one")
         @twoscope.resource = @scope.resource
       end
 
       def resource(type, params = nil)
         params ||= Puppet::Parser::AST::ASTArray.new(:children => [])
         instance = Puppet::Parser::AST::ResourceInstance.new(
                                                              :title => Puppet::Parser::AST::String.new(:value => "myresource"), :parameters => params)
         Puppet::Parser::AST::Resource.new(:type => type,
                                           :instances => Puppet::Parser::AST::ASTArray.new(:children => [instance]))
       end
 
       it "should be able to generate resources with fully qualified type information" do
         resource("two").evaluate(@twoscope)[0].type.should == "One::Two"
       end
 
       it "should be able to generate resources with unqualified type information" do
         resource("one").evaluate(@twoscope)[0].type.should == "One"
       end
 
       it "should correctly generate resources that can look up builtin types" do
         resource("file").evaluate(@twoscope)[0].type.should == "File"
       end
 
       it "should correctly generate resources that can look up defined classes by title" do
         @scope.known_resource_types.add_hostclass Puppet::Resource::Type.new(:hostclass, "Myresource", {})
         @scope.compiler.stubs(:evaluate_classes)
         res = resource("class").evaluate(@twoscope)[0]
         res.type.should == "Class"
         res.title.should == "Myresource"
       end
 
       it "should evaluate parameterized classes when they are instantiated" do
         @scope.known_resource_types.add_hostclass Puppet::Resource::Type.new(:hostclass, "Myresource", {})
-        @scope.compiler.expects(:evaluate_classes).with(['myresource'],@twoscope,false)
+        @scope.compiler.expects(:evaluate_classes).with(['myresource'],@twoscope,false,true)
         resource("class").evaluate(@twoscope)[0]
       end
 
       it "should fail for resource types that do not exist" do
         lambda { resource("nosuchtype").evaluate(@twoscope) }.should raise_error(Puppet::ParseError)
       end
     end
   end
 
   describe "for class resources" do
     before do
       @title = Puppet::Parser::AST::String.new(:value => "classname")
       @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
       @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
       @scope.stubs(:resource).returns(stub_everything)
       @instance = ast::ResourceInstance.new(:title => @title, :parameters => ast::ASTArray.new(:children => []))
       @resource = ast::Resource.new(:type => "Class", :instances => ast::ASTArray.new(:children => [@instance]))
       @resource.stubs(:qualified_type).returns("Resource")
       @type = Puppet::Resource::Type.new(:hostclass, "classname")
       @compiler.known_resource_types.add(@type)
     end
 
     it "should instantiate the class" do
       @compiler.stubs(:evaluate_classes)
       result = @resource.evaluate(@scope)
       result.length.should == 1
       result.first.ref.should == "Class[Classname]"
       @compiler.catalog.resource("Class[Classname]").should equal(result.first)
     end
 
     it "should cause its parent to be evaluated" do
       parent_type = Puppet::Resource::Type.new(:hostclass, "parentname")
       @compiler.stubs(:evaluate_classes)
       @compiler.known_resource_types.add(parent_type)
       @type.parent = "parentname"
       result = @resource.evaluate(@scope)
       result.length.should == 1
       result.first.ref.should == "Class[Classname]"
       @compiler.catalog.resource("Class[Classname]").should equal(result.first)
       @compiler.catalog.resource("Class[Parentname]").should be_instance_of(Puppet::Parser::Resource)
     end
 
   end
 
 end
diff --git a/spec/unit/parser/compiler_spec.rb b/spec/unit/parser/compiler_spec.rb
index b38050b87..e545dde6d 100755
--- a/spec/unit/parser/compiler_spec.rb
+++ b/spec/unit/parser/compiler_spec.rb
@@ -1,805 +1,805 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 class CompilerTestResource
   attr_accessor :builtin, :virtual, :evaluated, :type, :title
 
   def initialize(type, title)
     @type = type
     @title = title
   end
 
   def [](attr)
     return nil if attr == :stage
     :main
   end
 
   def ref
     "#{type.to_s.capitalize}[#{title}]"
   end
 
   def evaluated?
     @evaluated
   end
 
   def builtin_type?
     @builtin
   end
 
   def virtual?
     @virtual
   end
 
   def evaluate
   end
 
   def file
     "/fake/file/goes/here"
   end
 
   def line
     "42"
   end
 end
 
 describe Puppet::Parser::Compiler do
   include PuppetSpec::Files
 
   def resource(type, title)
     Puppet::Parser::Resource.new(type, title, :scope => @scope)
   end
 
   before :each do
     # Push me faster, I wanna go back in time!  (Specifically, freeze time
     # across the test since we have a bunch of version == timestamp code
     # hidden away in the implementation and we keep losing the race.)
     # --daniel 2011-04-21
     now = Time.now
     Time.stubs(:now).returns(now)
 
     @node = Puppet::Node.new "testnode"
     @known_resource_types = Puppet::Resource::TypeCollection.new "development"
     @compiler = Puppet::Parser::Compiler.new(@node)
     @scope = Puppet::Parser::Scope.new(:compiler => @compiler, :source => stub('source'))
     @scope_resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope)
     @scope.resource = @scope_resource
     @compiler.environment.stubs(:known_resource_types).returns @known_resource_types
   end
 
   it "should have a class method that compiles, converts, and returns a catalog" do
     compiler = stub 'compiler'
     Puppet::Parser::Compiler.expects(:new).with(@node).returns compiler
     catalog = stub 'catalog'
     compiler.expects(:compile).returns catalog
     converted_catalog = stub 'converted_catalog'
     catalog.expects(:to_resource).returns converted_catalog
 
     Puppet::Parser::Compiler.compile(@node).should equal(converted_catalog)
   end
 
   it "should fail intelligently when a class-level compile fails" do
     Puppet::Parser::Compiler.expects(:new).raises ArgumentError
     lambda { Puppet::Parser::Compiler.compile(@node) }.should raise_error(Puppet::Error)
   end
 
   it "should use the node's environment as its environment" do
     @compiler.environment.should equal(@node.environment)
   end
 
   it "should include the resource type collection helper" do
     Puppet::Parser::Compiler.ancestors.should be_include(Puppet::Resource::TypeCollectionHelper)
   end
 
   it "should be able to return a class list containing all added classes" do
     @compiler.add_class ""
     @compiler.add_class "one"
     @compiler.add_class "two"
 
     @compiler.classlist.sort.should == %w{one two}.sort
   end
 
   describe "when initializing" do
 
     it "should set its node attribute" do
       @compiler.node.should equal(@node)
     end
     it "should detect when ast nodes are absent" do
       @compiler.ast_nodes?.should be_false
     end
 
     it "should detect when ast nodes are present" do
       @known_resource_types.expects(:nodes?).returns true
       @compiler.ast_nodes?.should be_true
     end
 
     it "should copy the known_resource_types version to the catalog" do
       @compiler.catalog.version.should == @known_resource_types.version
     end
 
     it "should copy any node classes into the class list" do
       node = Puppet::Node.new("mynode")
       node.classes = %w{foo bar}
       compiler = Puppet::Parser::Compiler.new(node)
 
       compiler.classlist.should =~ ['foo', 'bar']
     end
 
     it "should transform node class hashes into a class list" do
       node = Puppet::Node.new("mynode")
       node.classes = {'foo'=>{'one'=>'1'}, 'bar'=>{'two'=>'2'}}
       compiler = Puppet::Parser::Compiler.new(node)
 
       compiler.classlist.should =~ ['foo', 'bar']
     end
 
     it "should add a 'main' stage to the catalog" do
       @compiler.catalog.resource(:stage, :main).should be_instance_of(Puppet::Parser::Resource)
     end
   end
 
   describe "when managing scopes" do
 
     it "should create a top scope" do
       @compiler.topscope.should be_instance_of(Puppet::Parser::Scope)
     end
 
     it "should be able to create new scopes" do
       @compiler.newscope(@compiler.topscope).should be_instance_of(Puppet::Parser::Scope)
     end
 
     it "should set the parent scope of the new scope to be the passed-in parent" do
       scope = mock 'scope'
       newscope = @compiler.newscope(scope)
 
       newscope.parent.should equal(scope)
     end
 
     it "should set the parent scope of the new scope to its topscope if the parent passed in is nil" do
       scope = mock 'scope'
       newscope = @compiler.newscope(nil)
 
       newscope.parent.should equal(@compiler.topscope)
     end
   end
 
   describe "when compiling" do
 
     def compile_methods
       [:set_node_parameters, :evaluate_main, :evaluate_ast_node, :evaluate_node_classes, :evaluate_generators, :fail_on_unevaluated,
         :finish, :store, :extract, :evaluate_relationships]
     end
 
     # Stub all of the main compile methods except the ones we're specifically interested in.
     def compile_stub(*except)
       (compile_methods - except).each { |m| @compiler.stubs(m) }
     end
 
     it "should set node parameters as variables in the top scope" do
       params = {"a" => "b", "c" => "d"}
       @node.stubs(:parameters).returns(params)
       compile_stub(:set_node_parameters)
       @compiler.compile
       @compiler.topscope['a'].should == "b"
       @compiler.topscope['c'].should == "d"
     end
 
     it "should set the client and server versions on the catalog" do
       params = {"clientversion" => "2", "serverversion" => "3"}
       @node.stubs(:parameters).returns(params)
       compile_stub(:set_node_parameters)
       @compiler.compile
       @compiler.catalog.client_version.should == "2"
       @compiler.catalog.server_version.should == "3"
     end
 
     it "should evaluate any existing classes named in the node" do
       classes = %w{one two three four}
       main = stub 'main'
       one = stub 'one', :name => "one"
       three = stub 'three', :name => "three"
       @node.stubs(:name).returns("whatever")
       @node.stubs(:classes).returns(classes)
 
       @compiler.expects(:evaluate_classes).with(classes, @compiler.topscope)
       @compiler.class.publicize_methods(:evaluate_node_classes) { @compiler.evaluate_node_classes }
     end
 
     it "should evaluate any parameterized classes named in the node" do
       classes = {'foo'=>{'1'=>'one'}, 'bar'=>{'2'=>'two'}}
       @node.stubs(:classes).returns(classes)
       @compiler.expects(:evaluate_classes).with(classes, @compiler.topscope)
       @compiler.compile
     end
 
 
     it "should evaluate the main class if it exists" do
       compile_stub(:evaluate_main)
       main_class = @known_resource_types.add Puppet::Resource::Type.new(:hostclass, "")
       main_class.expects(:evaluate_code).with { |r| r.is_a?(Puppet::Parser::Resource) }
       @compiler.topscope.expects(:source=).with(main_class)
 
       @compiler.compile
     end
 
     it "should create a new, empty 'main' if no main class exists" do
       compile_stub(:evaluate_main)
       @compiler.compile
       @known_resource_types.find_hostclass([""], "").should be_instance_of(Puppet::Resource::Type)
     end
 
     it "should add an edge between the main stage and main class" do
       @compiler.compile
       (stage = @compiler.catalog.resource(:stage, "main")).should be_instance_of(Puppet::Parser::Resource)
       (klass = @compiler.catalog.resource(:class, "")).should be_instance_of(Puppet::Parser::Resource)
 
       @compiler.catalog.edge?(stage, klass).should be_true
     end
 
     it "should evaluate any node classes" do
       @node.stubs(:classes).returns(%w{one two three four})
       @compiler.expects(:evaluate_classes).with(%w{one two three four}, @compiler.topscope)
       @compiler.send(:evaluate_node_classes)
     end
 
     it "should evaluate all added collections" do
       colls = []
       # And when the collections fail to evaluate.
       colls << mock("coll1-false")
       colls << mock("coll2-false")
       colls.each { |c| c.expects(:evaluate).returns(false) }
 
       @compiler.add_collection(colls[0])
       @compiler.add_collection(colls[1])
 
       compile_stub(:evaluate_generators)
       @compiler.compile
     end
 
     it "should ignore builtin resources" do
       resource = resource(:file, "testing")
 
       @compiler.add_resource(@scope, resource)
       resource.expects(:evaluate).never
 
       @compiler.compile
     end
 
     it "should evaluate unevaluated resources" do
       resource = CompilerTestResource.new(:file, "testing")
 
       @compiler.add_resource(@scope, resource)
 
       # We have to now mark the resource as evaluated
       resource.expects(:evaluate).with { |*whatever| resource.evaluated = true }
 
       @compiler.compile
     end
 
     it "should not evaluate already-evaluated resources" do
       resource = resource(:file, "testing")
       resource.stubs(:evaluated?).returns true
 
       @compiler.add_resource(@scope, resource)
       resource.expects(:evaluate).never
 
       @compiler.compile
     end
 
     it "should evaluate unevaluated resources created by evaluating other resources" do
       resource = CompilerTestResource.new(:file, "testing")
       @compiler.add_resource(@scope, resource)
 
       resource2 = CompilerTestResource.new(:file, "other")
 
       # We have to now mark the resource as evaluated
       resource.expects(:evaluate).with { |*whatever| resource.evaluated = true; @compiler.add_resource(@scope, resource2) }
       resource2.expects(:evaluate).with { |*whatever| resource2.evaluated = true }
 
 
       @compiler.compile
     end
 
     describe "when finishing" do
       before do
         @compiler.send(:evaluate_main)
         @catalog = @compiler.catalog
       end
 
       def add_resource(name, parent = nil)
         resource = Puppet::Parser::Resource.new "file", name, :scope => @scope
         @compiler.add_resource(@scope, resource)
         @catalog.add_edge(parent, resource) if parent
         resource
       end
 
       it "should call finish() on all resources" do
         # Add a resource that does respond to :finish
         resource = Puppet::Parser::Resource.new "file", "finish", :scope => @scope
         resource.expects(:finish)
 
         @compiler.add_resource(@scope, resource)
 
         # And one that does not
         dnf_resource = stub_everything "dnf", :ref => "File[dnf]", :type => "file"
 
         @compiler.add_resource(@scope, dnf_resource)
 
         @compiler.send(:finish)
       end
 
       it "should call finish() in add_resource order" do
         resources = sequence('resources')
 
         resource1 = add_resource("finish1")
         resource1.expects(:finish).in_sequence(resources)
 
         resource2 = add_resource("finish2")
         resource2.expects(:finish).in_sequence(resources)
 
         @compiler.send(:finish)
       end
 
       it "should add each container's metaparams to its contained resources" do
         main = @catalog.resource(:class, :main)
         main[:noop] = true
 
         resource1 = add_resource("meh", main)
 
         @compiler.send(:finish)
         resource1[:noop].should be_true
       end
 
       it "should add metaparams recursively" do
         main = @catalog.resource(:class, :main)
         main[:noop] = true
 
         resource1 = add_resource("meh", main)
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
         resource2[:noop].should be_true
       end
 
       it "should prefer metaparams from immediate parents" do
         main = @catalog.resource(:class, :main)
         main[:noop] = true
 
         resource1 = add_resource("meh", main)
         resource2 = add_resource("foo", resource1)
 
         resource1[:noop] = false
 
         @compiler.send(:finish)
         resource2[:noop].should be_false
       end
 
       it "should merge tags downward" do
         main = @catalog.resource(:class, :main)
         main.tag("one")
 
         resource1 = add_resource("meh", main)
         resource1.tag "two"
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
         resource2.tags.should be_include("one")
         resource2.tags.should be_include("two")
       end
 
       it "should work if only middle resources have metaparams set" do
         main = @catalog.resource(:class, :main)
 
         resource1 = add_resource("meh", main)
         resource1[:noop] = true
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
         resource2[:noop].should be_true
       end
     end
 
     it "should return added resources in add order" do
       resource1 = resource(:file, "yay")
       @compiler.add_resource(@scope, resource1)
       resource2 = resource(:file, "youpi")
       @compiler.add_resource(@scope, resource2)
 
       @compiler.resources.should == [resource1, resource2]
     end
 
     it "should add resources that do not conflict with existing resources" do
       resource = resource(:file, "yay")
       @compiler.add_resource(@scope, resource)
 
       @compiler.catalog.should be_vertex(resource)
     end
 
     it "should fail to add resources that conflict with existing resources" do
       path = make_absolute("/foo")
       file1 = Puppet::Type.type(:file).new :path => path
       file2 = Puppet::Type.type(:file).new :path => path
 
       @compiler.add_resource(@scope, file1)
       lambda { @compiler.add_resource(@scope, file2) }.should raise_error(Puppet::Resource::Catalog::DuplicateResourceError)
     end
 
     it "should add an edge from the scope resource to the added resource" do
       resource = resource(:file, "yay")
       @compiler.add_resource(@scope, resource)
 
       @compiler.catalog.should be_edge(@scope.resource, resource)
     end
 
     it "should not add non-class resources that don't specify a stage to the 'main' stage" do
       main = @compiler.catalog.resource(:stage, :main)
       resource = resource(:file, "foo")
       @compiler.add_resource(@scope, resource)
 
       @compiler.catalog.should_not be_edge(main, resource)
     end
 
     it "should not add any parent-edges to stages" do
       stage = resource(:stage, "other")
       @compiler.add_resource(@scope, stage)
 
       @scope.resource = resource(:class, "foo")
 
       @compiler.catalog.edge?(@scope.resource, stage).should be_false
     end
 
     it "should not attempt to add stages to other stages" do
       other_stage = resource(:stage, "other")
       second_stage = resource(:stage, "second")
       @compiler.add_resource(@scope, other_stage)
       @compiler.add_resource(@scope, second_stage)
 
       second_stage[:stage] = "other"
 
       @compiler.catalog.edge?(other_stage, second_stage).should be_false
     end
 
     it "should have a method for looking up resources" do
       resource = resource(:yay, "foo")
       @compiler.add_resource(@scope, resource)
       @compiler.findresource("Yay[foo]").should equal(resource)
     end
 
     it "should be able to look resources up by type and title" do
       resource = resource(:yay, "foo")
       @compiler.add_resource(@scope, resource)
       @compiler.findresource("Yay", "foo").should equal(resource)
     end
 
     it "should not evaluate virtual defined resources" do
       resource = resource(:file, "testing")
       resource.virtual = true
       @compiler.add_resource(@scope, resource)
 
       resource.expects(:evaluate).never
 
       @compiler.compile
     end
   end
 
   describe "when evaluating collections" do
 
     it "should evaluate each collection" do
       2.times { |i|
         coll = mock 'coll%s' % i
         @compiler.add_collection(coll)
 
         # This is the hard part -- we have to emulate the fact that
         # collections delete themselves if they are done evaluating.
         coll.expects(:evaluate).with do
           @compiler.delete_collection(coll)
         end
       }
 
       @compiler.class.publicize_methods(:evaluate_collections) { @compiler.evaluate_collections }
     end
 
     it "should not fail when there are unevaluated resource collections that do not refer to specific resources" do
       coll = stub 'coll', :evaluate => false
       coll.expects(:resources).returns(nil)
 
       @compiler.add_collection(coll)
 
       lambda { @compiler.compile }.should_not raise_error
     end
 
     it "should fail when there are unevaluated resource collections that refer to a specific resource" do
       coll = stub 'coll', :evaluate => false
       coll.expects(:resources).returns(:something)
 
       @compiler.add_collection(coll)
 
       lambda { @compiler.compile }.should raise_error Puppet::ParseError, 'Failed to realize virtual resources something'
     end
 
     it "should fail when there are unevaluated resource collections that refer to multiple specific resources" do
       coll = stub 'coll', :evaluate => false
       coll.expects(:resources).returns([:one, :two])
 
       @compiler.add_collection(coll)
 
       lambda { @compiler.compile }.should raise_error Puppet::ParseError, 'Failed to realize virtual resources one, two'
     end
   end
 
   describe "when evaluating relationships" do
     it "should evaluate each relationship with its catalog" do
       dep = stub 'dep'
       dep.expects(:evaluate).with(@compiler.catalog)
       @compiler.add_relationship dep
       @compiler.evaluate_relationships
     end
   end
 
   describe "when told to evaluate missing classes" do
 
     it "should fail if there's no source listed for the scope" do
       scope = stub 'scope', :source => nil
       proc { @compiler.evaluate_classes(%w{one two}, scope) }.should raise_error(Puppet::DevError)
     end
 
     it "should raise an error if a class is not found" do
-      @scope.expects(:find_hostclass).with("notfound").returns(nil)
+      @scope.expects(:find_hostclass).with("notfound", {:assume_fqname => false}).returns(nil)
       lambda{ @compiler.evaluate_classes(%w{notfound}, @scope) }.should raise_error(Puppet::Error, /Could not find class/)
     end
 
     it "should raise an error when it can't find class" do
       klasses = {'foo'=>nil}
       @node.classes = klasses
-      @compiler.topscope.stubs(:find_hostclass).with('foo').returns(nil)
+      @compiler.topscope.stubs(:find_hostclass).with('foo', {:assume_fqname => false}).returns(nil)
       lambda{ @compiler.compile }.should raise_error(Puppet::Error, /Could not find class foo for testnode/)
     end
   end
 
   describe "when evaluating found classes" do
 
     before do
       @class = stub 'class', :name => "my::class"
-      @scope.stubs(:find_hostclass).with("myclass").returns(@class)
+      @scope.stubs(:find_hostclass).with("myclass", {:assume_fqname => false}).returns(@class)
 
       @resource = stub 'resource', :ref => "Class[myclass]", :type => "file"
     end
 
     it "should evaluate each class" do
       @compiler.catalog.stubs(:tag)
 
       @class.expects(:ensure_in_catalog).with(@scope)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope)
     end
 
     describe "and the classes are specified as a hash with parameters" do
       before do
         @node.classes = {}
         @ast_obj = Puppet::Parser::AST::String.new(:value => 'foo')
       end
 
       # Define the given class with default parameters
       def define_class(name, parameters)
         @node.classes[name] = parameters
         klass = Puppet::Resource::Type.new(:hostclass, name, :arguments => {'1' => @ast_obj, '2' => @ast_obj})
         @compiler.topscope.known_resource_types.add klass
       end
 
       def compile
         @catalog = @compiler.compile
       end
 
       it "should record which classes are evaluated" do
         classes = {'foo'=>{}, 'bar::foo'=>{}, 'bar'=>{}}
         classes.each { |c, params| define_class(c, params) }
         compile()
         classes.each { |name, p| @catalog.classes.should include(name) }
       end
 
       it "should provide default values for parameters that have no values specified" do
         define_class('foo', {})
         compile()
         @catalog.resource(:class, 'foo')['1'].should == "foo"
       end
 
       it "should use any provided values" do
         define_class('foo', {'1' => 'real_value'})
         compile()
         @catalog.resource(:class, 'foo')['1'].should == "real_value"
       end
 
       it "should support providing some but not all values" do
         define_class('foo', {'1' => 'real_value'})
         compile()
         @catalog.resource(:class, 'Foo')['1'].should == "real_value"
         @catalog.resource(:class, 'Foo')['2'].should == "foo"
       end
 
       it "should ensure each node class is in catalog and has appropriate tags" do
         klasses = ['bar::foo']
         @node.classes = klasses
         ast_obj = Puppet::Parser::AST::String.new(:value => 'foo')
         klasses.each do |name|
           klass = Puppet::Resource::Type.new(:hostclass, name, :arguments => {'1' => ast_obj, '2' => ast_obj})
           @compiler.topscope.known_resource_types.add klass
         end
         catalog = @compiler.compile
 
         r2 = catalog.resources.detect {|r| r.title == 'Bar::Foo' }
         r2.tags.should =~ ['bar::foo', 'class', 'bar', 'foo']
       end
     end
 
     it "should fail if required parameters are missing" do
       klass = {'foo'=>{'1'=>'one'}}
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {'1' => nil, '2' => nil})
       @compiler.topscope.known_resource_types.add klass
       lambda { @compiler.compile }.should raise_error(Puppet::ParseError, "Must pass 2 to Class[Foo]")
     end
 
     it "should fail if invalid parameters are passed" do
       klass = {'foo'=>{'3'=>'one'}}
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {})
       @compiler.topscope.known_resource_types.add klass
       lambda { @compiler.compile }.should raise_error(Puppet::ParseError, "Invalid parameter 3")
     end
 
     it "should ensure class is in catalog without params" do
       @node.classes = klasses = {'foo'=>nil}
       foo = Puppet::Resource::Type.new(:hostclass, 'foo')
       @compiler.topscope.known_resource_types.add foo
       catalog = @compiler.compile
       catalog.classes.should include 'foo'
     end
 
     it "should not evaluate the resources created for found classes unless asked" do
       @compiler.catalog.stubs(:tag)
 
       @resource.expects(:evaluate).never
 
       @class.expects(:ensure_in_catalog).returns(@resource)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope)
     end
 
     it "should immediately evaluate the resources created for found classes when asked" do
       @compiler.catalog.stubs(:tag)
 
       @resource.expects(:evaluate)
       @class.expects(:ensure_in_catalog).returns(@resource)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope, false)
     end
 
     it "should skip classes that have already been evaluated" do
       @compiler.catalog.stubs(:tag)
 
       @scope.stubs(:class_scope).with(@class).returns("something")
 
       @compiler.expects(:add_resource).never
 
       @resource.expects(:evaluate).never
 
       Puppet::Parser::Resource.expects(:new).never
       @compiler.evaluate_classes(%w{myclass}, @scope, false)
     end
 
     it "should skip classes previously evaluated with different capitalization" do
       @compiler.catalog.stubs(:tag)
-      @scope.stubs(:find_hostclass).with("MyClass").returns(@class)
+      @scope.stubs(:find_hostclass).with("MyClass",{:assume_fqname => false}).returns(@class)
       @scope.stubs(:class_scope).with(@class).returns("something")
       @compiler.expects(:add_resource).never
       @resource.expects(:evaluate).never
       Puppet::Parser::Resource.expects(:new).never
       @compiler.evaluate_classes(%w{MyClass}, @scope, false)
     end
   end
 
   describe "when evaluating AST nodes with no AST nodes present" do
 
     it "should do nothing" do
       @compiler.expects(:ast_nodes?).returns(false)
       @compiler.known_resource_types.expects(:nodes).never
       Puppet::Parser::Resource.expects(:new).never
 
       @compiler.send(:evaluate_ast_node)
     end
   end
 
   describe "when evaluating AST nodes with AST nodes present" do
 
     before do
       @compiler.known_resource_types.stubs(:nodes?).returns true
 
       # Set some names for our test
       @node.stubs(:names).returns(%w{a b c})
       @compiler.known_resource_types.stubs(:node).with("a").returns(nil)
       @compiler.known_resource_types.stubs(:node).with("b").returns(nil)
       @compiler.known_resource_types.stubs(:node).with("c").returns(nil)
 
       # It should check this last, of course.
       @compiler.known_resource_types.stubs(:node).with("default").returns(nil)
     end
 
     it "should fail if the named node cannot be found" do
       proc { @compiler.send(:evaluate_ast_node) }.should raise_error(Puppet::ParseError)
     end
 
     it "should evaluate the first node class matching the node name" do
       node_class = stub 'node', :name => "c", :evaluate_code => nil
       @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil, :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       @compiler.compile
     end
 
     it "should match the default node if no matching node can be found" do
       node_class = stub 'node', :name => "default", :evaluate_code => nil
       @compiler.known_resource_types.stubs(:node).with("default").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[default]", :evaluate => nil, :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       @compiler.compile
     end
 
     it "should evaluate the node resource immediately rather than using lazy evaluation" do
       node_class = stub 'node', :name => "c"
       @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       node_resource.expects(:evaluate)
 
       @compiler.send(:evaluate_ast_node)
     end
   end
 
   describe "when managing resource overrides" do
 
     before do
       @override = stub 'override', :ref => "File[/foo]", :type => "my"
       @resource = resource(:file, "/foo")
     end
 
     it "should be able to store overrides" do
       lambda { @compiler.add_override(@override) }.should_not raise_error
     end
 
     it "should apply overrides to the appropriate resources" do
       @compiler.add_resource(@scope, @resource)
       @resource.expects(:merge).with(@override)
 
       @compiler.add_override(@override)
 
       @compiler.compile
     end
 
     it "should accept overrides before the related resource has been created" do
       @resource.expects(:merge).with(@override)
 
       # First store the override
       @compiler.add_override(@override)
 
       # Then the resource
       @compiler.add_resource(@scope, @resource)
 
       # And compile, so they get resolved
       @compiler.compile
     end
 
     it "should fail if the compile is finished and resource overrides have not been applied" do
       @compiler.add_override(@override)
 
       lambda { @compiler.compile }.should raise_error Puppet::ParseError, 'Could not find resource(s) File[/foo] for overriding'
     end
   end
 end
diff --git a/spec/unit/parser/parser_spec.rb b/spec/unit/parser/parser_spec.rb
index ad232d26a..d25d88066 100755
--- a/spec/unit/parser/parser_spec.rb
+++ b/spec/unit/parser/parser_spec.rb
@@ -1,520 +1,520 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Parser do
 
   Puppet::Parser::AST
 
   before :each do
     @known_resource_types = Puppet::Resource::TypeCollection.new("development")
     @parser = Puppet::Parser::Parser.new "development"
     @parser.stubs(:known_resource_types).returns @known_resource_types
     @true_ast = Puppet::Parser::AST::Boolean.new :value => true
   end
 
   it "should require an environment at initialization" do
     expect { Puppet::Parser::Parser.new }.should raise_error(ArgumentError)
   end
 
   it "should set the environment" do
     env = Puppet::Node::Environment.new
     Puppet::Parser::Parser.new(env).environment.should == env
   end
 
   it "should convert the environment into an environment instance if a string is provided" do
     env = Puppet::Node::Environment.new("testing")
     Puppet::Parser::Parser.new("testing").environment.should == env
   end
 
   it "should be able to look up the environment-specific resource type collection" do
     rtc = Puppet::Node::Environment.new("development").known_resource_types
     parser = Puppet::Parser::Parser.new "development"
     parser.known_resource_types.should equal(rtc)
   end
 
   context "when importing" do
     it "should delegate importing to the known resource type loader" do
       parser = Puppet::Parser::Parser.new "development"
       parser.known_resource_types.loader.expects(:import).with("newfile", "current_file")
       parser.lexer.expects(:file).returns "current_file"
       parser.import("newfile")
     end
 
     it "should import multiple files on one line" do
       @parser.known_resource_types.loader.expects(:import).with('one', nil)
       @parser.known_resource_types.loader.expects(:import).with('two', nil)
       @parser.parse("import 'one', 'two'")
     end
   end
 
   describe "when parsing files" do
     before do
       FileTest.stubs(:exist?).returns true
       File.stubs(:read).returns ""
       @parser.stubs(:watch_file)
     end
 
     it "should treat files ending in 'rb' as ruby files" do
       @parser.expects(:parse_ruby_file)
       @parser.file = "/my/file.rb"
       @parser.parse
     end
   end
 
   describe "when parsing append operator" do
 
     it "should not raise syntax errors" do
       expect { @parser.parse("$var += something") }.should_not raise_error
     end
 
     it "shouldraise syntax error on incomplete syntax " do
       expect { @parser.parse("$var += ") }.should raise_error
     end
 
     it "should create ast::VarDef with append=true" do
       vardef = @parser.parse("$var += 2").code[0]
       vardef.should be_a(Puppet::Parser::AST::VarDef)
       vardef.append.should == true
     end
 
     it "should work with arrays too" do
       vardef = @parser.parse("$var += ['test']").code[0]
       vardef.should be_a(Puppet::Parser::AST::VarDef)
       vardef.append.should == true
     end
 
   end
 
   describe "when parsing selector" do
     it "should support hash access on the left hand side" do
       expect { @parser.parse("$h = { 'a' => 'b' } $a = $h['a'] ? { 'b' => 'd', default => undef }") }.should_not raise_error
     end
   end
 
   describe "parsing 'unless'" do
     it "should create the correct ast objects" do
       Puppet::Parser::AST::Not.expects(:new).with { |h| h[:value].is_a?(Puppet::Parser::AST::Boolean) }
       @parser.parse("unless false { $var = 1 }")
     end
     
     it "should not raise an error with empty statements" do
       expect { @parser.parse("unless false { }") }.should_not raise_error
     end
     
     #test for bug #13296
     it "should not override 'unless' as a parameter inside resources" do
       lambda { @parser.parse("exec {'/bin/echo foo': unless => '/usr/bin/false',}") }.should_not raise_error
     end
   end
 
   describe "when parsing parameter names" do
     Puppet::Parser::Lexer::KEYWORDS.sort_tokens.each do |keyword|
       it "should allow #{keyword} as a keyword" do
         lambda { @parser.parse("exec {'/bin/echo foo': #{keyword} => '/usr/bin/false',}") }.should_not raise_error
       end
     end
   end
 
   describe "when parsing 'if'" do
     it "not, it should create the correct ast objects" do
       Puppet::Parser::AST::Not.expects(:new).with { |h| h[:value].is_a?(Puppet::Parser::AST::Boolean) }
       @parser.parse("if ! true { $var = 1 }")
     end
 
     it "boolean operation, it should create the correct ast objects" do
       Puppet::Parser::AST::BooleanOperator.expects(:new).with {
         |h| h[:rval].is_a?(Puppet::Parser::AST::Boolean) and h[:lval].is_a?(Puppet::Parser::AST::Boolean) and h[:operator]=="or"
       }
       @parser.parse("if true or true { $var = 1 }")
 
     end
 
     it "comparison operation, it should create the correct ast objects" do
       Puppet::Parser::AST::ComparisonOperator.expects(:new).with {
         |h| h[:lval].is_a?(Puppet::Parser::AST::Name) and h[:rval].is_a?(Puppet::Parser::AST::Name) and h[:operator]=="<"
       }
       @parser.parse("if 1 < 2 { $var = 1 }")
 
     end
 
   end
 
   describe "when parsing if complex expressions" do
     it "should create a correct ast tree" do
       aststub = stub_everything 'ast'
       Puppet::Parser::AST::ComparisonOperator.expects(:new).with {
         |h| h[:rval].is_a?(Puppet::Parser::AST::Name) and h[:lval].is_a?(Puppet::Parser::AST::Name) and h[:operator]==">"
       }.returns(aststub)
       Puppet::Parser::AST::ComparisonOperator.expects(:new).with {
         |h| h[:rval].is_a?(Puppet::Parser::AST::Name) and h[:lval].is_a?(Puppet::Parser::AST::Name) and h[:operator]=="=="
       }.returns(aststub)
       Puppet::Parser::AST::BooleanOperator.expects(:new).with {
         |h| h[:rval]==aststub and h[:lval]==aststub and h[:operator]=="and"
       }
       @parser.parse("if (1 > 2) and (1 == 2) { $var = 1 }")
     end
 
     it "should raise an error on incorrect expression" do
       expect { @parser.parse("if (1 > 2 > ) or (1 == 2) { $var = 1 }") }.should raise_error
     end
 
   end
 
   describe "when parsing resource references" do
 
     it "should not raise syntax errors" do
       expect { @parser.parse('exec { test: param => File["a"] }') }.should_not raise_error
     end
 
     it "should not raise syntax errors with multiple references" do
       expect { @parser.parse('exec { test: param => File["a","b"] }') }.should_not raise_error
     end
 
     it "should create an ast::ResourceReference" do
       Puppet::Parser::AST::ResourceReference.expects(:new).with { |arg|
         arg[:line]==1 and arg[:type]=="File" and arg[:title].is_a?(Puppet::Parser::AST::ASTArray)
       }
       @parser.parse('exec { test: command => File["a","b"] }')
     end
   end
 
   describe "when parsing resource overrides" do
 
     it "should not raise syntax errors" do
       expect { @parser.parse('Resource["title"] { param => value }') }.should_not raise_error
     end
 
     it "should not raise syntax errors with multiple overrides" do
       expect { @parser.parse('Resource["title1","title2"] { param => value }') }.should_not raise_error
     end
 
     it "should create an ast::ResourceOverride" do
       #Puppet::Parser::AST::ResourceOverride.expects(:new).with { |arg|
       #  arg[:line]==1 and arg[:object].is_a?(Puppet::Parser::AST::ResourceReference) and arg[:parameters].is_a?(Puppet::Parser::AST::ResourceParam)
       #}
       ro = @parser.parse('Resource["title1","title2"] { param => value }').code[0]
       ro.should be_a(Puppet::Parser::AST::ResourceOverride)
       ro.line.should == 1
       ro.object.should be_a(Puppet::Parser::AST::ResourceReference)
       ro.parameters[0].should be_a(Puppet::Parser::AST::ResourceParam)
     end
 
   end
 
   describe "when parsing if statements" do
 
     it "should not raise errors with empty if" do
       expect { @parser.parse("if true { }") }.should_not raise_error
     end
 
     it "should not raise errors with empty else" do
       expect { @parser.parse("if false { notice('if') } else { }") }.should_not raise_error
     end
 
     it "should not raise errors with empty if and else" do
       expect { @parser.parse("if false { } else { }") }.should_not raise_error
     end
 
     it "should create a nop node for empty branch" do
       Puppet::Parser::AST::Nop.expects(:new)
       @parser.parse("if true { }")
     end
 
     it "should create a nop node for empty else branch" do
       Puppet::Parser::AST::Nop.expects(:new)
       @parser.parse("if true { notice('test') } else { }")
     end
 
     it "should build a chain of 'ifs' if there's an 'elsif'" do
       expect { @parser.parse(<<-PP) }.should_not raise_error
         if true { notice('test') } elsif true {} else { }
       PP
     end
 
   end
 
   describe "when parsing function calls" do
     it "should not raise errors with no arguments" do
       expect { @parser.parse("tag()") }.should_not raise_error
     end
 
     it "should not raise errors with rvalue function with no args" do
       expect { @parser.parse("$a = template()") }.should_not raise_error
     end
 
     it "should not raise errors with arguments" do
       expect { @parser.parse("notice(1)") }.should_not raise_error
     end
 
     it "should not raise errors with multiple arguments" do
       expect { @parser.parse("notice(1,2)") }.should_not raise_error
     end
 
     it "should not raise errors with multiple arguments and a trailing comma" do
       expect { @parser.parse("notice(1,2,)") }.should_not raise_error
     end
 
   end
 
   describe "when parsing arrays" do
     it "should parse an array" do
       expect { @parser.parse("$a = [1,2]") }.should_not raise_error
     end
 
     it "should not raise errors with a trailing comma" do
       expect { @parser.parse("$a = [1,2,]") }.should_not raise_error
     end
 
     it "should accept an empty array" do
       expect { @parser.parse("$var = []\n") }.should_not raise_error
     end
   end
 
   describe "when providing AST context" do
     before do
       @lexer = stub 'lexer', :line => 50, :file => "/foo/bar", :getcomment => "whev"
       @parser.stubs(:lexer).returns @lexer
     end
 
     it "should include the lexer's line" do
       @parser.ast_context[:line].should == 50
     end
 
     it "should include the lexer's file" do
       @parser.ast_context[:file].should == "/foo/bar"
     end
 
     it "should include the docs if directed to do so" do
       @parser.ast_context(true)[:doc].should == "whev"
     end
 
     it "should not include the docs when told not to" do
       @parser.ast_context(false)[:doc].should be_nil
     end
 
     it "should not include the docs by default" do
       @parser.ast_context[:doc].should be_nil
     end
   end
 
   describe "when building ast nodes" do
     before do
       @lexer = stub 'lexer', :line => 50, :file => "/foo/bar", :getcomment => "whev"
       @parser.stubs(:lexer).returns @lexer
       @class = Puppet::Resource::Type.new(:hostclass, "myclass", :use_docs => false)
     end
 
     it "should return a new instance of the provided class created with the provided options" do
       @class.expects(:new).with { |opts| opts[:foo] == "bar" }
       @parser.ast(@class, :foo => "bar")
     end
 
     it "should merge the ast context into the provided options" do
       @class.expects(:new).with { |opts| opts[:file] == "/foo" }
       @parser.expects(:ast_context).returns :file => "/foo"
       @parser.ast(@class, :foo => "bar")
     end
 
     it "should prefer provided options over AST context" do
       @class.expects(:new).with { |opts| opts[:file] == "/bar" }
       @lexer.expects(:file).returns "/foo"
       @parser.ast(@class, :file => "/bar")
     end
 
     it "should include docs when the AST class uses them" do
       @class.expects(:use_docs).returns true
       @class.stubs(:new)
       @parser.expects(:ast_context).with{ |docs, line| docs == true }.returns({})
       @parser.ast(@class, :file => "/bar")
     end
 
     it "should get docs from lexer using the correct AST line number" do
       @class.expects(:use_docs).returns true
       @class.stubs(:new).with{ |a| a[:doc] == "doc" }
       @lexer.expects(:getcomment).with(12).returns "doc"
       @parser.ast(@class, :file => "/bar", :line => 12)
     end
   end
 
   describe "when retrieving a specific node" do
     it "should delegate to the known_resource_types node" do
       @known_resource_types.expects(:node).with("node")
 
       @parser.node("node")
     end
   end
 
   describe "when retrieving a specific class" do
     it "should delegate to the loaded code" do
       @known_resource_types.expects(:hostclass).with("class")
 
       @parser.hostclass("class")
     end
   end
 
   describe "when retrieving a specific definitions" do
     it "should delegate to the loaded code" do
       @known_resource_types.expects(:definition).with("define")
 
       @parser.definition("define")
     end
   end
 
   describe "when determining the configuration version" do
     it "should determine it from the resource type collection" do
       @parser.known_resource_types.expects(:version).returns "foo"
       @parser.version.should == "foo"
     end
   end
 
   describe "when looking up definitions" do
     it "should use the known resource types to check for them by name" do
       @parser.known_resource_types.stubs(:find_or_load).with("namespace","name",:definition).returns(:this_value)
       @parser.find_definition("namespace","name").should == :this_value
     end
   end
 
   describe "when looking up hostclasses" do
     it "should use the known resource types to check for them by name" do
-      @parser.known_resource_types.stubs(:find_or_load).with("namespace","name",:hostclass).returns(:this_value)
+      @parser.known_resource_types.stubs(:find_or_load).with("namespace","name",:hostclass,{}).returns(:this_value)
       @parser.find_hostclass("namespace","name").should == :this_value
     end
   end
 
   describe "when parsing classes" do
     before :each do
       @krt = Puppet::Resource::TypeCollection.new("development")
       @parser = Puppet::Parser::Parser.new "development"
       @parser.stubs(:known_resource_types).returns @krt
     end
 
     it "should not create new classes" do
       @parser.parse("class foobar {}").code[0].should be_a(Puppet::Parser::AST::Hostclass)
       @krt.hostclass("foobar").should be_nil
     end
 
     it "should correctly set the parent class when one is provided" do
       @parser.parse("class foobar inherits yayness {}").code[0].instantiate('')[0].parent.should == "yayness"
     end
 
     it "should correctly set the parent class for multiple classes at a time" do
       statements = @parser.parse("class foobar inherits yayness {}\nclass boo inherits bar {}").code
       statements[0].instantiate('')[0].parent.should == "yayness"
       statements[1].instantiate('')[0].parent.should == "bar"
     end
 
     it "should define the code when some is provided" do
       @parser.parse("class foobar { $var = val }").code[0].code.should_not be_nil
     end
 
     it "should accept parameters with trailing comma" do
       @parser.parse("file { '/example': ensure => file, }").should be
     end
 
     it "should accept parametrized classes with trailing comma" do
       @parser.parse("class foobar ($var1 = 0,) { $var = val }").code[0].code.should_not be_nil
     end
 
     it "should define parameters when provided" do
       foobar = @parser.parse("class foobar($biz,$baz) {}").code[0].instantiate('')[0]
       foobar.arguments.should == {"biz" => nil, "baz" => nil}
     end
   end
 
   describe "when parsing resources" do
     before :each do
       @krt = Puppet::Resource::TypeCollection.new("development")
       @parser = Puppet::Parser::Parser.new "development"
       @parser.stubs(:known_resource_types).returns @krt
     end
 
     it "should be able to parse class resources" do
       @krt.add(Puppet::Resource::Type.new(:hostclass, "foobar", :arguments => {"biz" => nil}))
       expect { @parser.parse("class { foobar: biz => stuff }") }.should_not raise_error
     end
 
     it "should correctly mark exported resources as exported" do
       @parser.parse("@@file { '/file': }").code[0].exported.should be_true
     end
 
     it "should correctly mark virtual resources as virtual" do
       @parser.parse("@file { '/file': }").code[0].virtual.should be_true
     end
   end
 
   describe "when parsing nodes" do
     it "should be able to parse a node with a single name" do
       node = @parser.parse("node foo { }").code[0]
       node.should be_a Puppet::Parser::AST::Node
       node.names.length.should == 1
       node.names[0].value.should == "foo"
     end
 
     it "should be able to parse a node with two names" do
       node = @parser.parse("node foo, bar { }").code[0]
       node.should be_a Puppet::Parser::AST::Node
       node.names.length.should == 2
       node.names[0].value.should == "foo"
       node.names[1].value.should == "bar"
     end
 
     it "should be able to parse a node with three names" do
       node = @parser.parse("node foo, bar, baz { }").code[0]
       node.should be_a Puppet::Parser::AST::Node
       node.names.length.should == 3
       node.names[0].value.should == "foo"
       node.names[1].value.should == "bar"
       node.names[2].value.should == "baz"
     end
   end
 
   it "should fail if trying to collect defaults" do
     expect { @parser.parse("@Port { protocols => tcp }") }.
       to raise_error Puppet::ParseError
   end
 
   context "when parsing collections" do
     it "should parse basic collections" do
       @parser.parse("Port <| |>").code.
         should be_all {|x| x.is_a? Puppet::Parser::AST::Collection }
     end
 
     it "should parse fully qualified collections" do
       @parser.parse("Port::Range <| |>").code.
         should be_all {|x| x.is_a? Puppet::Parser::AST::Collection }
     end
   end
 
   it "should not assign to a fully qualified variable" do
     expect { @parser.parse("$one::two = yay") }.to raise_error Puppet::ParseError
   end
 
   it "should parse assignment of undef" do
     tree = @parser.parse("$var = undef")
     tree.code.children[0].should be_an_instance_of Puppet::Parser::AST::VarDef
     tree.code.children[0].value.should be_an_instance_of Puppet::Parser::AST::Undef
   end
 
   context "#namesplit" do
     { "base::sub" => %w{base sub},
       "main" => ["", "main"],
       "one::two::three::four" => ["one::two::three", "four"],
     }.each do |input, output|
       it "should split #{input.inspect} to #{output.inspect}" do
         @parser.namesplit(input).should == output
       end
     end
   end
 
   it "should treat classes as case insensitive" do
     @parser.known_resource_types.import_ast(@parser.parse("class yayness {}"), '')
     @parser.known_resource_types.hostclass('yayness').
       should == @parser.find_hostclass("", "YayNess")
   end
 
   it "should treat defines as case insensitive" do
     @parser.known_resource_types.import_ast(@parser.parse("define funtest {}"), '')
     @parser.known_resource_types.hostclass('funtest').
       should == @parser.find_hostclass("", "fUntEst")
   end
 end
diff --git a/spec/unit/resource/type_collection_spec.rb b/spec/unit/resource/type_collection_spec.rb
index 23590ac64..c812fa789 100755
--- a/spec/unit/resource/type_collection_spec.rb
+++ b/spec/unit/resource/type_collection_spec.rb
@@ -1,451 +1,454 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/resource/type_collection'
 require 'puppet/resource/type'
 
 describe Puppet::Resource::TypeCollection do
   include PuppetSpec::Files
 
   before do
     @instance = Puppet::Resource::Type.new(:hostclass, "foo")
     @code = Puppet::Resource::TypeCollection.new("env")
   end
 
   it "should require an environment at initialization" do
     env = Puppet::Node::Environment.new("testing")
     Puppet::Resource::TypeCollection.new(env).environment.should equal(env)
   end
 
   it "should convert the environment into an environment instance if a string is provided" do
     env = Puppet::Node::Environment.new("testing")
     Puppet::Resource::TypeCollection.new("testing").environment.should equal(env)
   end
 
   it "should create a 'loader' at initialization" do
     Puppet::Resource::TypeCollection.new("testing").loader.should be_instance_of(Puppet::Parser::TypeLoader)
   end
 
   it "should be able to add a resource type" do
     Puppet::Resource::TypeCollection.new("env").should respond_to(:add)
   end
 
   it "should consider '<<' to be an alias to 'add' but should return self" do
     loader = Puppet::Resource::TypeCollection.new("env")
     loader.expects(:add).with "foo"
     loader.expects(:add).with "bar"
     loader << "foo" << "bar"
   end
 
   it "should set itself as the code collection for added resource types" do
     loader = Puppet::Resource::TypeCollection.new("env")
 
     node = Puppet::Resource::Type.new(:node, "foo")
 
     @code.add(node)
     @code.node("foo").should equal(node)
 
     node.resource_type_collection.should equal(@code)
   end
 
   it "should store node resource types as nodes" do
     node = Puppet::Resource::Type.new(:node, "foo")
 
     @code.add(node)
     @code.node("foo").should equal(node)
   end
 
   it "should store hostclasses as hostclasses" do
     klass = Puppet::Resource::Type.new(:hostclass, "foo")
 
     @code.add(klass)
     @code.hostclass("foo").should equal(klass)
   end
 
   it "should store definitions as definitions" do
     define = Puppet::Resource::Type.new(:definition, "foo")
 
     @code.add(define)
     @code.definition("foo").should equal(define)
   end
 
   it "should merge new classes with existing classes of the same name" do
     loader = Puppet::Resource::TypeCollection.new("env")
     first = Puppet::Resource::Type.new(:hostclass, "foo")
     second = Puppet::Resource::Type.new(:hostclass, "foo")
     loader.add first
     first.expects(:merge).with(second)
     loader.add(second)
   end
 
   it "should remove all nodes, classes, and definitions when cleared" do
     loader = Puppet::Resource::TypeCollection.new("env")
     loader.add Puppet::Resource::Type.new(:hostclass, "class")
     loader.add Puppet::Resource::Type.new(:definition, "define")
     loader.add Puppet::Resource::Type.new(:node, "node")
     watched_file = tmpfile('watched_file')
     loader.watch_file(watched_file)
 
     loader.clear
     loader.hostclass("class").should be_nil
     loader.definition("define").should be_nil
     loader.node("node").should be_nil
     loader.should_not be_watching_file(watched_file)
   end
 
   describe "when resolving namespaces" do
     [ ['',               '::foo', ['foo']],
       ['a',              '::foo', ['foo']],
       ['a::b',           '::foo', ['foo']],
       [['a::b'],         '::foo', ['foo']],
       [['a::b', 'c'],    '::foo', ['foo']],
       [['A::B', 'C'],    '::Foo', ['foo']],
       ['',               '',      ['']],
       ['a',              '',      ['']],
       ['a::b',           '',      ['']],
       [['a::b'],         '',      ['']],
       [['a::b', 'c'],    '',      ['']],
       [['A::B', 'C'],    '',      ['']],
       ['',               'foo',   ['foo']],
       ['a',              'foo',   ['a::foo', 'foo']],
       ['a::b',           'foo',   ['a::b::foo', 'a::foo', 'foo']],
       ['A::B',           'Foo',   ['a::b::foo', 'a::foo', 'foo']],
       [['a::b'],         'foo',   ['a::b::foo', 'a::foo', 'foo']],
       [['a', 'b'],       'foo',   ['a::foo', 'foo', 'b::foo']],
       [['a::b', 'c::d'], 'foo',   ['a::b::foo', 'a::foo', 'foo', 'c::d::foo', 'c::foo']],
       [['a::b', 'a::c'], 'foo',   ['a::b::foo', 'a::foo', 'foo', 'a::c::foo']],
     ].each do |namespaces, name, expected_result|
       it "should resolve #{name.inspect} in namespaces #{namespaces.inspect} correctly" do
         @code.instance_eval { resolve_namespaces(namespaces, name) }.should == expected_result
       end
     end
   end
 
   describe "when looking up names" do
     before do
       @type = Puppet::Resource::Type.new(:hostclass, "ns::klass")
     end
 
     it "should support looking up with multiple namespaces" do
       @code.add @type
       @code.find_hostclass(%w{boo baz ns}, "klass").should equal(@type)
     end
 
     it "should not attempt to import anything when the type is already defined" do
       @code.add @type
       @code.loader.expects(:import).never
       @code.find_hostclass(%w{ns}, "klass").should equal(@type)
     end
 
     describe "that need to be loaded" do
       it "should use the loader to load the files" do
         @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass")
         @code.loader.expects(:try_load_fqname).with(:hostclass, "klass")
         @code.find_hostclass(["ns"], "klass")
       end
 
       it "should downcase the name and downcase and array-fy the namespaces before passing to the loader" do
         @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass")
         @code.loader.expects(:try_load_fqname).with(:hostclass, "klass")
         @code.find_hostclass("Ns", "Klass")
       end
 
       it "should use the class returned by the loader" do
         @code.loader.expects(:try_load_fqname).returns(:klass)
         @code.expects(:hostclass).with("ns::klass").returns(false)
         @code.find_hostclass("ns", "klass").should == :klass
       end
 
       it "should return nil if the name isn't found" do
         @code.stubs(:try_load_fqname).returns(nil)
         @code.find_hostclass("Ns", "Klass").should be_nil
       end
 
       it "already-loaded names at broader scopes should not shadow autoloaded names" do
         @code.add Puppet::Resource::Type.new(:hostclass, "bar")
         @code.loader.expects(:try_load_fqname).with(:hostclass, "foo::bar").returns(:foobar)
         @code.find_hostclass("foo", "bar").should == :foobar
       end
     end
   end
 
   %w{hostclass node definition}.each do |data|
     before do
       @instance = Puppet::Resource::Type.new(data, "foo")
     end
 
     it "should have a method for adding a #{data}" do
       Puppet::Resource::TypeCollection.new("env").should respond_to("add_#{data}")
     end
 
     it "should use the name of the instance to add it" do
       loader = Puppet::Resource::TypeCollection.new("env")
       loader.send("add_#{data}", @instance)
       loader.send(data, @instance.name).should equal(@instance)
     end
 
     unless data == "hostclass"
       it "should fail to add a #{data} when one already exists" do
         loader = Puppet::Resource::TypeCollection.new("env")
         loader.add @instance
         lambda { loader.add(@instance) }.should raise_error(Puppet::ParseError)
       end
     end
 
     it "should return the added #{data}" do
       loader = Puppet::Resource::TypeCollection.new("env")
 
       loader.add(@instance).should equal(@instance)
     end
 
     it "should be able to retrieve #{data} by name" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(data, "bar")
       loader.add instance
       loader.send(data, "bar").should equal(instance)
     end
 
     it "should retrieve #{data} insensitive to case" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(data, "Bar")
       loader.add instance
       loader.send(data, "bAr").should equal(instance)
     end
 
     it "should return nil when asked for a #{data} that has not been added" do
       Puppet::Resource::TypeCollection.new("env").send(data, "foo").should be_nil
     end
 
     it "should be able to retrieve all #{data}s" do
       plurals = { "hostclass" => "hostclasses", "node" => "nodes", "definition" => "definitions" }
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(data, "foo")
       loader.add instance
       loader.send(plurals[data]).should == { "foo" => instance }
     end
   end
 
   describe "when finding a qualified instance" do
     it "should return any found instance if the instance name is fully qualified" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
       loader.find_hostclass("namespace", "::foo::bar").should equal(instance)
     end
 
     it "should return nil if the instance name is fully qualified and no such instance exists" do
       loader = Puppet::Resource::TypeCollection.new("env")
       loader.find_hostclass("namespace", "::foo::bar").should be_nil
     end
 
     it "should be able to find classes in the base namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo")
       loader.add instance
       loader.find_hostclass("", "foo").should equal(instance)
     end
 
     it "should return the partially qualified object if it exists in a provided namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find_hostclass("foo", "bar::baz").should equal(instance)
     end
 
     it "should be able to find partially qualified objects in any of the provided namespaces" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find_hostclass(["nons", "foo", "otherns"], "bar::baz").should equal(instance)
     end
 
     it "should return the unqualified object if it exists in a provided namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
       loader.find_hostclass("foo", "bar").should equal(instance)
     end
 
     it "should return the unqualified object if it exists in the parent namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
       loader.find_hostclass("foo::bar::baz", "bar").should equal(instance)
     end
 
     it "should should return the partially qualified object if it exists in the parent namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find_hostclass("foo::bar", "bar::baz").should equal(instance)
     end
 
     it "should return the qualified object if it exists in the root namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find_hostclass("foo::bar", "foo::bar::baz").should equal(instance)
     end
 
     it "should return nil if the object cannot be found" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find_hostclass("foo::bar", "eh").should be_nil
     end
 
     describe "when topscope has a class that has the same name as a local class" do
       before do
         @loader = Puppet::Resource::TypeCollection.new("env")
         [ "foo::bar", "bar" ].each do |name|
           @loader.add Puppet::Resource::Type.new(:hostclass, name)
         end
       end
 
       it "should favor the local class, if the name is unqualified" do
         @loader.find_hostclass("foo", "bar").name.should == 'foo::bar'
       end
 
       it "should only look in the topclass, if the name is qualified" do
         @loader.find_hostclass("foo", "::bar").name.should == 'bar'
       end
-
+      
+      it "should only look in the topclass, if we assume the name is fully qualified" do
+        @loader.find_hostclass("foo", "bar", :assume_fqname => true).name.should == 'bar'
+      end
     end
     
     it "should not look in the local scope for classes when the name is qualified" do
         @loader = Puppet::Resource::TypeCollection.new("env")
         @loader.add Puppet::Resource::Type.new(:hostclass, "foo::bar")
 
         @loader.find_hostclass("foo", "::bar").should == nil
     end
 
   end
 
   it "should be able to find nodes" do
     node = Puppet::Resource::Type.new(:node, "bar")
     loader = Puppet::Resource::TypeCollection.new("env")
     loader.add(node)
     loader.find_node(stub("ignored"), "bar").should == node
   end
 
   it "should use the 'find_or_load' method to find hostclasses" do
     loader = Puppet::Resource::TypeCollection.new("env")
-    loader.expects(:find_or_load).with("foo", "bar", :hostclass)
+    loader.expects(:find_or_load).with("foo", "bar", :hostclass, {})
     loader.find_hostclass("foo", "bar")
   end
 
   it "should use the 'find_or_load' method to find definitions" do
     loader = Puppet::Resource::TypeCollection.new("env")
     loader.expects(:find_or_load).with("foo", "bar", :definition)
     loader.find_definition("foo", "bar")
   end
 
   it "should indicate whether any nodes are defined" do
     loader = Puppet::Resource::TypeCollection.new("env")
     loader.add_node(Puppet::Resource::Type.new(:node, "foo"))
     loader.should be_nodes
   end
 
   it "should indicate whether no nodes are defined" do
     Puppet::Resource::TypeCollection.new("env").should_not be_nodes
   end
 
   describe "when finding nodes" do
     before :each do
       @loader = Puppet::Resource::TypeCollection.new("env")
     end
 
     it "should return any node whose name exactly matches the provided node name" do
       node = Puppet::Resource::Type.new(:node, "foo")
       @loader << node
 
       @loader.node("foo").should equal(node)
     end
 
     it "should return the first regex node whose regex matches the provided node name" do
       node1 = Puppet::Resource::Type.new(:node, /\w/)
       node2 = Puppet::Resource::Type.new(:node, /\d/)
       @loader << node1 << node2
 
       @loader.node("foo10").should equal(node1)
     end
 
     it "should preferentially return a node whose name is string-equal over returning a node whose regex matches a provided name" do
       node1 = Puppet::Resource::Type.new(:node, /\w/)
       node2 = Puppet::Resource::Type.new(:node, "foo")
       @loader << node1 << node2
 
       @loader.node("foo").should equal(node2)
     end
   end
 
   describe "when managing files" do
     before do
       @loader = Puppet::Resource::TypeCollection.new("env")
       Puppet::Util::LoadedFile.stubs(:new).returns stub("watched_file")
     end
 
     it "should have a method for specifying a file should be watched" do
       @loader.should respond_to(:watch_file)
     end
 
     it "should have a method for determining if a file is being watched" do
       @loader.watch_file("/foo/bar")
       @loader.should be_watching_file("/foo/bar")
     end
 
     it "should use LoadedFile to watch files" do
       Puppet::Util::LoadedFile.expects(:new).with("/foo/bar").returns stub("watched_file")
       @loader.watch_file("/foo/bar")
     end
 
     it "should be considered stale if any files have changed" do
       file1 = stub 'file1', :changed? => false
       file2 = stub 'file2', :changed? => true
       Puppet::Util::LoadedFile.expects(:new).times(2).returns(file1).then.returns(file2)
       @loader.watch_file("/foo/bar")
       @loader.watch_file("/other/bar")
 
       @loader.should be_stale
     end
 
     it "should not be considered stable if no files have changed" do
       file1 = stub 'file1', :changed? => false
       file2 = stub 'file2', :changed? => false
       Puppet::Util::LoadedFile.expects(:new).times(2).returns(file1).then.returns(file2)
       @loader.watch_file("/foo/bar")
       @loader.watch_file("/other/bar")
 
       @loader.should_not be_stale
     end
   end
 
   describe "when determining the configuration version" do
     before do
       @code = Puppet::Resource::TypeCollection.new("env")
     end
 
     it "should default to the current time" do
       time = Time.now
 
       Time.stubs(:now).returns time
       @code.version.should == time.to_i
     end
 
     it "should use the output of the environment's config_version setting if one is provided" do
       @code.environment.stubs(:[]).with(:config_version).returns("/my/foo")
 
       Puppet::Util::Execution.expects(:execute).with(["/my/foo"]).returns "output\n"
       @code.version.should == "output"
     end
 
     it "should raise a puppet parser error if executing config_version fails" do
       @code.environment.stubs(:[]).with(:config_version).returns("test")
       Puppet::Util::Execution.expects(:execute).raises(Puppet::ExecutionFailure.new("msg"))
 
       lambda { @code.version }.should raise_error(Puppet::ParseError)
     end
 
   end
 
 end