17 files changed, 159 insertions, 159 deletions

diff --git a/spec/integration/parser/functions/include.rb b/spec/integration/parser/functions/include.rb
index 64346bffb..f84d43276 100755
--- a/spec/integration/parser/functions/include.rb
+++ b/spec/integration/parser/functions/include.rb
@@ -14,7 +14,7 @@ describe "The include function" do
     end
 
     it "should add a containment relationship between the 'included' class and our class" do
-        @compiler.known_resource_types.add Puppet::Parser::ResourceType.new(:hostclass, "includedclass")
+        @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "includedclass")
 
         @scope.function_include("includedclass")
 
diff --git a/spec/integration/parser/functions/require.rb b/spec/integration/parser/functions/require.rb
index 5f95ec520..143729967 100755
--- a/spec/integration/parser/functions/require.rb
+++ b/spec/integration/parser/functions/require.rb
@@ -16,7 +16,7 @@ describe "The require function" do
     end
 
     it "should add a dependency between the 'required' class and our class" do
-        @compiler.known_resource_types.add Puppet::Parser::ResourceType.new(:hostclass, "requiredclass")
+        @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "requiredclass")
 
         @scope.function_require("requiredclass")
         @scope.resource["require"].should_not be_nil
diff --git a/spec/integration/parser/parser.rb b/spec/integration/parser/parser.rb
index 08cab5621..5a30f066e 100755
--- a/spec/integration/parser/parser.rb
+++ b/spec/integration/parser/parser.rb
@@ -4,7 +4,7 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Parser::Parser do
     before :each do
-        @resource_type_collection = Puppet::Parser::ResourceTypeCollection.new("env")
+        @resource_type_collection = Puppet::Resource::TypeCollection.new("env")
         @parser = Puppet::Parser::Parser.new "development"
     end
 
diff --git a/spec/integration/util/rdoc/parser.rb b/spec/integration/util/rdoc/parser.rb
index a52c11d87..01bcb644b 100755
--- a/spec/integration/util/rdoc/parser.rb
+++ b/spec/integration/util/rdoc/parser.rb
@@ -2,7 +2,7 @@
 
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
-require 'puppet/parser/resource_type_collection'
+require 'puppet/resource/type_collection'
 require 'puppet/util/rdoc/parser'
 require 'puppet/util/rdoc'
 require 'puppet/util/rdoc/code_objects'
@@ -41,7 +41,7 @@ describe RDoc::Parser do
     end
 
     it "should parse to RDoc data structure" do
-        @parser.expects(:document_class).with { |n,k,c| n == "::test" and k.is_a?(Puppet::Parser::ResourceType) }
+        @parser.expects(:document_class).with { |n,k,c| n == "::test" and k.is_a?(Puppet::Resource::Type) }
         @parser.scan
     end
 
diff --git a/spec/unit/application/main.rb b/spec/unit/application/main.rb
index ca185cb0a..74c40c14a 100755
--- a/spec/unit/application/main.rb
+++ b/spec/unit/application/main.rb
@@ -144,7 +144,7 @@ describe "Puppet" do
                 @main.stubs(:exit)
                 @main.options.stubs(:[]).with(:code).returns "some code"
                 @collection = stub_everything
-                Puppet::Parser::ResourceTypeCollection.stubs(:new).returns(@collection)
+                Puppet::Resource::TypeCollection.stubs(:new).returns(@collection)
             end
 
             it "should use a Puppet Resource Type Collection to parse the file" do
diff --git a/spec/unit/application/server.rb b/spec/unit/application/server.rb
index ba0fcfef2..b300e941e 100644
--- a/spec/unit/application/server.rb
+++ b/spec/unit/application/server.rb
@@ -262,7 +262,7 @@ describe "PuppetMaster" do
                 Puppet.stubs(:err)
                 @server_app.stubs(:exit)
                 @collection = stub_everything
-                Puppet::Parser::ResourceTypeCollection.stubs(:new).returns(@collection)
+                Puppet::Resource::TypeCollection.stubs(:new).returns(@collection)
             end
 
             it "should use a Puppet Resource Type Collection to parse the file" do
diff --git a/spec/unit/node/environment.rb b/spec/unit/node/environment.rb
index 26d9aabe1..81981973d 100755
--- a/spec/unit/node/environment.rb
+++ b/spec/unit/node/environment.rb
@@ -46,12 +46,12 @@ describe Puppet::Node::Environment do
     describe "when managing known resource types" do
         before do
             @env = Puppet::Node::Environment.new("dev")
-            @collection = Puppet::Parser::ResourceTypeCollection.new(@env)
+            @collection = Puppet::Resource::TypeCollection.new(@env)
             @collection.stubs(:perform_initial_import)
         end
 
         it "should create a resource type collection if none exists" do
-            Puppet::Parser::ResourceTypeCollection.expects(:new).with(@env).returns @collection
+            Puppet::Resource::TypeCollection.expects(:new).with(@env).returns @collection
             @env.known_resource_types.should equal(@collection)
         end
 
@@ -61,7 +61,7 @@ describe Puppet::Node::Environment do
         
         it "should perform the initial import when creating a new collection" do
             @collection.expects(:perform_initial_import)
-            Puppet::Parser::ResourceTypeCollection.expects(:new).returns @collection
+            Puppet::Resource::TypeCollection.expects(:new).returns @collection
 
             @env.known_resource_types
         end
@@ -69,7 +69,7 @@ describe Puppet::Node::Environment do
         it "should create and return a new collection rather than returning a stale collection" do
             @env.known_resource_types.expects(:stale?).returns true
 
