Merge remote branch 'paul/4472-4483-4496-4521-4522'

a.k.a. "make_taller_trees"

17 files changed, 379 insertions, 246 deletions

diff --git a/spec/integration/parser/collector_spec.rb b/spec/integration/parser/collector_spec.rb
index 73273c909..b1cfc51c7 100755
--- a/spec/integration/parser/collector_spec.rb
+++ b/spec/integration/parser/collector_spec.rb
@@ -17,7 +17,7 @@ describe Puppet::Parser::Collector do
   def query(text)
     code = "File <| #{text} |>"
     parser = Puppet::Parser::Parser.new(@scope.compiler)
-    parser.parse(code).hostclass("").code[0].query
+    return parser.parse(code).code[0].query
   end
 
   {true => [%{title == "/tmp/testing"}, %{(title == "/tmp/testing")}, %{group == bin},
diff --git a/spec/integration/parser/compiler_spec.rb b/spec/integration/parser/compiler_spec.rb
index 9158ad1c2..266347c60 100755
--- a/spec/integration/parser/compiler_spec.rb
+++ b/spec/integration/parser/compiler_spec.rb
@@ -69,4 +69,26 @@ describe Puppet::Parser::Compiler do
       notify_resource[:require].title.should == "Experiment::Baz"
     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
+
+  it "should not allow classes inside conditional constructs" do
+    Puppet[:code] = <<-PP
+      if true {
+        class foo {
+        }
+      }
+    PP
+
+    lambda { Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode")) }.should raise_error(Puppet::Error)
+  end
 end
diff --git a/spec/integration/parser/parser_spec.rb b/spec/integration/parser/parser_spec.rb
index 7b85bcacb..0d9aa51e1 100755
--- a/spec/integration/parser/parser_spec.rb
+++ b/spec/integration/parser/parser_spec.rb
@@ -11,7 +11,7 @@ describe Puppet::Parser::Parser do
       end
 
       def result_instance
-        @result.hostclass("").code[0]
+        @result.code[0]
       end
 
       def matches?(string)
@@ -44,7 +44,7 @@ describe Puppet::Parser::Parser do
       end
 
       def result_instance
-        @result.hostclass("").code[0]
+        @result.code[0]
       end
 
       def matches?(string)
@@ -85,7 +85,9 @@ describe Puppet::Parser::Parser do
       class test {}
       """)
 
-      ast.hostclass("test").doc.should == "comment\n"
+      ast.code[0].should be_a(Puppet::Parser::AST::Hostclass)
+      ast.code[0].name.should == 'test'
+      ast.code[0].instantiate('')[0].doc.should == "comment\n"
     end
   end
 
diff --git a/spec/unit/application/apply_spec.rb b/spec/unit/application/apply_spec.rb
index 0b00d1a2e..a79ddbad3 100755
--- a/spec/unit/application/apply_spec.rb
+++ b/spec/unit/application/apply_spec.rb
@@ -142,17 +142,16 @@ describe Puppet::Application::Apply do
 
     describe "the parseonly command" do
       before :each do
-        Puppet.stubs(:[]).with(:environment)
+        @environment = Puppet::Node::Environment.new("env")
+        Puppet.stubs(:[]).with(:environment).returns(@environment)
         Puppet.stubs(:[]).with(:manifest).returns("site.pp")
         Puppet.stubs(:err)
         @apply.stubs(:exit)
         @apply.options.stubs(:[]).with(:code).returns "some code"
-        @collection = stub_everything
-        Puppet::Resource::TypeCollection.stubs(:new).returns(@collection)
       end
 
-      it "should use a Puppet Resource Type Collection to parse the file" do
-        @collection.expects(:perform_initial_import)
+      it "should use the environment to parse the file" do
+        @environment.stubs(:perform_initial_import)
         @apply.parseonly
       end
 
@@ -162,7 +161,7 @@ describe Puppet::Application::Apply do
       end
 
       it "should exit with exit code 1 if error" do
-        @collection.stubs(:perform_initial_import).raises(Puppet::ParseError)
+        @environment.stubs(:perform_initial_import).raises(Puppet::ParseError)
         @apply.expects(:exit).with(1)
         @apply.parseonly
       end
diff --git a/spec/unit/application/master_spec.rb b/spec/unit/application/master_spec.rb
index 0baa8229b..d23021317 100644
--- a/spec/unit/application/master_spec.rb
+++ b/spec/unit/application/master_spec.rb
@@ -257,16 +257,15 @@ describe Puppet::Application::Master do
 
     describe "the parseonly command" do
       before :each do
-        Puppet.stubs(:[]).with(:environment)
+        @environment = Puppet::Node::Environment.new("env")
+        Puppet.stubs(:[]).with(:environment).returns(@environment)
         Puppet.stubs(:[]).with(:manifest).returns("site.pp")
         Puppet.stubs(:err)
         @master.stubs(:exit)
-        @collection = stub_everything
-        Puppet::Resource::TypeCollection.stubs(:new).returns(@collection)
       end
 
       it "should use a Puppet Resource Type Collection to parse the file" do
-        @collection.expects(:perform_initial_import)
+        @environment.expects(:perform_initial_import)
         @master.parseonly
       end
 
@@ -276,7 +275,7 @@ describe Puppet::Application::Master do
       end
 
       it "should exit with exit code 1 if error" do
-        @collection.stubs(:perform_initial_import).raises(Puppet::ParseError)
+        @environment.stubs(:perform_initial_import).raises(Puppet::ParseError)
         @master.expects(:exit).with(1)
         @master.parseonly
       end
diff --git a/spec/unit/dsl/resource_type_api_spec.rb b/spec/unit/dsl/resource_type_api_spec.rb
index 5abe79ea7..4b8ccf5a7 100755
--- a/spec/unit/dsl/resource_type_api_spec.rb
+++ b/spec/unit/dsl/resource_type_api_spec.rb
@@ -16,22 +16,20 @@ describe Puppet::DSL::ResourceTypeAPI do
   [:definition, :node, :hostclass].each do |type|
     method = type == :definition ? "define" : type
     it "should be able to create a #{type}" do
-      newtype = Puppet::Resource::Type.new(:hostclass, "foo")
-      Puppet::Resource::Type.expects(:new).with { |t, n, args| t == type }.returns newtype
-      @api.send(method, "myname")
+      newtype = @api.send(method, "myname")
+      newtype.should be_a(Puppet::Resource::Type)
+      newtype.type.should == type
     end
 
     it "should use the provided name when creating a #{type}" do
-      type = Puppet::Resource::Type.new(:hostclass, "foo")
-      Puppet::Resource::Type.expects(:new).with { |t, n, args| n == "myname" }.returns type
-      @api.send(method, "myname")
+      newtype = @api.send(method, "myname")
+      newtype.name.should == "myname"
     end
 
     unless type == :definition
-      it "should pass in any provided options" do
-        type = Puppet::Resource::Type.new(:hostclass, "foo")
-        Puppet::Resource::Type.expects(:new).with { |t, n, args| args == {:myarg => :myvalue} }.returns type
-        @api.send(method, "myname", :myarg => :myvalue)
+      it "should pass in any provided options when creating a #{type}" do
+        newtype = @api.send(method, "myname", :line => 200)
+        newtype.line.should == 200
       end
     end
 
diff --git a/spec/unit/node/environment_spec.rb b/spec/unit/node/environment_spec.rb
index 6edcce56c..be2980879 100755
--- a/spec/unit/node/environment_spec.rb
+++ b/spec/unit/node/environment_spec.rb
@@ -52,7 +52,7 @@ describe Puppet::Node::Environment do
     before do
       @env = Puppet::Node::Environment.new("dev")
       @collection = Puppet::Resource::TypeCollection.new(@env)
-      @collection.stubs(:perform_initial_import)
+      @env.stubs(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
       Thread.current[:known_resource_types] = nil
     end
 
@@ -66,9 +66,8 @@ describe Puppet::Node::Environment do
     end
 
     it "should perform the initial import when creating a new collection" do
-      @collection.expects(:perform_initial_import)
-      Puppet::Resource::TypeCollection.expects(:new).returns @collection
-
+      @env = Puppet::Node::Environment.new("dev")
+      @env.expects(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
       @env.known_resource_types
     end
 
@@ -274,4 +273,56 @@ describe Puppet::Node::Environment do
       @helper.environment.name.should == :foo
     end
   end
+
+  describe "when performing initial import" do
+    before do
+      @parser = stub 'parser', :file= => nil, :string => nil, :parse => nil
+      Puppet::Parser::Parser.stubs(:new).returns @parser
+      @env = Puppet::Node::Environment.new("env")
+    end
+
+    it "should create a new parser instance" do
+      Puppet::Parser::Parser.expects(:new).returns @parser
+      @env.instance_eval { perform_initial_import }
+    end
+
+    it "should set the parser's string to the 'code' setting and parse if code is available" do
+      Puppet.settings[:code] = "my code"
+      @parser.expects(:string=).with "my code"
+      @parser.expects(:parse)
+      @env.instance_eval { perform_initial_import }
+    end
+
+    it "should set the parser's file to the 'manifest' setting and parse if no code is available and the manifest is available" do
+      File.stubs(:expand_path).with("/my/file").returns "/my/file"
+      File.expects(:exist?).with("/my/file").returns true
+      Puppet.settings[:manifest] = "/my/file"
+      @parser.expects(:file=).with "/my/file"
+      @parser.expects(:parse)
+      @env.instance_eval { perform_initial_import }
+    end
+
+    it "should not attempt to load a manifest if none is present" do
+      File.stubs(:expand_path).with("/my/file").returns "/my/file"
+      File.expects(:exist?).with("/my/file").returns false
+      Puppet.settings[:manifest] = "/my/file"
+      @parser.expects(:file=).never
+      @parser.expects(:parse).never
+      @env.instance_eval { perform_initial_import }
+    end
+
+    it "should fail helpfully if there is an error importing" do
+      File.stubs(:exist?).returns true
+      @parser.expects(:parse).raises ArgumentError
+      lambda { @env.instance_eval { perform_initial_import } }.should raise_error(Puppet::Error)
+    end
+
+    it "should not do anything if the ignore_import settings is set" do
+      Puppet.settings[:ignoreimport] = true
+      @parser.expects(:string=).never
+      @parser.expects(:file=).never
+      @parser.expects(:parse).never
+      @env.instance_eval { perform_initial_import }
+    end
+  end
 end
diff --git a/spec/unit/parser/ast/definition_spec.rb b/spec/unit/parser/ast/definition_spec.rb
new file mode 100644
index 000000000..01ca068ad
--- /dev/null
+++ b/spec/unit/parser/ast/definition_spec.rb
@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::Definition do
+  describe "when instantiated" do
+    it "should create a definition with the proper type, name, context, and module name" do
+      definition = Puppet::Parser::AST::Definition.new('foo', :line => 5)
+      instantiated_definitions = definition.instantiate('modname')
+      instantiated_definitions.length.should == 1
+      instantiated_definitions[0].type.should == :definition
+      instantiated_definitions[0].name.should == 'foo'
+      instantiated_definitions[0].line.should == 5
+      instantiated_definitions[0].module_name.should == 'modname'
+    end
+  end
+end
diff --git a/spec/unit/parser/ast/hostclass_spec.rb b/spec/unit/parser/ast/hostclass_spec.rb
new file mode 100644
index 000000000..b22eba98b
--- /dev/null
+++ b/spec/unit/parser/ast/hostclass_spec.rb
@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::Hostclass do
+  def ast
+    Puppet::Parser::AST
+  end
+
+  def newarray(*elems)
+    ast::ASTArray.new({}).push(*elems)
+  end
+
+  it "should make its name and context available through accessors" do
+    hostclass = ast::Hostclass.new('foo', :line => 5)
+    hostclass.name.should == 'foo'
+    hostclass.context.should == {:line => 5}
+  end
+
+  it "should make its code available through an accessor" do
+    code = newarray
+    hostclass = ast::Hostclass.new('foo', :code => code)
+    hostclass.code.should be_equal(code)
+  end
+
+  describe "when instantiated" do
+    it "should create a class with the proper type, code, name, context, and module name" do
+      code = newarray
+      hostclass = ast::Hostclass.new('foo', :code => code, :line => 5)
+      instantiated_class = hostclass.instantiate('modname')[0]
+      instantiated_class.type.should == :hostclass
+      instantiated_class.name.should == 'foo'
+      instantiated_class.code.should be_equal(code)
+      instantiated_class.line.should == 5
+      instantiated_class.module_name.should == 'modname'
+    end
+
+    it "should instantiate all nested classes, defines, and nodes with the same module name." do
+      nested_objects = newarray(ast::Hostclass.new('foo::child1'),
+                                ast::Definition.new('foo::child2'),
+                                ast::Definition.new('child3'))
+      hostclass = ast::Hostclass.new('foo', :code => nested_objects)
+      instantiated_classes = hostclass.instantiate('modname')
+      instantiated_classes.length.should == 4
+      instantiated_classes[0].name.should == 'foo'
+      instantiated_classes[1].name.should == 'foo::child1'
+      instantiated_classes[2].name.should == 'foo::child2'
+      instantiated_classes[3].name.should == 'child3'
+      instantiated_classes.each { |cls| cls.module_name.should == 'modname' }
+    end
+
+    it "should handle a nested class that contains its own nested classes." do
+      foo_bar_baz = ast::Hostclass.new('foo::bar::baz')
+      foo_bar = ast::Hostclass.new('foo::bar', :code => newarray(foo_bar_baz))
+      foo = ast::Hostclass.new('foo', :code => newarray(foo_bar))
+      instantiated_classes = foo.instantiate('')
+      instantiated_classes.length.should == 3
+      instantiated_classes[0].name.should == 'foo'
+      instantiated_classes[1].name.should == 'foo::bar'
+      instantiated_classes[2].name.should == 'foo::bar::baz'
+    end
+
+    it "should skip nested elements that are not classes, definitions, or nodes." do
+      func = ast::Function.new(:name => 'biz', :arguments => newarray(ast::Name.new(:value => 'baz')))
+      foo = ast::Hostclass.new('foo', :code => newarray(func))
+      instantiated_classes = foo.instantiate('')
+      instantiated_classes.length.should == 1
+      instantiated_classes[0].should be_a(Puppet::Resource::Type)
+      instantiated_classes[0].name.should == 'foo'
+    end
+  end
+end
+
diff --git a/spec/unit/parser/ast/node_spec.rb b/spec/unit/parser/ast/node_spec.rb
new file mode 100644
index 000000000..409e877f9
--- /dev/null
+++ b/spec/unit/parser/ast/node_spec.rb
@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::Node do
+  describe "when instantiated" do
+    it "should make its names available through an accessor" do
+      node = Puppet::Parser::AST::Node.new(['foo', 'bar'])
+      node.names.should == ['foo', 'bar']
+    end
+
+    it "should create a node with the proper type, name, context, and module name" do
+      node = Puppet::Parser::AST::Node.new(['foo'], :line => 5)
+      instantiated_nodes = node.instantiate('modname')
+      instantiated_nodes.length.should == 1
+      instantiated_nodes[0].type.should == :node
+      instantiated_nodes[0].name.should == 'foo'
+      instantiated_nodes[0].line.should == 5
+      instantiated_nodes[0].module_name.should == 'modname'
+    end
+
+    it "should handle multiple names" do
+      node = Puppet::Parser::AST::Node.new(['foo', 'bar'])
+      instantiated_nodes = node.instantiate('modname')
+      instantiated_nodes.length.should == 2
+      instantiated_nodes[0].name.should == 'foo'
+      instantiated_nodes[1].name.should == 'bar'
+    end
+  end
+end
diff --git a/spec/unit/parser/ast/resource_spec.rb b/spec/unit/parser/ast/resource_spec.rb
index 5c94ac0e9..6dbfc1f04 100755
--- a/spec/unit/parser/ast/resource_spec.rb
+++ b/spec/unit/parser/ast/resource_spec.rb
@@ -89,9 +89,9 @@ describe Puppet::Parser::AST::Resource 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)
-      @parser.newdefine "one"
-      @parser.newdefine "one::two"
-      @parser.newdefine "three"
+      ["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
diff --git a/spec/unit/parser/parser_spec.rb b/spec/unit/parser/parser_spec.rb
index 0657ab37a..0a61e73de 100755
--- a/spec/unit/parser/parser_spec.rb
+++ b/spec/unit/parser/parser_spec.rb
@@ -73,14 +73,16 @@ describe Puppet::Parser do
       lambda { @parser.parse("$var += ") }.should raise_error
     end
 
-    it "should call ast::VarDef with append=true" do
-      ast::VarDef.expects(:new).with { |h| h[:append] == true }
-      @parser.parse("$var += 2")
+    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
-      ast::VarDef.expects(:new).with { |h| h[:append] == true }
-      @parser.parse("$var += ['test']")
+      vardef = @parser.parse("$var += ['test']").code[0]
+      vardef.should be_a(Puppet::Parser::AST::VarDef)
+      vardef.append.should == true
     end
 
   end
@@ -160,10 +162,14 @@ describe Puppet::Parser do
     end
 
     it "should create an ast::ResourceOverride" do
-      ast::ResourceOverride.expects(:new).with { |arg|
-        arg[:line]==1 and arg[:object].is_a?(ast::ResourceReference) and arg[:parameters].is_a?(ast::ResourceParam)
-      }
-      @parser.parse('Resource["title1","title2"] { param => value }')
+      #ast::ResourceOverride.expects(:new).with { |arg|
+      #  arg[:line]==1 and arg[:object].is_a?(ast::ResourceReference) and arg[:parameters].is_a?(ast::ResourceParam)
+      #}
+      ro = @parser.parse('Resource["title1","title2"] { param => value }').code[0]
+      ro.should be_a(ast::ResourceOverride)
+      ro.line.should == 1
+      ro.object.should be_a(ast::ResourceReference)
+      ro.parameters[0].should be_a(ast::ResourceParam)
     end
 
   end
@@ -290,24 +296,6 @@ describe Puppet::Parser do
     end
   end
 
-  describe "when creating a node" do
-    before :each do
-      @lexer = stub 'lexer'
-      @lexer.stubs(:getcomment)
-      @parser.stubs(:lexer).returns(@lexer)
-      @node = stub_everything 'node'
-      @parser.stubs(:ast_context).returns({})
-      @parser.stubs(:node).returns(nil)
-
-      @nodename = stub 'nodename', :is_a? => false, :value => "foo"
-      @nodename.stubs(:is_a?).with(Puppet::Parser::AST::HostName).returns(true)
-    end
-
-    it "should return an array of nodes" do
-      @parser.newnode(@nodename).should be_instance_of(Array)
-    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")
@@ -360,30 +348,28 @@ describe Puppet::Parser do
       @parser.stubs(:known_resource_types).returns @krt
     end
 
-    it "should create new classes" do
-      @parser.parse("class foobar {}")
-      @krt.hostclass("foobar").should be_instance_of(Puppet::Resource::Type)
+    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 {}")
-      @krt.hostclass("foobar").parent.should == "yayness"
+      @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
-      @parser.parse("class foobar inherits yayness {}\nclass boo inherits bar {}")
-      @krt.hostclass("foobar").parent.should == "yayness"
-      @krt.hostclass("boo").parent.should == "bar"
+      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 }")
-      @krt.hostclass("foobar").code.should_not be_nil
+      @parser.parse("class foobar { $var = val }").code[0].code.should_not be_nil
     end
 
     it "should define parameters when provided" do
-      @parser.parse("class foobar($biz,$baz) {}")
-      @krt.hostclass("foobar").arguments.should == {"biz" => nil, "baz" => nil}
+      foobar = @parser.parse("class foobar($biz,$baz) {}").code[0].instantiate('')[0]
+      foobar.arguments.should == {"biz" => nil, "baz" => nil}
     end
   end
 
@@ -400,13 +386,37 @@ describe Puppet::Parser do
     end
 
     it "should correctly mark exported resources as exported" do
-      @parser.parse("@@file { '/file': }")
-      @krt.hostclass("").code[0].exported.should be_true
+      @parser.parse("@@file { '/file': }").code[0][0].exported.should be_true
     end
 
     it "should correctly mark virtual resources as virtual" do
-      @parser.parse("@file { '/file': }")
-      @krt.hostclass("").code[0].virtual.should be_true
+      @parser.parse("@file { '/file': }").code[0][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
 end
diff --git a/spec/unit/parser/scope_spec.rb b/spec/unit/parser/scope_spec.rb
index 9895f446b..2e390a53b 100755
--- a/spec/unit/parser/scope_spec.rb
+++ b/spec/unit/parser/scope_spec.rb
@@ -29,8 +29,7 @@ describe Puppet::Parser::Scope do
   end
 
   it "should be able to retrieve its parent module name from the source of its parent type" do
-    @topscope.source = Puppet::Resource::Type.new(:hostclass, :foo)
-    @topscope.source.module_name = "foo"
+    @topscope.source = Puppet::Resource::Type.new(:hostclass, :foo, :module_name => "foo")
 
     @scope.parent_module_name.should == "foo"
   end
diff --git a/spec/unit/parser/type_loader_spec.rb b/spec/unit/parser/type_loader_spec.rb
index 83006b37b..58c386d96 100644
--- a/spec/unit/parser/type_loader_spec.rb
+++ b/spec/unit/parser/type_loader_spec.rb
@@ -28,92 +28,26 @@ describe Puppet::Parser::TypeLoader do
   describe "when loading names from namespaces" do
     it "should do nothing if the name to import is an empty string" do
       @loader.expects(:name2files).never
-      @loader.load_until(["foo"], "") { |f| false }.should be_nil
-    end
-
-    it "should turn the provided namespaces and name into a list of files" do
-      @loader.expects(:name2files).with(["foo"], "bar").returns []
-      @loader.load_until(["foo"], "bar") { |f| false }
+      @loader.try_load_fqname(:hostclass, "") { |filename, modname| raise :should_not_occur }.should be_nil
     end
 
     it "should attempt to import each generated name" do
-      @loader.expects(:name2files).returns %w{foo bar}
-      @loader.expects(:import).with("foo",nil)
-      @loader.expects(:import).with("bar",nil)
-      @loader.load_until(["foo"], "bar") { |f| false }
-    end
-
-    it "should yield after each import" do
-      yielded = []
-      @loader.expects(:name2files).returns %w{foo bar}
-      @loader.expects(:import).with("foo",nil)
-      @loader.expects(:import).with("bar",nil)
-      @loader.load_until(["foo"], "bar") { |f| yielded << f; false }
-      yielded.should == %w{foo bar}
-    end
-
-    it "should stop importing when the yielded block returns true" do
-      yielded = []
-      @loader.expects(:name2files).returns %w{foo bar baz}
-      @loader.expects(:import).with("foo",nil)
-      @loader.expects(:import).with("bar",nil)
-      @loader.expects(:import).with("baz",nil).never
-      @loader.load_until(["foo"], "bar") { |f| true if f == "bar" }
-    end
-
-    it "should return the result of the block" do
-      yielded = []
-      @loader.expects(:name2files).returns %w{foo bar baz}
-      @loader.expects(:import).with("foo",nil)
-      @loader.expects(:import).with("bar",nil)
-      @loader.expects(:import).with("baz",nil).never
-      @loader.load_until(["foo"], "bar") { |f| 10 if f == "bar" }.should == 10
-    end
-
-    it "should return nil if the block never returns true" do
-      @loader.expects(:name2files).returns %w{foo bar}
-      @loader.expects(:import).with("foo",nil)
-      @loader.expects(:import).with("bar",nil)
-      @loader.load_until(["foo"], "bar") { |f| false }.should be_nil
+      @loader.expects(:import).with("foo/bar",nil).returns([])
+      @loader.expects(:import).with("foo",nil).returns([])
+      @loader.try_load_fqname(:hostclass, "foo::bar") { |f| false }
     end
 
     it "should know when a given name has been loaded" do
-      @loader.expects(:name2files).returns %w{file}
-      @loader.expects(:import).with("file",nil)
-      @loader.load_until(["foo"], "bar") { |f| true }
+      @loader.expects(:import).with("file",nil).returns([])
+      @loader.try_load_fqname(:hostclass, "file") { |f| true }
       @loader.should be_loaded("file")
     end
-
-    it "should set the module name on any created resource types" do
-      type = Puppet::Resource::Type.new(:hostclass, "mytype")
-
-      Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{one}]
-      @loader.stubs(:parse_file)
-      @loader.load_until(["foo"], "one") { |f| type }
-
-      type.module_name.should == "modname"
-    end
-  end
-
-  describe "when mapping names to files" do
-    {
-      [["foo"], "::bar::baz"] => %w{bar/baz},
-      [[""], "foo::bar"]      => %w{foo foo/bar},
-      [%w{foo}, "bar"]        => %w{foo foo/bar bar},
-      [%w{a b}, "bar"]        => %w{a a/bar b b/bar bar},
-      [%w{a::b::c}, "bar"]    => %w{a a/b/c/bar bar},
-      [%w{a::b}, "foo::bar"]  => %w{a a/b/foo/bar foo/bar}
-    }.each do |inputs, outputs|
-      it "should produce #{outputs.inspect} from the #{inputs[0].inspect} namespace and #{inputs[1]} name" do
-        @loader.name2files(*inputs).should == outputs
-      end
-    end
   end
 
   describe "when importing" do
     before do
       Puppet::Parser::Files.stubs(:find_manifests).returns ["modname", %w{file}]
-      @loader.stubs(:parse_file)
+      @loader.stubs(:parse_file).returns(Puppet::Parser::AST::Hostclass.new(''))
     end
 
     it "should return immediately when imports are being ignored" do
@@ -144,13 +78,13 @@ describe Puppet::Parser::TypeLoader do
 
     it "should parse each found file" do
       Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{/one}]
-      @loader.expects(:parse_file).with("/one")
+      @loader.expects(:parse_file).with("/one").returns(Puppet::Parser::AST::Hostclass.new(''))
       @loader.import("myfile")
     end
 
     it "should make each file qualified before attempting to parse it" do
       Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{one}]
-      @loader.expects(:parse_file).with("/current/one")
+      @loader.expects(:parse_file).with("/current/one").returns(Puppet::Parser::AST::Hostclass.new(''))
       @loader.import("myfile", "/current/file")
     end
 
@@ -163,7 +97,7 @@ describe Puppet::Parser::TypeLoader do
 
     it "should not attempt to import files that have already been imported" do
       Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{/one}]
-      @loader.expects(:parse_file).once
+      @loader.expects(:parse_file).once.returns(Puppet::Parser::AST::Hostclass.new(''))
       @loader.import("myfile")
 
       # This will fail if it tries to reimport the file.
@@ -174,7 +108,7 @@ describe Puppet::Parser::TypeLoader do
   describe "when parsing a file" do
     before do
       @parser = Puppet::Parser::Parser.new(@loader.environment)
-      @parser.stubs(:parse)
+      @parser.stubs(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
       @parser.stubs(:file=)
       Puppet::Parser::Parser.stubs(:new).with(@loader.environment).returns @parser
     end
@@ -186,7 +120,7 @@ describe Puppet::Parser::TypeLoader do
 
     it "should assign the parser its file and parse" do
       @parser.expects(:file=).with("/my/file")
-      @parser.expects(:parse)
+      @parser.expects(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
       @loader.parse_file("/my/file")
     end
   end
@@ -198,4 +132,15 @@ describe Puppet::Parser::TypeLoader do
 
     @loader.known_resource_types.hostclass("foo").should be_instance_of(Puppet::Resource::Type)
   end
+
+  describe "when deciding where to look for files" do
+    { 'foo' => ['foo'],
+      'foo::bar' => ['foo/bar', 'foo'],
+      'foo::bar::baz' => ['foo/bar/baz', 'foo/bar', 'foo']
+    }.each do |fqname, expected_paths|
+      it "should look for #{fqname.inspect} in #{expected_paths.inspect}" do
+        @loader.instance_eval { name2files(fqname) }.should == expected_paths
+      end
+    end
+  end
 end
diff --git a/spec/unit/resource/type_collection_spec.rb b/spec/unit/resource/type_collection_spec.rb
index 577aea42b..b8da3cf58 100644
--- a/spec/unit/resource/type_collection_spec.rb
+++ b/spec/unit/resource/type_collection_spec.rb
@@ -89,6 +89,34 @@ describe Puppet::Resource::TypeCollection do
     loader.node("node").should be_nil
   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")
@@ -107,29 +135,32 @@ describe Puppet::Resource::TypeCollection do
 
     describe "that need to be loaded" do
       it "should use the loader to load the files" do
-        @code.loader.expects(:load_until).with(["ns"], "klass")
-        @code.find_or_load(["ns"], "klass", :hostclass)
+        @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(:load_until).with(["ns"], "klass")
-        @code.find_or_load("Ns", "Klass", :hostclass)
+        @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 attempt to find the type when the loader yields" do
-        @code.loader.expects(:load_until).yields
-        @code.expects(:find).with(["ns"], "klass", :hostclass).times(2).returns(false).then.returns(true)
-        @code.find_or_load("ns", "klass", :hostclass)
+      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 the result of 'load_until'" do
-        @code.loader.expects(:load_until).returns "foo"
-        @code.find_or_load("Ns", "Klass", :hostclass).should == "foo"
+      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 "should return nil if the name isn't found" do
-        @code.stubs(:load_until).returns(nil)
-        @code.find_or_load("Ns", "Klass", :hostclass).should be_nil
+      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
@@ -195,68 +226,68 @@ describe Puppet::Resource::TypeCollection do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
-      loader.find("namespace", "::foo::bar", :hostclass).should equal(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("namespace", "::foo::bar", :hostclass).should be_nil
+      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("", "foo", :hostclass).should equal(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("foo", "bar::baz", :hostclass).should equal(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(["nons", "foo", "otherns"], "bar::baz", :hostclass).should equal(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("foo", "bar", :hostclass).should equal(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("foo::bar::baz", "bar", :hostclass).should equal(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("foo::bar", "bar::baz", :hostclass).should equal(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("foo::bar", "foo::bar::baz", :hostclass).should equal(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("foo::bar", "eh", :hostclass).should be_nil
+      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
@@ -268,11 +299,11 @@ describe Puppet::Resource::TypeCollection do
       end
 
       it "should favor the local class, if the name is unqualified" do
-        @loader.find("foo", "bar",   :hostclass).name.should == 'foo::bar'
+        @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("foo", "::bar", :hostclass).name.should == 'bar'
+        @loader.find_hostclass("foo", "::bar").name.should == 'bar'
       end
 
     end
@@ -281,15 +312,16 @@ describe Puppet::Resource::TypeCollection do
         @loader = Puppet::Resource::TypeCollection.new("env")
         @loader.add Puppet::Resource::Type.new(:hostclass, "foo::bar")
 
-        @loader.find("foo", "::bar", :hostclass).should == nil
+        @loader.find_hostclass("foo", "::bar").should == nil
     end
 
   end
 
-  it "should use the generic 'find' method with an empty namespace to find nodes" do
+  it "should be able to find nodes" do
+    node = Puppet::Resource::Type.new(:node, "bar")
     loader = Puppet::Resource::TypeCollection.new("env")
-    loader.expects(:find).with("", "bar", :node)
-    loader.find_node(stub("ignored"), "bar")
+    loader.add(node)
+    loader.find_node(stub("ignored"), "bar").should == node
   end
 
   it "should use the 'find_or_load' method to find hostclasses" do
@@ -384,58 +416,6 @@ describe Puppet::Resource::TypeCollection do
     end
   end
 
-  describe "when performing initial import" do
-    before do
-      @parser = stub 'parser', :file= => nil, :string => nil, :parse => nil
-      Puppet::Parser::Parser.stubs(:new).returns @parser
-      @code = Puppet::Resource::TypeCollection.new("env")
-    end
-
-    it "should create a new parser instance" do
-      Puppet::Parser::Parser.expects(:new).returns @parser
-      @code.perform_initial_import
-    end
-
-    it "should set the parser's string to the 'code' setting and parse if code is available" do
-      Puppet.settings[:code] = "my code"
-      @parser.expects(:string=).with "my code"
-      @parser.expects(:parse)
-      @code.perform_initial_import
-    end
-
-    it "should set the parser's file to the 'manifest' setting and parse if no code is available and the manifest is available" do
-      File.stubs(:expand_path).with("/my/file").returns "/my/file"
-      File.expects(:exist?).with("/my/file").returns true
-      Puppet.settings[:manifest] = "/my/file"
-      @parser.expects(:file=).with "/my/file"
-      @parser.expects(:parse)
-      @code.perform_initial_import
-    end
-
-    it "should not attempt to load a manifest if none is present" do
-      File.stubs(:expand_path).with("/my/file").returns "/my/file"
-      File.expects(:exist?).with("/my/file").returns false
-      Puppet.settings[:manifest] = "/my/file"
-      @parser.expects(:file=).never
-      @parser.expects(:parse).never
-      @code.perform_initial_import
-    end
-
-    it "should fail helpfully if there is an error importing" do
-      File.stubs(:exist?).returns true
-      @parser.expects(:parse).raises ArgumentError
-      lambda { @code.perform_initial_import }.should raise_error(Puppet::Error)
-    end
-
-    it "should not do anything if the ignore_import settings is set" do
-      Puppet.settings[:ignoreimport] = true
-      @parser.expects(:string=).never
-      @parser.expects(:file=).never
-      @parser.expects(:parse).never
-      @code.perform_initial_import
-    end
-  end
-
   describe "when determining the configuration version" do
     before do
       @code = Puppet::Resource::TypeCollection.new("env")
diff --git a/spec/unit/resource/type_spec.rb b/spec/unit/resource/type_spec.rb
index 4d3942c5c..29c13c53f 100755
--- a/spec/unit/resource/type_spec.rb
+++ b/spec/unit/resource/type_spec.rb
@@ -322,7 +322,7 @@ describe Puppet::Resource::Type do
     end
 
     it "should set its module name in the scope if available" do
-      @type.module_name = "mymod"
+      @type.instance_eval { @module_name = "mymod" }
 
       @type.set_resource_parameters(@resource, @scope)
 
@@ -514,8 +514,7 @@ describe Puppet::Resource::Type do
         @compiler.add_resource @scope, @parent_resource
 
         @type.resource_type_collection = @scope.known_resource_types
-        @type.resource_type_collection.stubs(:node).with("parent").returns(@parent_type)
-        @type.resource_type_collection.stubs(:node).with("Parent").returns(@parent_type)
+        @type.resource_type_collection.add(@parent_type)
       end
 
       it "should evaluate the parent's resource" do
diff --git a/spec/unit/util/rdoc/parser_spec.rb b/spec/unit/util/rdoc/parser_spec.rb
index 79195e657..5dc083cab 100755
--- a/spec/unit/util/rdoc/parser_spec.rb
+++ b/spec/unit/util/rdoc/parser_spec.rb
@@ -16,12 +16,17 @@ describe RDoc::Parser do
   end
 
   describe "when scanning files" do
+    before do
+      @environment = Puppet::Node::Environment.new("foo")
+    end
+
     it "should parse puppet files with the puppet parser" do
       @parser.stubs(:scan_top_level)
       parser = stub 'parser'
-      Puppet::Parser::Parser.expects(:new).returns(parser)
-      parser.expects(:parse)
+      Puppet::Parser::Parser.stubs(:new).returns(parser)
+      parser.expects(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
       parser.expects(:file=).with("module/manifests/init.pp")
+      parser.expects(:environment).returns(@environment)
 
       @parser.scan
     end
@@ -29,6 +34,8 @@ describe RDoc::Parser do
     it "should scan the ast for Puppet files" do
       parser = stub_everything 'parser'
       Puppet::Parser::Parser.stubs(:new).returns(parser)
+      parser.expects(:environment).returns(@environment)
+      parser.expects(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
 
       @parser.expects(:scan_top_level)
 
@@ -38,6 +45,8 @@ describe RDoc::Parser do
     it "should return a PuppetTopLevel to RDoc" do
       parser = stub_everything 'parser'
       Puppet::Parser::Parser.stubs(:new).returns(parser)
+      parser.expects(:environment).returns(@environment)
+      parser.expects(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
 
       @parser.expects(:scan_top_level)
 
@@ -47,8 +56,8 @@ describe RDoc::Parser do
 
   describe "when scanning top level entities" do
     before :each do
-      @resource_type_collection = stub_everything 'resource_type_collection'
-      @parser.ast = @resource_type_collection
+      @resource_type_collection = resource_type_collection = stub_everything('resource_type_collection')
+      @parser.instance_eval { @known_resource_types = resource_type_collection }
       @parser.stubs(:split_module).returns("module")
 
       @topcontainer = stub_everything 'topcontainer'
@@ -141,8 +150,8 @@ describe RDoc::Parser do
       @definition = stub_everything 'definition', :file => "module/manifests/init.pp", :type => :definition, :name => "mydef"
       @node = stub_everything 'node', :file => "module/manifests/init.pp", :type => :node, :name => "mynode"
 
-      @resource_type_collection = Puppet::Resource::TypeCollection.new("env")
-      @parser.ast = @resource_type_collection
+      @resource_type_collection = resource_type_collection = Puppet::Resource::TypeCollection.new("env")
+      @parser.instance_eval { @known_resource_types = resource_type_collection }
 
       @container = stub_everything 'container'
     end