diff --git a/lib/puppet/parser/interpreter.rb b/lib/puppet/parser/interpreter.rb
index fe8e17084..4480a123a 100644
--- a/lib/puppet/parser/interpreter.rb
+++ b/lib/puppet/parser/interpreter.rb
@@ -1,798 +1,802 @@
 # The interepreter's job is to convert from a parsed file to the configuration
 # for a given client.  It really doesn't do any work on its own, it just collects
 # and calls out to other objects.
 
 require 'puppet'
 require 'timeout'
 require 'puppet/parser/parser'
 require 'puppet/parser/scope'
 
 class Puppet::Parser::Interpreter
     include Puppet::Util
 
     Puppet.setdefaults("ldap",
         :ldapnodes => [false,
             "Whether to search for node configurations in LDAP."],
         :ldapssl => [false,
             "Whether SSL should be used when searching for nodes.
             Defaults to false because SSL usually requires certificates
             to be set up on the client side."],
         :ldaptls => [false,
             "Whether TLS should be used when searching for nodes.
             Defaults to false because TLS usually requires certificates
             to be set up on the client side."],
         :ldapserver => ["ldap",
             "The LDAP server.  Only used if ``ldapnodes`` is enabled."],
         :ldapport => [389,
             "The LDAP port.  Only used if ``ldapnodes`` is enabled."],
         :ldapstring => ["(&(objectclass=puppetClient)(cn=%s))",
             "The search string used to find an LDAP node."],
         :ldapattrs => ["puppetclass",
             "The LDAP attributes to use to define Puppet classes.  Values
             should be comma-separated."],
         :ldapparentattr => ["parentnode",
             "The attribute to use to define the parent node."],
         :ldapuser => ["",
             "The user to use to connect to LDAP.  Must be specified as a
             full DN."],
         :ldappassword => ["",
             "The password to use to connect to LDAP."],
         :ldapbase => ["",
             "The search base for LDAP searches.  It's impossible to provide
             a meaningful default here, although the LDAP libraries might
             have one already set.  Generally, it should be the 'ou=Hosts'
             branch under your main directory."]
     )
 
     Puppet.setdefaults(:puppetmaster,
         :storeconfigs => [false,
             "Whether to store each client's configuration.  This
              requires ActiveRecord from Ruby on Rails."]
     )
 
     attr_accessor :usenodes
 
     class << self
         attr_writer :ldap
     end
     # just shorten the constant path a bit, using what amounts to an alias
     AST = Puppet::Parser::AST
 
     include Puppet::Util::Errors
 
     # Create an ldap connection.  This is a class method so others can call
     # it and use the same variables and such.
     def self.ldap
         unless defined? @ldap and @ldap
             if Puppet[:ldapssl]
                 @ldap = LDAP::SSLConn.new(Puppet[:ldapserver], Puppet[:ldapport])
             elsif Puppet[:ldaptls]
                 @ldap = LDAP::SSLConn.new(
                     Puppet[:ldapserver], Puppet[:ldapport], true
                 )
             else
                 @ldap = LDAP::Conn.new(Puppet[:ldapserver], Puppet[:ldapport])
             end
             @ldap.set_option(LDAP::LDAP_OPT_PROTOCOL_VERSION, 3)
             @ldap.set_option(LDAP::LDAP_OPT_REFERRALS, LDAP::LDAP_OPT_ON)
             @ldap.simple_bind(Puppet[:ldapuser], Puppet[:ldappassword])
         end
 
         return @ldap
     end
 
     def clear
         initparsevars
     end
 
     # Iteratively evaluate all of the objects.  This finds all fo the
     # objects that represent definitions and evaluates the definitions appropriately.
     # It also adds defaults and overrides as appropriate.
     def evaliterate(scope)
         count = 0
         begin
             timeout 300 do
                 while ary = scope.unevaluated
                     ary.each do |resource|
                         resource.evaluate
                     end
                 end
             end
         rescue Timeout::Error
             raise Puppet::DevError, "Got a timeout trying to evaluate all definitions"
         end
     end
 
     # Evaluate a specific node.
     def evalnode(client, scope, facts)
         return unless self.usenodes
 
         unless client
             raise Puppet::Error,
                 "Cannot evaluate nodes with a nil client"
         end
         names = [client]
 
         # Make sure both the fqdn and the short name of the
         # host can be used in the manifest
         if client =~ /\./
             names << client.sub(/\..+/,'')
         else
             names << "#{client}.#{facts['domain']}"
         end
 
         if names.empty?
             raise Puppet::Error,
                 "Cannot evaluate nodes with a nil client"
         end
 
         # Look up our node object.
         if nodeclass = nodesearch(*names)
             nodeclass.safeevaluate :scope => scope
         else
             raise Puppet::Error, "Could not find %s with names %s" %
                 [client, names.join(", ")]
         end
     end
 
     # Evaluate all of the code we can find that's related to our client.
     def evaluate(client, facts)
 
         scope = Puppet::Parser::Scope.new(:interp => self) # no parent scope
         scope.name = "top"
         scope.type = "main"
 
         scope.host = facts["hostname"] || Facter.value("hostname")
 
         classes = @classes.dup
 
         # Okay, first things first.  Set our facts.
         scope.setfacts(facts)
 
         # Everyone will always evaluate the top-level class, if there is one.
         if klass = findclass("", "")
             # Set the source, so objects can tell where they were defined.
             scope.source = klass
             klass.safeevaluate :scope => scope, :nosubscope => true
         end
 
         # Next evaluate the node
         evalnode(client, scope, facts)
 
         # If we were passed any classes, evaluate those.
         if classes
             classes.each do |klass|
                 if klassobj = findclass("", klass)
                     klassobj.safeevaluate :scope => scope
                 end
             end
         end
 
         # That was the first pass evaluation.  Now iteratively evaluate
         # until we've gotten rid of all of everything or thrown an error.
         evaliterate(scope)
 
         # Now make sure we fail if there's anything left to do
         failonleftovers(scope)
 
         # Now perform the collections
         exceptwrap do
             scope.collections.each do |coll|
                 coll.evaluate
             end
         end
 
         # Now finish everything.  This recursively calls finish on the
         # contained scopes and resources.
         scope.finish
 
         # Store everything.  We need to do this before translation, because
         # it operates on resources, not transobjects.
         if Puppet[:storeconfigs]
             args = {
                 :resources => scope.resources,
                 :name => client,
                 :facts => facts
             }
             unless scope.classlist.empty?
                 args[:classes] = scope.classlist
             end
 
             storeconfigs(args)
         end
 
         # Now, finally, convert our scope tree + resources into a tree of
         # buckets and objects.
         objects = scope.translate
 
         # Add the class list
         unless scope.classlist.empty?
             objects.classes = scope.classlist
         end
 
         return objects
     end
 
     # Fail if there any overrides left to perform.
     def failonleftovers(scope)
         overrides = scope.overrides
         if overrides.empty?
             return nil
         else
             fail Puppet::ParseError,
                 "Could not find object(s) %s" % overrides.collect { |o|
                     o.ref
                 }.join(", ")
         end
     end
 
     # Find a class definition, relative to the current namespace.
     def findclass(namespace, name)
         fqfind namespace, name, @classtable
     end
 
     # Find a component definition, relative to the current namespace.
     def finddefine(namespace, name)
         fqfind namespace, name, @definetable
     end
 
     # The recursive method used to actually look these objects up.
     def fqfind(namespace, name, table)
         if name =~ /^::/ or namespace == ""
             return table[name.sub(/^::/, '')]
         end
         ary = namespace.split("::")
 
         while ary.length > 0
             newname = (ary + [name]).join("::").sub(/^::/, '')
             if obj = table[newname]
                 return obj
             end
 
             # Delete the second to last object, which reduces our namespace by one.
             ary.pop
         end
 
         # If we've gotten to this point without finding it, see if the name
         # exists at the top namespace
         if obj = table[name]
             return obj
         end
 
         return nil
     end
 
     # Create a new node, just from a list of names, classes, and an optional parent.
     def gennode(name, hash)
         facts = hash[:facts]
         classes = hash[:classes]
         parent = hash[:parentnode]
         arghash = {
             :name => name,
             :interp => self,
             :fqname => name
         }
 
         if (classes.is_a?(Array) and classes.empty?) or classes.nil?
             arghash[:code] = AST::ASTArray.new(:children => [])
         else
             classes = [classes] unless classes.is_a?(Array)
 
             classcode = @parser.ast(AST::ASTArray, :children => classes.collect do |klass|
                 @parser.ast(AST::FlatString, :value => klass)
             end)
 
             # Now generate a function call.
             code = @parser.ast(AST::Function,
                 :name => "include",
                 :arguments => classcode,
                 :ftype => :statement
             )
 
             arghash[:code] = code
         end
 
         if parent
             arghash[:parentclass] = parent
         end
 
         # Create the node
         return @parser.ast(AST::Node, arghash)
     end
 
     # create our interpreter
     def initialize(hash)
         if @code = hash[:Code]
             @file = nil # to avoid warnings
         elsif ! @file = hash[:Manifest]
             devfail "You must provide code or a manifest"
         end
 
         if hash.include?(:UseNodes)
             @usenodes = hash[:UseNodes]
         else
             @usenodes = true
         end
 
         # By default, we only search for parsed nodes.
         @nodesources = []
 
         if Puppet[:ldapnodes]
             # Nodes in the file override nodes in ldap.
             @nodesources << :ldap
         end
 
         if hash[:NodeSources]
             unless hash[:NodeSources].is_a?(Array)
                 hash[:NodeSources] = [hash[:NodeSources]]
             end
             hash[:NodeSources].each do |src|
                 if respond_to? "nodesearch_#{src.to_s}"
                     @nodesources << src.to_s.intern
                 else
                     Puppet.warning "Node source '#{src}' not supported"
                 end
             end
         end
 
         unless @nodesources.include?(:code)
             @nodesources << :code
         end
 
         @setup = false
 
         initparsevars()
 
         # Set it to either the value or nil.  This is currently only used
         # by the cfengine module.
         @classes = hash[:Classes] || []
 
         @local = hash[:Local] || false
 
         if hash.include?(:ForkSave)
             @forksave = hash[:ForkSave]
         else
             # This is just too dangerous right now.  Sorry, it's going
             # to have to be slow.
             @forksave = false
         end
 
         # The class won't always be defined during testing.
         if Puppet[:storeconfigs] and defined? ActiveRecord::Base
             Puppet::Rails.init
         end
 
         @files = []
 
         # Create our parser object
         parsefiles
     end
 
     # Initialize or reset the variables related to parsing.
     def initparsevars
         @classtable = {}
         @namespace = "main"
 
         @nodetable = {}
 
         @definetable = {}
     end
 
     # Find the ldap node and extra the info, returning just
     # the critical data.
     def ldapsearch(node)
         unless defined? @ldap and @ldap
             setup_ldap()
             unless @ldap
                 Puppet.info "Skipping ldap source; no ldap connection"
                 return nil, []
             end
         end
 
         if node =~ /\./
             node = node.sub(/\..+/, '')
         end
 
         filter = Puppet[:ldapstring]
         attrs = Puppet[:ldapattrs].split("\s*,\s*")
         sattrs = attrs.dup
         pattr = nil
         if pattr = Puppet[:ldapparentattr]
             if pattr == ""
                 pattr = nil
             else
                 sattrs << pattr
             end
         end
 
         if filter =~ /%s/
             filter = filter.gsub(/%s/, node)
         end
 
         parent = nil
         classes = []
 
         found = false
         count = 0
         begin
             # We're always doing a sub here; oh well.
             @ldap.search(Puppet[:ldapbase], 2, filter, sattrs) do |entry|
                 found = true
                 if pattr
                     if values = entry.vals(pattr)
                         if values.length > 1
                             raise Puppet::Error,
                                 "Node %s has more than one parent: %s" %
                                 [node, values.inspect]
                         end
                         unless values.empty?
                             parent = values.shift
                         end
                     end
                 end
 
                 attrs.each { |attr|
                     if values = entry.vals(attr)
                         values.each do |v| classes << v end
                     end
                 }
             end
         rescue => detail
             if count == 0
                 # Try reconnecting to ldap
                 @ldap = nil
                 setup_ldap()
                 retry
             else
                 raise Puppet::Error, "LDAP Search failed: %s" % detail
             end
         end
 
         classes.flatten!
 
         if classes.empty?
             classes = nil
         end
 
         return parent, classes
     end
 
     # Split an fq name into a namespace and name
     def namesplit(fullname)
         ary = fullname.split("::")
         n = ary.pop || ""
         ns = ary.join("::")
         return ns, n
     end
 
     # Create a new class, or merge with an existing class.
     def newclass(fqname, options = {})
         if @definetable.include?(fqname)
             raise Puppet::ParseError, "Cannot redefine class %s as a definition" %
                 fqname
         end
         code = options[:code]
         parent = options[:parent]
 
         # If the class is already defined, then add code to it.
         if other = @classtable[fqname]
             # Make sure the parents match
             if parent and other.parentclass and (parent != other.parentclass)
                 @parser.error @parser.addcontext("Class %s is already defined" % fqname) +
                     " with parent %s" % [fqname, other.parentclass]
             end
 
             # This might be dangerous...
             if parent and ! other.parentclass
                 other.parentclass = parent
             end
 
             # This might just be an empty, stub class.
             if code
                 tmp = fqname
                 if tmp == ""
                     tmp = "main"
                 end
                 
                 Puppet.debug @parser.addcontext("Adding code to %s" % tmp)
                 # Else, add our code to it.
                 if other.code and code
                     other.code.children += code.children
                 else
                     other.code ||= code
                 end
             end
         else
             # Define it anew.
             ns, name = namesplit(fqname)
-            args = {:type => name, :namespace => ns, :fqname => fqname, :interp => self}
+
+            # Note we're doing something somewhat weird here -- we're setting
+            # the class's namespace to its fully qualified name.  This means
+            # anything inside that class starts looking in that namespace first.
+            args = {:type => name, :namespace => fqname, :fqname => fqname, :interp => self}
             args[:code] = code if code
             args[:parentclass] = parent if parent
             @classtable[fqname] = @parser.ast AST::HostClass, args
         end
 
         return @classtable[fqname]
     end
 
     # Create a new definition.
     def newdefine(fqname, options = {})
         if @classtable.include?(fqname)
             raise Puppet::ParseError, "Cannot redefine class %s as a definition" %
                 fqname
         end
         # Make sure our definition doesn't already exist
         if other = @definetable[fqname]
             @parser.error @parser.addcontext(
                 "%s is already defined at line %s" % [fqname, other.line],
                 other
             )
         end
 
         ns, name = namesplit(fqname)
         args = {
             :type => name,
             :namespace => ns,
             :arguments => options[:arguments],
             :code => options[:code],
             :fqname => fqname
         }
 
         [:code, :arguments].each do |param|
             args[param] = options[param] if options[param]
         end
 
         @definetable[fqname] = @parser.ast AST::Component, args
     end
 
     # Create a new node.  Nodes are special, because they're stored in a global
     # table, not according to namespaces.
     def newnode(names, options = {})
         names = [names] unless names.instance_of?(Array)
         names.collect do |name|
             if other = @nodetable[name]
                 @parser.error @parser.addcontext("Node %s is already defined" % [other.name], other)
             end
             name = name.to_s if name.is_a?(Symbol)
             args = {
                 :name => name,
             }
             if options[:code]
                 args[:code] = options[:code]
             end
             if options[:parent]
                 args[:parentclass] = options[:parent]
             end
             @nodetable[name] = @parser.ast(AST::Node, args)
             @nodetable[name].fqname = name
             @nodetable[name]
             @nodetable[name].interp = self
             @nodetable[name]
         end
     end
 
     # Add a new file to be checked when we're checking to see if we should be
     # reparsed.
     def newfile(*files)
         files.each do |file|
             unless file.is_a? Puppet::LoadedFile
                 file = Puppet::LoadedFile.new(file)
             end
             @files << file
         end
     end
 
     # Search for our node in the various locations.
     def nodesearch(*nodes)
         # At this point, stop at the first source that defines
         # the node
         @nodesources.each do |source|
             method = "nodesearch_%s" % source
             if self.respond_to? method
                 # Do an inverse sort on the length, so the longest match always
                 # wins
                 nodes.sort { |a,b| b.length <=> a.length }.each do |node|
                     node = node.to_s if node.is_a?(Symbol)
                     if obj = self.send(method, node)
                         nsource = obj.file || source
                         Puppet.info "Found %s in %s" % [node, nsource]
                         return obj
                     end
                 end
             end
         end
 
         # If they made it this far, we haven't found anything, so look for a
         # default node.
         unless nodes.include?("default")
             if defobj = self.nodesearch("default")
                 Puppet.notice "Using default node for %s" % [nodes[0]]
                 return defobj
             end
         end
 
         return nil
     end
 
     # See if our node was defined in the code.
     def nodesearch_code(name)
         @nodetable[name]
     end
 
     # Look for our node in ldap.
     def nodesearch_ldap(node)
         parent, classes = ldapsearch(node)
         if parent or classes
             args = {}
             args[:classes] = classes if classes
             args[:parentnode] = parent if parent
             return gennode(node, args)
         else
             return nil
         end
     end
 
     def parsedate
         parsefiles()
         @parsedate
     end
 
     # evaluate our whole tree
     def run(client, facts)
         # We have to leave this for after initialization because there
         # seems to be a problem keeping ldap open after a fork.
         unless @setup
             @nodesources.each { |source|
                 method = "setup_%s" % source.to_s
                 if respond_to? method
                     exceptwrap :type => Puppet::Error,
                             :message => "Could not set up node source %s" % source do
                         self.send(method)
                     end
                 end
             }
         end
         parsefiles()
 
         # Evaluate all of the appropriate code.
         objects = evaluate(client, facts)
 
         # And return it all.
         return objects
     end
 
     # Connect to the LDAP Server
     def setup_ldap
         self.class.ldap = nil
         begin
             require 'ldap'
         rescue LoadError
             Puppet.notice(
                 "Could not set up LDAP Connection: Missing ruby/ldap libraries"
             )
             @ldap = nil
             return
         end
         begin
             @ldap = self.class.ldap()
         rescue => detail
             raise Puppet::Error, "Could not connect to LDAP: %s" % detail
         end
     end
 
     def scope
         return @scope
     end
 
     private
 
     # Check whether any of our files have changed.
     def checkfiles
         if @files.find { |f| f.changed?  }
             @parsedate = Time.now.to_i
         end
     end
 
     # Parse the files, generating our parse tree.  This automatically
     # reparses only if files are updated, so it's safe to call multiple
     # times.
     def parsefiles
         # First check whether there are updates to any non-puppet files
         # like templates.  If we need to reparse, this will get quashed,
         # but it needs to be done first in case there's no reparse
         # but there are other file changes.
         checkfiles()
 
         # Check if the parser should reparse.
         if @file
             if defined? @parser
                 if stamp = @parser.reparse?
                     Puppet.notice "Reloading files"
                 else
                     return false
                 end
             end
 
             unless FileTest.exists?(@file)
                 # If we've already parsed, then we're ok.
                 if findclass("", "")
                     return
                 else
                     raise Puppet::Error, "Manifest %s must exist" % @file
                 end
             end
         end
 
         # Reset our parse tables.
         clear()
 
         # Create a new parser, just to keep things fresh.
         @parser = Puppet::Parser::Parser.new(self)
         if @code
             @parser.string = @code
         else
             @parser.file = @file
             # Mark when we parsed, so we can check freshness
             @parsedate = File.stat(@file).ctime.to_i
         end
 
         # Parsing stores all classes and defines and such in their
         # various tables, so we don't worry about the return.
         if @local
             @parser.parse
         else
             benchmark(:info, "Parsed manifest") do
                 @parser.parse
             end
         end
         @parsedate = Time.now.to_i
     end
 
     # Store the configs into the database.
     def storeconfigs(hash)
         unless defined? ActiveRecord
             require 'puppet/rails'
             unless defined? ActiveRecord
                 raise LoadError,
                     "storeconfigs is enabled but rails is unavailable"
             end
         end
 
         Puppet::Rails.init
 
         # Fork the storage, since we don't need the client waiting
         # on that.  How do I avoid this duplication?
         if @forksave
             fork {
                 # We store all of the objects, even the collectable ones
                 benchmark(:info, "Stored configuration for #{hash[:name]}") do
                     # Try to batch things a bit, by putting them into
                     # a transaction
                     Puppet::Rails::Host.transaction do
                         Puppet::Rails::Host.store(hash)
                     end
                 end
             }
         else
             begin
                 # We store all of the objects, even the collectable ones
                 benchmark(:info, "Stored configuration for #{hash[:name]}") do
                     Puppet::Rails::Host.transaction do
                         Puppet::Rails::Host.store(hash)
                     end
                 end
             rescue => detail
                 if Puppet[:trace]
                     puts detail.backtrace
                 end
                 Puppet.err "Could not store configs: %s" % detail.to_s
             end
         end
 
         # Now that we've stored everything, we need to strip out
         # the collectable objects so that they are not sent on
         # to the host
         #hash[:objects].collectstrip!
     end
 end
 
 # $Id$
diff --git a/test/language/ast.rb b/test/language/ast.rb
index 2f657e5c8..d414a4f96 100755
--- a/test/language/ast.rb
+++ b/test/language/ast.rb
@@ -1,501 +1,535 @@
 #!/usr/bin/env ruby
 
 $:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'puppet/rails'
 require 'puppet/parser/interpreter'
 require 'puppet/parser/parser'
 require 'puppet/client'
 require 'puppettest'
 require 'puppettest/resourcetesting'
 require 'puppettest/parsertesting'
 require 'puppettest/railstesting'
 
 class TestAST < Test::Unit::TestCase
     include PuppetTest::RailsTesting
     include PuppetTest::ParserTesting
     include PuppetTest::ResourceTesting
 
     # A fake class that we can use for testing evaluation.
     class FakeAST
         attr_writer :evaluate
 
         def evaluate(*args)
             return @evaluate
         end
 
         def initialize(val = nil)
             if val
                 @evaluate = val
             end
         end
 
         def safeevaluate(*args)
             evaluate()
         end
     end
 
     if defined? ActiveRecord
     # Verify that our collection stuff works.
     def test_collection
         collectable = []
         non = []
         # First put some objects into the database.
         bucket = mk_transtree do |object, depth, width|
             # and mark some of them collectable
             if width % 2 == 1
                 object.collectable = true
                 collectable << object
             else
                 non << object
             end
         end
 
         # Now collect our facts
         facts = {}
         Facter.each do |fact, value| facts[fact] = value end
 
         assert_nothing_raised {
             Puppet::Rails.init
         }
 
         # Now try storing our crap
         assert_nothing_raised {
             host = Puppet::Rails::Host.store(
                 :objects => bucket,
                 :facts => facts,
                 :host => facts["hostname"]
             )
         }
 
         # Now create an ast tree that collects that.  They should all be files.
         coll = nil
         assert_nothing_raised {
             coll = AST::Collection.new(
                 :type => nameobj("file")
             )
         }
 
         top = nil
         assert_nothing_raised("Could not create top object") {
             top = AST::ASTArray.new(
                 :children => [coll]
             )
         }
 
         objects = nil
         assert_nothing_raised("Could not evaluate") {
             scope = mkscope
             objects = scope.evaluate(:ast => top).flatten
         }
 
         assert(objects.length > 0, "Did not receive any collected objects")
     end
     else
         $stderr.puts "No ActiveRecord -- skipping collection tests"
     end
 
     def test_if
         astif = nil
         astelse = nil
         fakeelse = FakeAST.new(:else)
         faketest = FakeAST.new(true)
         fakeif = FakeAST.new(:if)
 
         assert_nothing_raised {
             astelse = AST::Else.new(:statements => fakeelse)
         }
         assert_nothing_raised {
             astif = AST::IfStatement.new(
                 :test => faketest,
                 :statements => fakeif,
                 :else => astelse
             )
         }
 
         # We initialized it to true, so we should get that first
         ret = nil
         assert_nothing_raised {
             ret = astif.evaluate(:scope => "yay")
         }
         assert_equal(:if, ret)
 
         # Now set it to false and check that
         faketest.evaluate = false
         assert_nothing_raised {
             ret = astif.evaluate(:scope => "yay")
         }
         assert_equal(:else, ret)
     end
 
     # Make sure our override object behaves "correctly"
     def test_override
         interp, scope, source = mkclassframing
 
         ref = nil
         assert_nothing_raised do
             ref = resourceoverride("resource", "yaytest", "one" => "yay", "two" => "boo")
         end
 
         ret = nil
         assert_nothing_raised do
             ret = ref.evaluate :scope => scope
         end
 
         assert_instance_of(Puppet::Parser::Resource, ret)
 
         assert(ret.override?, "Resource was not an override resource")
 
         assert(scope.overridetable[ret.ref].include?(ret),
             "Was not stored in the override table")
     end
 
     # make sure our resourcedefaults ast object works correctly.
     def test_resourcedefaults
         interp, scope, source = mkclassframing
 
         # Now make some defaults for files
         args = {:source => "/yay/ness", :group => "yayness"}
         assert_nothing_raised do
             obj = defaultobj "file", args
             obj.evaluate :scope => scope
         end
 
         hash = nil
         assert_nothing_raised do
             hash = scope.lookupdefaults("file")
         end
 
         hash.each do |name, value|
             assert_instance_of(Symbol, name) # params always convert
             assert_instance_of(Puppet::Parser::Resource::Param, value)
         end
 
         args.each do |name, value|
             assert(hash[name], "Did not get default %s" % name)
             assert_equal(value, hash[name].value)
         end
     end
 
     def test_hostclass
         interp, scope, source = mkclassframing
 
         # Create the class we're testing, first with no parent
         klass = interp.newclass "first",
             :code => AST::ASTArray.new(
                 :children => [resourcedef("file", "/tmp",
                         "owner" => "nobody", "mode" => "755")]
             )
 
         assert_nothing_raised do
             klass.evaluate(:scope => scope)
         end
 
         # Then try it again
         assert_nothing_raised do
             klass.evaluate(:scope => scope)
         end
 
         assert(scope.setclass?(klass), "Class was not considered evaluated")
 
         tmp = scope.findresource("file[/tmp]")
         assert(tmp, "Could not find file /tmp")
         assert_equal("nobody", tmp[:owner])
         assert_equal("755", tmp[:mode])
 
         # Now create a couple more classes.
         newbase = interp.newclass "newbase",
             :code => AST::ASTArray.new(
                 :children => [resourcedef("file", "/tmp/other",
                         "owner" => "nobody", "mode" => "644")]
             )
 
         newsub = interp.newclass "newsub",
             :parent => "newbase",
             :code => AST::ASTArray.new(
                 :children => [resourcedef("file", "/tmp/yay",
                         "owner" => "nobody", "mode" => "755"),
                     resourceoverride("file", "/tmp/other",
                             "owner" => "daemon")
                 ]
             )
 
         # Override a different variable in the top scope.
         moresub = interp.newclass "moresub",
             :parent => "newbase",
             :code => AST::ASTArray.new(
                 :children => [resourceoverride("file", "/tmp/other",
                             "mode" => "755")]
             )
 
         assert_nothing_raised do
             newsub.evaluate(:scope => scope)
         end
 
         assert_nothing_raised do
             moresub.evaluate(:scope => scope)
         end
 
         assert(scope.setclass?(newbase), "Did not eval newbase")
         assert(scope.setclass?(newsub), "Did not eval newsub")
 
         yay = scope.findresource("file[/tmp/yay]")
         assert(yay, "Did not find file /tmp/yay")
         assert_equal("nobody", yay[:owner])
         assert_equal("755", yay[:mode])
 
         other = scope.findresource("file[/tmp/other]")
         assert(other, "Did not find file /tmp/other")
         assert_equal("daemon", other[:owner])
         assert_equal("755", other[:mode])
     end
 
     def test_component
         interp, scope, source = mkclassframing
 
         # Create a new definition
         klass = interp.newdefine "yayness",
             :arguments => [["owner", stringobj("nobody")], %w{mode}],
             :code => AST::ASTArray.new(
                 :children => [resourcedef("file", "/tmp/$name",
                         "owner" => varref("owner"), "mode" => varref("mode"))]
             )
 
         # Test validattr? a couple different ways
         [:owner, "owner", :schedule, "schedule"].each do |var|
             assert(klass.validattr?(var), "%s was not considered valid" % var.inspect)
         end
 
         [:random, "random"].each do |var|
             assert(! klass.validattr?(var), "%s was considered valid" % var.inspect)
         end
         # Now call it a couple of times
         # First try it without a required param
         assert_raise(Puppet::ParseError) do
             klass.evaluate(:scope => scope,
                 :name => "bad",
                 :arguments => {"owner" => "nobody"}
             )
         end
 
         # And make sure it didn't create the file
         assert_nil(scope.findresource("file[/tmp/bad]"),
             "Made file with invalid params")
 
         assert_nothing_raised do
             klass.evaluate(:scope => scope,
                 :name => "first",
                 :arguments => {"mode" => "755"}
             )
         end
 
         firstobj = scope.findresource("file[/tmp/first]")
         assert(firstobj, "Did not create /tmp/first obj")
 
         assert_equal("file", firstobj.type)
         assert_equal("/tmp/first", firstobj.title)
         assert_equal("nobody", firstobj[:owner])
         assert_equal("755", firstobj[:mode])
 
         # Make sure we can't evaluate it with the same args
         assert_raise(Puppet::ParseError) do
             klass.evaluate(:scope => scope,
                 :name => "first",
                 :arguments => {"mode" => "755"}
             )
         end
 
         # Now create another with different args
         assert_nothing_raised do
             klass.evaluate(:scope => scope,
                 :name => "second",
                 :arguments => {"mode" => "755", "owner" => "daemon"}
             )
         end
 
         secondobj = scope.findresource("file[/tmp/second]")
         assert(secondobj, "Did not create /tmp/second obj")
 
         assert_equal("file", secondobj.type)
         assert_equal("/tmp/second", secondobj.title)
         assert_equal("daemon", secondobj[:owner])
         assert_equal("755", secondobj[:mode])
     end
 
+    # Make sure that classes set their namespaces to themselves.  This
+    # way they start looking for definitions in their own namespace.
+    def test_hostclass_namespace
+        interp, scope, source = mkclassframing
+
+        # Create a new class
+        klass = nil
+        assert_nothing_raised do
+            klass = interp.newclass "funtest"
+        end
+
+        # Now define a definition in that namespace
+
+        define = nil
+        assert_nothing_raised do
+            define = interp.newdefine "funtest::mydefine"
+        end
+
+        assert_equal("funtest", klass.namespace,
+            "component namespace was not set in the class")
+
+        assert_equal("funtest", define.namespace,
+            "component namespace was not set in the definition")
+
+        newscope = klass.subscope(scope)
+
+        assert_equal("funtest", newscope.namespace,
+            "Scope did not inherit namespace")
+
+        # Now make sure we can find the define
+        assert(newscope.finddefine("mydefine"),
+            "Could not find definition in my enclosing class")
+    end
+
     def test_node
         interp = mkinterp
         scope = mkscope(:interp => interp)
 
         # Define a base node
         basenode = interp.newnode "basenode", :code => AST::ASTArray.new(:children => [
             resourcedef("file", "/tmp/base", "owner" => "root")
         ])
 
         # Now define a subnode
         nodes = interp.newnode ["mynode", "othernode"],
             :code => AST::ASTArray.new(:children => [
                 resourcedef("file", "/tmp/mynode", "owner" => "root"),
                 resourcedef("file", "/tmp/basenode", "owner" => "daemon")
         ])
 
         assert_instance_of(Array, nodes)
 
         # Make sure we can find them all.
         %w{mynode othernode}.each do |node|
             assert(interp.nodesearch_code(node), "Could not find %s" % node)
         end
         mynode = interp.nodesearch_code("mynode")
 
         # Now try evaluating the node
         assert_nothing_raised do
             mynode.evaluate :scope => scope
         end
 
         # Make sure that we can find each of the files
         myfile = scope.findresource "file[/tmp/mynode]"
         assert(myfile, "Could not find file from node")
         assert_equal("root", myfile[:owner])
 
         basefile = scope.findresource "file[/tmp/basenode]"
         assert(basefile, "Could not find file from base node")
         assert_equal("daemon", basefile[:owner])
 
         # Now make sure we can evaluate nodes with parents
         child = interp.newnode(%w{child}, :parent => "basenode").shift
 
         newscope = mkscope :interp => interp
         assert_nothing_raised do
             child.evaluate :scope => newscope
         end
 
         assert(newscope.findresource("file[/tmp/base]"),
             "Could not find base resource")
     end
 
     def test_collection
         interp = mkinterp
         scope = mkscope(:interp => interp)
 
         coll = nil
         assert_nothing_raised do
             coll = AST::Collection.new(:type => "file", :form => :virtual)
         end
 
         assert_instance_of(AST::Collection, coll)
 
         ret = nil
         assert_nothing_raised do
             ret = coll.evaluate :scope => scope
         end
 
         assert_instance_of(Puppet::Parser::Collector, ret)
 
         # Now make sure we get it back from the scope
         assert_equal([ret], scope.collections)
     end
 
     def test_virtual_collexp
         @interp, @scope, @source = mkclassframing
 
         # make a resource
         resource = mkresource(:type => "file", :title => "/tmp/testing",
             :params => {:owner => "root", :group => "bin", :mode => "644"})
 
         run_collection_queries(:virtual) do |string, result, query|
             code = nil
             assert_nothing_raised do
                 str, code = query.evaluate :scope => @scope
             end
 
             assert_instance_of(Proc, code)
             assert_nothing_raised do
                 assert_equal(result, code.call(resource),
                     "'#{string}' failed")
             end
         end
     end
 
     if defined? ActiveRecord::Base
     def test_exported_collexp
         railsinit
         Puppet[:storeconfigs] = true
         @interp, @scope, @source = mkclassframing
 
         # make a rails resource
         railsresource "file", "/tmp/testing", :owner => "root", :group => "bin",
             :mode => "644"
 
         run_collection_queries(:exported) do |string, result, query|
             code = nil
             str = nil
 
             # We don't support anything but the title in rails right now
             retval = nil
             bad = false
             # Figure out if the search is for anything rails will ignore
             string.scan(/(\w+) [!=]= \w+/) do |s|
                 unless s[0] == "title"
                     bad = true
                     break
                 end
             end
 
             # And if it is, make sure we throw an error.
             if bad
                 assert_raise(Puppet::ParseError, "Evaluated '#{string}'") do
                     str, code = query.evaluate :scope => @scope
                 end
                 next
             else
                 assert_nothing_raised("Could not evaluate '#{string}'") do
                     str, code = query.evaluate :scope => @scope
                 end
             end
             assert_nothing_raised("Could not find resource") do
                 retval = Puppet::Rails::RailsResource.find(:all,
                     :include => :rails_parameters,
                     :conditions => str) 
             end
 
             if result
                 assert_equal(1, retval.length, "Did not find resource with '#{string}'")
                 res = retval.shift
 
                 assert_equal("file", res.restype)
                 assert_equal("/tmp/testing", res.title)
             else
                 assert_equal(0, retval.length, "found a resource with '#{string}'")
             end
         end
     end
     end
 
     def run_collection_queries(form)
         {true => [%{title == "/tmp/testing"}, %{(title == "/tmp/testing")},
             %{title == "/tmp/testing" and group == bin}, %{title == bin or group == bin},
             %{title == "/tmp/testing" or title == bin}, %{title == "/tmp/testing"},
             %{(title == "/tmp/testing" or title == bin) and group == bin}],
         false => [%{title == bin}, %{title == bin or (title == bin and group == bin)},
             %{title != "/tmp/testing"}, %{title != "/tmp/testing" and group != bin}]
         }.each do |res, ary|
             ary.each do |str|
                 if form == :virtual
                     code = "File <| #{str} |>"
                 else
                     code = "File <<| #{str} |>>"
                 end
                 parser = mkparser
                 query = nil
 
                 assert_nothing_raised("Could not parse '#{str}'") do
                     query = parser.parse(code)[0].query
                 end
 
                 yield str, res, query
             end
         end
     end
 end
 
 # $Id$