-            Puppet::Parser::ResourceTypeCollection.expects(:new).returns @collection
+            Puppet::Resource::TypeCollection.expects(:new).returns @collection
 
             @env.known_resource_types.should equal(@collection)
         end
diff --git a/spec/unit/parser/compiler.rb b/spec/unit/parser/compiler.rb
index 4646f77a3..333046c77 100755
--- a/spec/unit/parser/compiler.rb
+++ b/spec/unit/parser/compiler.rb
@@ -33,7 +33,7 @@ end
 describe Puppet::Parser::Compiler do
     before :each do
         @node = Puppet::Node.new "testnode"
-        @known_resource_types = Puppet::Parser::ResourceTypeCollection.new "development"
+        @known_resource_types = Puppet::Resource::TypeCollection.new "development"
 
         @scope_resource = stub 'scope_resource', :builtin? => true, :finish => nil, :ref => 'Class[main]', :type => "class"
         @scope = stub 'scope', :resource => @scope_resource, :source => mock("source")
@@ -62,7 +62,7 @@ describe Puppet::Parser::Compiler do
     end
 
     it "should include the resource type collection helper" do
-        Puppet::Parser::Compiler.ancestors.should be_include(Puppet::Parser::ResourceTypeCollectionHelper)
+        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
@@ -185,7 +185,7 @@ describe Puppet::Parser::Compiler do
         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::Parser::ResourceType)
+            @known_resource_types.find_hostclass("", "").should be_instance_of(Puppet::Resource::Type)
         end
 
         it "should evaluate any node classes" do
diff --git a/spec/unit/parser/parser.rb b/spec/unit/parser/parser.rb
index cb96e0cb7..bb0fa0a7b 100755
--- a/spec/unit/parser/parser.rb
+++ b/spec/unit/parser/parser.rb
@@ -7,7 +7,7 @@ describe Puppet::Parser do
     ast = Puppet::Parser::AST
 
     before :each do
-        @known_resource_types = Puppet::Parser::ResourceTypeCollection.new("development")
+        @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
diff --git a/spec/unit/parser/resource.rb b/spec/unit/parser/resource.rb
index eb2cd490c..bb3001c8e 100755
--- a/spec/unit/parser/resource.rb
+++ b/spec/unit/parser/resource.rb
@@ -8,7 +8,7 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 describe Puppet::Parser::Resource do
     before do
         @node = Puppet::Node.new("yaynode")
-        @known_resource_types = Puppet::Parser::ResourceTypeCollection.new("env")
+        @known_resource_types = Puppet::Resource::TypeCollection.new("env")
         @compiler = Puppet::Parser::Compiler.new(@node)
         @compiler.environment.stubs(:known_resource_types).returns @known_resource_types
         @source = newclass ""
@@ -46,15 +46,15 @@ describe Puppet::Parser::Resource do
     end
 
     def newclass(name)
-        @known_resource_types.add Puppet::Parser::ResourceType.new(:hostclass, name)
+        @known_resource_types.add Puppet::Resource::Type.new(:hostclass, name)
     end
 
     def newdefine(name)
-        @known_resource_types.add Puppet::Parser::ResourceType.new(:definition, name)
+        @known_resource_types.add Puppet::Resource::Type.new(:definition, name)
     end
 
     def newnode(name)
-        @known_resource_types.add Puppet::Parser::ResourceType.new(:node, name)
+        @known_resource_types.add Puppet::Resource::Type.new(:node, name)
     end
 
     it "should use the file lookup module" do
diff --git a/spec/unit/parser/resource/reference.rb b/spec/unit/parser/resource/reference.rb
index 1034dbdda..a38604226 100755
--- a/spec/unit/parser/resource/reference.rb
+++ b/spec/unit/parser/resource/reference.rb
@@ -14,7 +14,7 @@ describe Puppet::Parser::Resource::Reference do
     end
 
     it "should use the resource type collection helper to find its known resource types" do
-        Puppet::Parser::Resource::Reference.ancestors.should include(Puppet::Parser::ResourceTypeCollectionHelper)
+        Puppet::Parser::Resource::Reference.ancestors.should include(Puppet::Resource::TypeCollectionHelper)
     end
 
     it "should use the file lookup module" do
@@ -70,21 +70,21 @@ end
 
 describe Puppet::Parser::Resource::Reference, " when modeling defined types" do
     def newclass(name)
-        @known_resource_types.add Puppet::Parser::ResourceType.new(:hostclass, name)
+        @known_resource_types.add Puppet::Resource::Type.new(:hostclass, name)
     end
 
     def newdefine(name)
-        @known_resource_types.add Puppet::Parser::ResourceType.new(:definition, name)
+        @known_resource_types.add Puppet::Resource::Type.new(:definition, name)
     end
 
     def newnode(name)
-        @known_resource_types.add Puppet::Parser::ResourceType.new(:node, name)
+        @known_resource_types.add Puppet::Resource::Type.new(:node, name)
     end
 
     before do
         @type = Puppet::Parser::Resource::Reference
 
-        @known_resource_types = Puppet::Parser::ResourceTypeCollection.new("myenv")
+        @known_resource_types = Puppet::Resource::TypeCollection.new("myenv")
         @definition = newdefine("mydefine")
         @class = newclass("myclass")
         @nodedef = newnode("mynode")
diff --git a/spec/unit/parser/scope.rb b/spec/unit/parser/scope.rb
index b48bd1246..799d05766 100755
--- a/spec/unit/parser/scope.rb
+++ b/spec/unit/parser/scope.rb
@@ -54,7 +54,7 @@ describe Puppet::Parser::Scope do
     end
 
     it "should use the resource type collection helper to find its known resource types" do
-        Puppet::Parser::Scope.ancestors.should include(Puppet::Parser::ResourceTypeCollectionHelper)
+        Puppet::Parser::Scope.ancestors.should include(Puppet::Resource::TypeCollectionHelper)
     end
 
     describe "when looking up a variable" do
@@ -99,7 +99,7 @@ describe Puppet::Parser::Scope do
             end
 
             def newclass(name)
-                @known_resource_types.add Puppet::Parser::ResourceType.new(:hostclass, name)
+                @known_resource_types.add Puppet::Resource::Type.new(:hostclass, name)
             end
 
             def create_class_scope(name)
diff --git a/spec/unit/parser/templatewrapper.rb b/spec/unit/parser/templatewrapper.rb
index b1f9d2ad9..1b4121643 100755
--- a/spec/unit/parser/templatewrapper.rb
+++ b/spec/unit/parser/templatewrapper.rb
@@ -4,7 +4,7 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Parser::TemplateWrapper do
     before(:each) do
-        @known_resource_types = Puppet::Parser::ResourceTypeCollection.new("env")
+        @known_resource_types = Puppet::Resource::TypeCollection.new("env")
         @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
         @compiler.environment.stubs(:known_resource_types).returns @known_resource_types
         @scope = Puppet::Parser::Scope.new :compiler => @compiler
diff --git a/spec/unit/parser/resource_type.rb b/spec/unit/resource/type.rb
index 816f86176..14503b7cc 100755
--- a/spec/unit/parser/resource_type.rb
+++ b/spec/unit/resource/type.rb
@@ -2,16 +2,16 @@
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-require 'puppet/parser/resource_type'
+require 'puppet/resource/type'
 
-describe Puppet::Parser::ResourceType do
+describe Puppet::Resource::Type do
     it "should have a 'name' attribute" do
-        Puppet::Parser::ResourceType.new(:hostclass, "foo").name.should == "foo"
+        Puppet::Resource::Type.new(:hostclass, "foo").name.should == "foo"
     end
 
     [:code, :doc, :line, :file, :code_collection].each do |attr|
         it "should have a '#{attr}' attribute" do
-            type = Puppet::Parser::ResourceType.new(:hostclass, "foo")
+            type = Puppet::Resource::Type.new(:hostclass, "foo")
             type.send(attr.to_s + "=", "yay")
             type.send(attr).should == "yay"
         end
@@ -19,156 +19,156 @@ describe Puppet::Parser::ResourceType do
 
     describe "when a node"  do
         it "should allow a regex as its name" do
-            lambda { Puppet::Parser::ResourceType.new(:node, /foo/) }.should_not raise_error
+            lambda { Puppet::Resource::Type.new(:node, /foo/) }.should_not raise_error
         end
 
         it "should allow a AST::HostName instance as its name" do
             regex = Puppet::Parser::AST::Regex.new(:value => /foo/)
             name = Puppet::Parser::AST::HostName.new(:value => regex)
-            lambda { Puppet::Parser::ResourceType.new(:node, name) }.should_not raise_error
+            lambda { Puppet::Resource::Type.new(:node, name) }.should_not raise_error
         end
 
         it "should match against the regexp in the AST::HostName when a HostName instance is provided" do
             regex = Puppet::Parser::AST::Regex.new(:value => /\w/)
             name = Puppet::Parser::AST::HostName.new(:value => regex)
-            node = Puppet::Parser::ResourceType.new(:node, name)
+            node = Puppet::Resource::Type.new(:node, name)
 
             node.match("foo").should be_true
         end
 
         it "should return the value of the hostname if provided a string-form AST::HostName instance as the name" do
             name = Puppet::Parser::AST::HostName.new(:value => "foo")
-            node = Puppet::Parser::ResourceType.new(:node, name)
+            node = Puppet::Resource::Type.new(:node, name)
 
             node.name.should == "foo"
         end
 
         describe "and the name is a regex" do
             it "should have a method that indicates that this is the case" do
-                Puppet::Parser::ResourceType.new(:node, /w/).should be_name_is_regex
+                Puppet::Resource::Type.new(:node, /w/).should be_name_is_regex
             end
 
             it "should set its namespace to ''" do
-                Puppet::Parser::ResourceType.new(:node, /w/).namespace.should == ""
+                Puppet::Resource::Type.new(:node, /w/).namespace.should == ""
             end
 
             it "should return the regex converted to a string when asked for its name" do
-                Puppet::Parser::ResourceType.new(:node, /ww/).name.should == "ww"
+                Puppet::Resource::Type.new(:node, /ww/).name.should == "ww"
             end
 
             it "should downcase the regex when returning the name as a string" do
-                Puppet::Parser::ResourceType.new(:node, /W/).name.should == "w"
+                Puppet::Resource::Type.new(:node, /W/).name.should == "w"
             end
 
             it "should remove non-alpha characters when returning the name as a string" do
-                Puppet::Parser::ResourceType.new(:node, /w*w/).name.should_not include("*")
+                Puppet::Resource::Type.new(:node, /w*w/).name.should_not include("*")
             end
 
             it "should remove leading dots when returning the name as a string" do
-                Puppet::Parser::ResourceType.new(:node, /.ww/).name.should_not =~ /^\./
+                Puppet::Resource::Type.new(:node, /.ww/).name.should_not =~ /^\./
             end
 
             it "should have a method for matching its regex name against a provided name" do
-                Puppet::Parser::ResourceType.new(:node, /.ww/).should respond_to(:match)
+                Puppet::Resource::Type.new(:node, /.ww/).should respond_to(:match)
             end
 
             it "should return true when its regex matches the provided name" do
-                Puppet::Parser::ResourceType.new(:node, /\w/).match("foo").should be_true
+                Puppet::Resource::Type.new(:node, /\w/).match("foo").should be_true
             end
 
             it "should return false when its regex does not match the provided name" do
-                (!!Puppet::Parser::ResourceType.new(:node, /\d/).match("foo")).should be_false
+                (!!Puppet::Resource::Type.new(:node, /\d/).match("foo")).should be_false
             end
 
             it "should return true when its name, as a string, is matched against an equal string" do
-                Puppet::Parser::ResourceType.new(:node, "foo").match("foo").should be_true
+                Puppet::Resource::Type.new(:node, "foo").match("foo").should be_true
             end
 
             it "should return false when its name is matched against an unequal string" do
-                Puppet::Parser::ResourceType.new(:node, "foo").match("bar").should be_false
+                Puppet::Resource::Type.new(:node, "foo").match("bar").should be_false
             end
 
             it "should match names insensitive to case" do
-                Puppet::Parser::ResourceType.new(:node, "fOo").match("foO").should be_true
+                Puppet::Resource::Type.new(:node, "fOo").match("foO").should be_true
             end
         end
 
         it "should return the name converted to a string when the name is not a regex" do
             pending "Need to define ResourceTypeCollection behaviour first"
             name = Puppet::Parser::AST::HostName.new(:value => "foo")
-            Puppet::Parser::ResourceType.new(:node, name).name.should == "foo"
+            Puppet::Resource::Type.new(:node, name).name.should == "foo"
         end
 
         it "should return the name converted to a string when the name is a regex" do
             pending "Need to define ResourceTypeCollection behaviour first"
             name = Puppet::Parser::AST::HostName.new(:value => /regex/)
-            Puppet::Parser::ResourceType.new(:node, name).name.should == /regex/.to_s
+            Puppet::Resource::Type.new(:node, name).name.should == /regex/.to_s
         end
 
         it "should mark any created scopes as a node scope" do
             pending "Need to define ResourceTypeCollection behaviour first"
             name = Puppet::Parser::AST::HostName.new(:value => /regex/)
-            Puppet::Parser::ResourceType.new(:node, name).name.should == /regex/.to_s
+            Puppet::Resource::Type.new(:node, name).name.should == /regex/.to_s
         end
     end
 
     describe "when initializing" do
         it "should require a resource super type" do
-            Puppet::Parser::ResourceType.new(:hostclass, "foo").type.should == :hostclass
+            Puppet::Resource::Type.new(:hostclass, "foo").type.should == :hostclass
         end
 
         it "should fail if provided an invalid resource super type" do
-            lambda { Puppet::Parser::ResourceType.new(:nope, "foo") }.should raise_error(ArgumentError)
+            lambda { Puppet::Resource::Type.new(:nope, "foo") }.should raise_error(ArgumentError)
         end
 
         it "should set its name to the downcased, stringified provided name" do
-            Puppet::Parser::ResourceType.new(:hostclass, "Foo::Bar".intern).name.should == "foo::bar"
+            Puppet::Resource::Type.new(:hostclass, "Foo::Bar".intern).name.should == "foo::bar"
         end
 
         it "should set its namespace to the downcased, stringified qualified portion of the name" do
-            Puppet::Parser::ResourceType.new(:hostclass, "Foo::Bar::Baz".intern).namespace.should == "foo::bar"
+            Puppet::Resource::Type.new(:hostclass, "Foo::Bar::Baz".intern).namespace.should == "foo::bar"
         end
 
         %w{code line file doc}.each do |arg|
             it "should set #{arg} if provided" do
-                type = Puppet::Parser::ResourceType.new(:hostclass, "foo", arg.to_sym => "something")
+                type = Puppet::Resource::Type.new(:hostclass, "foo", arg.to_sym => "something")
                 type.send(arg).should == "something"
             end
         end
 
         it "should set any provided arguments with the keys as symbols" do
-            type = Puppet::Parser::ResourceType.new(:hostclass, "foo", :arguments => {:foo => "bar", :baz => "biz"})
+            type = Puppet::Resource::Type.new(:hostclass, "foo", :arguments => {:foo => "bar", :baz => "biz"})
             type.should be_validattr("foo")
             type.should be_validattr("baz")
         end
 
         it "should set any provided arguments with they keys as strings" do
-            type = Puppet::Parser::ResourceType.new(:hostclass, "foo", :arguments => {"foo" => "bar", "baz" => "biz"})
+            type = Puppet::Resource::Type.new(:hostclass, "foo", :arguments => {"foo" => "bar", "baz" => "biz"})
             type.should be_validattr(:foo)
             type.should be_validattr(:baz)
         end
 
         it "should function if provided no arguments" do
-            type = Puppet::Parser::ResourceType.new(:hostclass, "foo")
+            type = Puppet::Resource::Type.new(:hostclass, "foo")
             type.should_not be_validattr(:foo)
         end
     end
 
     describe "when testing the validity of an attribute" do
         it "should return true if the parameter was typed at initialization" do
-            Puppet::Parser::ResourceType.new(:hostclass, "foo", :arguments => {"foo" => "bar"}).should be_validattr("foo")
+            Puppet::Resource::Type.new(:hostclass, "foo", :arguments => {"foo" => "bar"}).should be_validattr("foo")
         end
 
         it "should return true if it is a metaparam" do
-            Puppet::Parser::ResourceType.new(:hostclass, "foo").should be_validattr("require")
+            Puppet::Resource::Type.new(:hostclass, "foo").should be_validattr("require")
         end
 
         it "should return true if the parameter is named 'name'" do
-            Puppet::Parser::ResourceType.new(:hostclass, "foo").should be_validattr("name")
+            Puppet::Resource::Type.new(:hostclass, "foo").should be_validattr("name")
         end
 
         it "should return false if it is not a metaparam and was not provided at initialization" do
-            Puppet::Parser::ResourceType.new(:hostclass, "foo").should_not be_validattr("yayness")
+            Puppet::Resource::Type.new(:hostclass, "foo").should_not be_validattr("yayness")
         end
     end
 
@@ -176,7 +176,7 @@ describe Puppet::Parser::ResourceType do
         before do
             @scope = stub 'scope', :newscope => nil
             @resource = stub 'resource'
-            @type = Puppet::Parser::ResourceType.new(:hostclass, "foo")
+            @type = Puppet::Resource::Type.new(:hostclass, "foo")
         end
 
         it "should return a new scope created with the provided scope as the parent" do
@@ -205,7 +205,7 @@ describe Puppet::Parser::ResourceType do
         before do
             @scope = stub 'scope', :newscope => nil, :setvar => nil
             @resource = stub 'resource', :title => "yay", :name => "yea", :ref => "Foo[bar]"
-            @type = Puppet::Parser::ResourceType.new(:hostclass, "foo")
+            @type = Puppet::Resource::Type.new(:hostclass, "foo")
         end
 
         it "should set each of the resource's parameters as variables in the scope" do
@@ -275,16 +275,16 @@ describe Puppet::Parser::ResourceType do
 
     describe "when describing and managing parent classes" do
         before do
-            @code = Puppet::Parser::ResourceTypeCollection.new("env")
-            @parent = Puppet::Parser::ResourceType.new(:hostclass, "bar")
+            @code = Puppet::Resource::TypeCollection.new("env")
+            @parent = Puppet::Resource::Type.new(:hostclass, "bar")
             @code.add @parent
 
-            @child = Puppet::Parser::ResourceType.new(:hostclass, "foo", :parent => "bar")
+            @child = Puppet::Resource::Type.new(:hostclass, "foo", :parent => "bar")
             @code.add @child
         end
 
         it "should be able to define a parent" do
-            Puppet::Parser::ResourceType.new(:hostclass, "foo", :parent => "bar")
+            Puppet::Resource::Type.new(:hostclass, "foo", :parent => "bar")
         end
 
         it "should use the code collection to find the parent resource type" do
@@ -292,9 +292,9 @@ describe Puppet::Parser::ResourceType do
         end
 
         it "should be able to find parent nodes" do
-            parent = Puppet::Parser::ResourceType.new(:node, "bar")
+            parent = Puppet::Resource::Type.new(:node, "bar")
             @code.add parent
-            child = Puppet::Parser::ResourceType.new(:node, "foo", :parent => "bar")
+            child = Puppet::Resource::Type.new(:node, "foo", :parent => "bar")
             @code.add child
 
             child.parent_type.should equal(parent)
@@ -311,14 +311,14 @@ describe Puppet::Parser::ResourceType do
         end
 
         it "should be considered the child of a parent's parent" do
-            @grandchild = Puppet::Parser::ResourceType.new(:hostclass, "baz", :parent => "foo")
+            @grandchild = Puppet::Resource::Type.new(:hostclass, "baz", :parent => "foo")
             @code.add @grandchild
 
             @grandchild.should be_child_of(@parent)
         end
 
         it "should correctly state when it is not another type's child" do
-            @notchild = Puppet::Parser::ResourceType.new(:hostclass, "baz")
+            @notchild = Puppet::Resource::Type.new(:hostclass, "baz")
             @code.add @notchild
 
             @notchild.should_not be_child_of(@parent)
@@ -330,7 +330,7 @@ describe Puppet::Parser::ResourceType do
             @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
             @scope = Puppet::Parser::Scope.new :compiler => @compiler
             @resource = stub 'resource', :title => "yay", :name => "yea", :ref => "Foo[bar]", :scope => @scope
-            @type = Puppet::Parser::ResourceType.new(:hostclass, "foo")
+            @type = Puppet::Resource::Type.new(:hostclass, "foo")
             @type.stubs(:set_resource_parameters)
         end
 
@@ -372,10 +372,10 @@ describe Puppet::Parser::ResourceType do
             @compiler = Puppet::Parser::Compiler.new(@node)
             @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
 
-            @top = Puppet::Parser::ResourceType.new :hostclass, "top"
-            @middle = Puppet::Parser::ResourceType.new :hostclass, "middle", :parent => "top"
+            @top = Puppet::Resource::Type.new :hostclass, "top"
+            @middle = Puppet::Resource::Type.new :hostclass, "middle", :parent => "top"
 
-            @code = Puppet::Parser::ResourceTypeCollection.new("env")
+            @code = Puppet::Resource::TypeCollection.new("env")
             @code.add @top
             @code.add @middle
         end
@@ -385,15 +385,15 @@ describe Puppet::Parser::ResourceType do
         end
 
         it "should set its resource type to 'class' when it is a hostclass" do
-            Puppet::Parser::ResourceType.new(:hostclass, "top").mk_plain_resource(@scope).type.should == "Class"
+            Puppet::Resource::Type.new(:hostclass, "top").mk_plain_resource(@scope).type.should == "Class"
         end
 
         it "should set its resource type to 'node' when it is a node" do
-            Puppet::Parser::ResourceType.new(:node, "top").mk_plain_resource(@scope).type.should == "Node"
+            Puppet::Resource::Type.new(:node, "top").mk_plain_resource(@scope).type.should == "Node"
         end
 
         it "should fail when it is a definition" do
-            lambda { Puppet::Parser::ResourceType.new(:definition, "top").mk_plain_resource(@scope) }.should raise_error(ArgumentError)
+            lambda { Puppet::Resource::Type.new(:definition, "top").mk_plain_resource(@scope) }.should raise_error(ArgumentError)
         end
 
         it "should add the created resource to the scope's catalog" do
@@ -409,7 +409,7 @@ describe Puppet::Parser::ResourceType do
         end
 
         it "should fail to evaluate if a parent class is defined but cannot be found" do
-            othertop = Puppet::Parser::ResourceType.new :hostclass, "something", :parent => "yay"
+            othertop = Puppet::Resource::Type.new :hostclass, "something", :parent => "yay"
             @code.add othertop
             lambda { othertop.mk_plain_resource(@scope) }.should raise_error(Puppet::ParseError)
         end
@@ -456,53 +456,53 @@ describe Puppet::Parser::ResourceType do
         end
 
         it "should fail unless it is a class" do
-            lambda { Puppet::Parser::ResourceType.new(:node, "bar").merge("foo") }.should raise_error(ArgumentError)
+            lambda { Puppet::Resource::Type.new(:node, "bar").merge("foo") }.should raise_error(ArgumentError)
         end
 
         it "should fail unless the source instance is a class" do
-            dest = Puppet::Parser::ResourceType.new(:hostclass, "bar")
-            source = Puppet::Parser::ResourceType.new(:node, "foo")
+            dest = Puppet::Resource::Type.new(:hostclass, "bar")
+            source = Puppet::Resource::Type.new(:node, "foo")
             lambda { dest.merge(source) }.should raise_error(ArgumentError)
         end
 
         it "should fail if both classes have different parent classes" do
-            code = Puppet::Parser::ResourceTypeCollection.new("env")
+            code = Puppet::Resource::TypeCollection.new("env")
             {"a" => "b", "c" => "d"}.each do |parent, child|
-                code.add Puppet::Parser::ResourceType.new(:hostclass, parent)
-                code.add Puppet::Parser::ResourceType.new(:hostclass, child, :parent => parent)
+                code.add Puppet::Resource::Type.new(:hostclass, parent)
+                code.add Puppet::Resource::Type.new(:hostclass, child, :parent => parent)
             end
             lambda { code.hostclass("b").merge(code.hostclass("d")) }.should raise_error(ArgumentError)
         end
 
         it "should copy the other class's parent if it has not parent" do
-            dest = Puppet::Parser::ResourceType.new(:hostclass, "bar")
+            dest = Puppet::Resource::Type.new(:hostclass, "bar")
 
-            parent = Puppet::Parser::ResourceType.new(:hostclass, "parent")
-            source = Puppet::Parser::ResourceType.new(:hostclass, "foo", :parent => "parent")
+            parent = Puppet::Resource::Type.new(:hostclass, "parent")
+            source = Puppet::Resource::Type.new(:hostclass, "foo", :parent => "parent")
             dest.merge(source)
 
             dest.parent.should == "parent"
         end
 
         it "should copy the other class's documentation as its docs if it has no docs" do
-            dest = Puppet::Parser::ResourceType.new(:hostclass, "bar")
-            source = Puppet::Parser::ResourceType.new(:hostclass, "foo", :doc => "yayness")
+            dest = Puppet::Resource::Type.new(:hostclass, "bar")
+            source = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "yayness")
             dest.merge(source)
 
             dest.doc.should == "yayness"
         end
 
         it "should append the other class's docs to its docs if it has any" do
-            dest = Puppet::Parser::ResourceType.new(:hostclass, "bar", :doc => "fooness")
-            source = Puppet::Parser::ResourceType.new(:hostclass, "foo", :doc => "yayness")
+            dest = Puppet::Resource::Type.new(:hostclass, "bar", :doc => "fooness")
+            source = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "yayness")
             dest.merge(source)
 
             dest.doc.should == "foonessyayness"
         end
 
         it "should turn its code into an ASTArray if necessary" do
-            dest = Puppet::Parser::ResourceType.new(:hostclass, "bar", :code => code("foo"))
-            source = Puppet::Parser::ResourceType.new(:hostclass, "foo", :code => code("bar"))
+            dest = Puppet::Resource::Type.new(:hostclass, "bar", :code => code("foo"))
+            source = Puppet::Resource::Type.new(:hostclass, "foo", :code => code("bar"))
 
             dest.merge(source)
 
@@ -510,8 +510,8 @@ describe Puppet::Parser::ResourceType do
         end
 
         it "should set the other class's code as its code if it has none" do
-            dest = Puppet::Parser::ResourceType.new(:hostclass, "bar")
-            source = Puppet::Parser::ResourceType.new(:hostclass, "foo", :code => code("bar"))
+            dest = Puppet::Resource::Type.new(:hostclass, "bar")
+            source = Puppet::Resource::Type.new(:hostclass, "foo", :code => code("bar"))
 
             dest.merge(source)
 
@@ -520,10 +520,10 @@ describe Puppet::Parser::ResourceType do
 
         it "should append the other class's code to its code if it has any" do
             dcode = Puppet::Parser::AST::ASTArray.new :children => [code("dest")]
-            dest = Puppet::Parser::ResourceType.new(:hostclass, "bar", :code => dcode)
+            dest = Puppet::Resource::Type.new(:hostclass, "bar", :code => dcode)
 
             scode = Puppet::Parser::AST::ASTArray.new :children => [code("source")]
-            source = Puppet::Parser::ResourceType.new(:hostclass, "foo", :code => scode)
+            source = Puppet::Resource::Type.new(:hostclass, "foo", :code => scode)
 
             dest.merge(source)
 
diff --git a/spec/unit/parser/resource_type_collection.rb b/spec/unit/resource/type_collection.rb
index b2f1588c9..2fc364d6b 100644
--- a/spec/unit/parser/resource_type_collection.rb
+++ b/spec/unit/resource/type_collection.rb
@@ -2,40 +2,40 @@
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-require 'puppet/parser/resource_type_collection'
-require 'puppet/parser/resource_type'
+require 'puppet/resource/type_collection'
+require 'puppet/resource/type'
 
-describe Puppet::Parser::ResourceTypeCollection do
+describe Puppet::Resource::TypeCollection do
     before do
-        @instance = Puppet::Parser::ResourceType.new(:hostclass, "foo")
-        @code = Puppet::Parser::ResourceTypeCollection.new("env")
+        @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::Parser::ResourceTypeCollection.new(env).environment.should equal(env)
+        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::Parser::ResourceTypeCollection.new("testing").environment.should equal(env)
+        Puppet::Resource::TypeCollection.new("testing").environment.should equal(env)
     end
 
     it "should be able to add a resource type" do
-        Puppet::Parser::ResourceTypeCollection.new("env").should respond_to(:add)
+        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::Parser::ResourceTypeCollection.new("env")
+        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::Parser::ResourceTypeCollection.new("env")
+        loader = Puppet::Resource::TypeCollection.new("env")
 
-        node = Puppet::Parser::ResourceType.new(:node, "foo")
+        node = Puppet::Resource::Type.new(:node, "foo")
 
         @code.add(node)
         @code.node("foo").should equal(node)
@@ -44,21 +44,21 @@ describe Puppet::Parser::ResourceTypeCollection do
     end
 
     it "should store node resource types as nodes" do
-        node = Puppet::Parser::ResourceType.new(:node, "foo")
+        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::Parser::ResourceType.new(:hostclass, "foo")
+        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::Parser::ResourceType.new(:definition, "foo")
+        define = Puppet::Resource::Type.new(:definition, "foo")
 
         @code.add(define)
         @code.definition("foo").should equal(define)
@@ -66,49 +66,49 @@ describe Puppet::Parser::ResourceTypeCollection do
 
     %w{hostclass node definition}.each do |data|
         it "should have a method for adding a #{data}" do
-            Puppet::Parser::ResourceTypeCollection.new("env").should respond_to("add_" + data)
+            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::Parser::ResourceTypeCollection.new("env")
+            loader = Puppet::Resource::TypeCollection.new("env")
             loader.send("add_#{data}", @instance)
             loader.send(data, @instance.name).should equal(@instance)
         end
 
         it "should fail to add a #{data} when one already exists" do
-            loader = Puppet::Parser::ResourceTypeCollection.new("env")
+            loader = Puppet::Resource::TypeCollection.new("env")
             loader.add @instance
             lambda { loader.add(@instance) }.should raise_error(Puppet::ParseError)
         end
 
         it "should return the added #{data}" do
-            loader = Puppet::Parser::ResourceTypeCollection.new("env")
+            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::Parser::ResourceTypeCollection.new("env")
-            instance = Puppet::Parser::ResourceType.new(data, "bar")
+            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::Parser::ResourceTypeCollection.new("env")
-            instance = Puppet::Parser::ResourceType.new(data, "Bar")
+            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::Parser::ResourceTypeCollection.new("env").send(data, "foo").should be_nil
+            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::Parser::ResourceTypeCollection.new("env")
-            instance = Puppet::Parser::ResourceType.new(data, "foo")
+            loader = Puppet::Resource::TypeCollection.new("env")
+            instance = Puppet::Resource::Type.new(data, "foo")
             loader.add instance
             loader.send(plurals[data]).should == { "foo" => instance }
         end
@@ -116,111 +116,111 @@ describe Puppet::Parser::ResourceTypeCollection do
 
     describe "when finding a qualified instance" do
         it "should return any found instance if the instance name is fully qualified" do
-            loader = Puppet::Parser::ResourceTypeCollection.new("env")
-            instance = Puppet::Parser::ResourceType.new(:hostclass, "foo::bar")
+            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)
         end
 
         it "should return nil if the instance name is fully qualified and no such instance exists" do
-            loader = Puppet::Parser::ResourceTypeCollection.new("env")
+            loader = Puppet::Resource::TypeCollection.new("env")
             loader.find("namespace", "::foo::bar", :hostclass).should be_nil
         end
 
         it "should return the partially qualified object if it exists in the provided namespace" do
-            loader = Puppet::Parser::ResourceTypeCollection.new("env")
-            instance = Puppet::Parser::ResourceType.new(:hostclass, "foo::bar::baz")
+            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)
         end
 
         it "should return the unqualified object if it exists in the provided namespace" do
-            loader = Puppet::Parser::ResourceTypeCollection.new("env")
-            instance = Puppet::Parser::ResourceType.new(:hostclass, "foo::bar")
+            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)
         end
 
         it "should return the unqualified object if it exists in the parent namespace" do
-            loader = Puppet::Parser::ResourceTypeCollection.new("env")
-            instance = Puppet::Parser::ResourceType.new(:hostclass, "foo::bar")
+            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)
         end
 
         it "should should return the partially qualified object if it exists in the parent namespace" do
-            loader = Puppet::Parser::ResourceTypeCollection.new("env")
-            instance = Puppet::Parser::ResourceType.new(:hostclass, "foo::bar::baz")
+            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)
         end
 
         it "should return the qualified object if it exists in the root namespace" do
-            loader = Puppet::Parser::ResourceTypeCollection.new("env")
-            instance = Puppet::Parser::ResourceType.new(:hostclass, "foo::bar::baz")
+            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)
         end
 
         it "should return nil if the object cannot be found" do
-            loader = Puppet::Parser::ResourceTypeCollection.new("env")
-            instance = Puppet::Parser::ResourceType.new(:hostclass, "foo::bar::baz")
+            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
         end
     end
 
     it "should use the generic 'find' method with an empty namespace to find nodes" do
-        loader = Puppet::Parser::ResourceTypeCollection.new("env")
+        loader = Puppet::Resource::TypeCollection.new("env")
         loader.expects(:find).with("", "bar", :node)
         loader.find_node("bar")
     end
 
     it "should use the generic 'find' method to find hostclasses" do
-        loader = Puppet::Parser::ResourceTypeCollection.new("env")
+        loader = Puppet::Resource::TypeCollection.new("env")
         loader.expects(:find).with("foo", "bar", :hostclass)
         loader.find_hostclass("foo", "bar")
     end
 
     it "should use the generic 'find' method to find definitions" do
-        loader = Puppet::Parser::ResourceTypeCollection.new("env")
+        loader = Puppet::Resource::TypeCollection.new("env")
         loader.expects(:find).with("foo", "bar", :definition)
         loader.find_definition("foo", "bar")
     end
 
     it "should indicate whether any nodes are defined" do
-        loader = Puppet::Parser::ResourceTypeCollection.new("env")
-        loader.add_node(Puppet::Parser::ResourceType.new(:node, "foo"))
+        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::Parser::ResourceTypeCollection.new("env").should_not be_nodes
+        Puppet::Resource::TypeCollection.new("env").should_not be_nodes
     end
 
     describe "when finding nodes" do
         before :each do
-            @loader = Puppet::Parser::ResourceTypeCollection.new("env")
+            @loader = Puppet::Resource::TypeCollection.new("env")
         end
 
         it "should return any node whose name exactly matches the provided node name" do
-            node = Puppet::Parser::ResourceType.new(:node, "foo")
+            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::Parser::ResourceType.new(:node, /\w/)
-            node2 = Puppet::Parser::ResourceType.new(:node, /\d/)
+            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::Parser::ResourceType.new(:node, /\w/)
-            node2 = Puppet::Parser::ResourceType.new(:node, "foo")
+            node1 = Puppet::Resource::Type.new(:node, /\w/)
+            node2 = Puppet::Resource::Type.new(:node, "foo")
             @loader << node1 << node2
 
             @loader.node("foo").should equal(node2)
@@ -229,7 +229,7 @@ describe Puppet::Parser::ResourceTypeCollection do
 
     describe "when managing files" do
         before do
-            @loader = Puppet::Parser::ResourceTypeCollection.new("env")
+            @loader = Puppet::Resource::TypeCollection.new("env")
             Puppet::Util::LoadedFile.stubs(:new).returns stub("watched_file")
         end
 
@@ -272,7 +272,7 @@ describe Puppet::Parser::ResourceTypeCollection do
         before do
             @parser = stub 'parser', :file= => nil, :string => nil, :parse => nil
             Puppet::Parser::Parser.stubs(:new).returns @parser
-            @code = Puppet::Parser::ResourceTypeCollection.new("env")
+            @code = Puppet::Resource::TypeCollection.new("env")
         end
 
         it "should create a new parser instance" do
@@ -312,7 +312,7 @@ describe Puppet::Parser::ResourceTypeCollection do
 
     describe "when determining the configuration version" do
         before do
-            @code = Puppet::Parser::ResourceTypeCollection.new("env")
+            @code = Puppet::Resource::TypeCollection.new("env")
         end
 
         it "should default to the current time" do
diff --git a/spec/unit/parser/resource_type_collection_helper.rb b/spec/unit/resource/type_collection_helper.rb
index c93c9f20e..e390ff952 100644
--- a/spec/unit/parser/resource_type_collection_helper.rb
+++ b/spec/unit/resource/type_collection_helper.rb
@@ -2,13 +2,13 @@
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-require 'puppet/parser/resource_type_collection_helper'
+require 'puppet/resource/type_collection_helper'
 
 class RTCHelperTester
-    include Puppet::Parser::ResourceTypeCollectionHelper
+    include Puppet::Resource::TypeCollectionHelper
 end
 
-describe Puppet::Parser::ResourceTypeCollectionHelper do
+describe Puppet::Resource::TypeCollectionHelper do
     before do
         @helper = RTCHelperTester.new
     end
diff --git a/spec/unit/util/rdoc/parser.rb b/spec/unit/util/rdoc/parser.rb
index c62b01d43..7113b9539 100755
--- a/spec/unit/util/rdoc/parser.rb
+++ b/spec/unit/util/rdoc/parser.rb
@@ -2,7 +2,7 @@
 
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
-require 'puppet/parser/resource_type_collection'
+require 'puppet/resource/type_collection'
 require 'puppet/util/rdoc/parser'
 require 'puppet/util/rdoc/code_objects'
 require 'rdoc/options'
@@ -141,7 +141,7 @@ 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::Parser::ResourceTypeCollection.new("env")
+            @resource_type_collection = Puppet::Resource::TypeCollection.new("env")
             @parser.ast = @resource_type_collection
 
             @container = stub_everything 'container'