Removing Resource::Reference classes

This commit is hopefully less messy than it
first appears, but it's certainly cross-cutting.

The reason for all of this is that we previously only
looked up builtin resource types from outside the parser,
but now that the defined resource types are available globally
via environments, we can push that lookup code to Resource.

Once we do that, however, we have to have environment and
namespace information in every resource.

Here I remove the Resource::Reference classes (except
the AST class), and use Resource instances instead. I
did this because the shared code between the two classes
got incredibly complicated, such that they should have had
a hierarchical relationship disallowed by their constants.
This complexity convinced me just to get rid of References
entirely.

I also make Puppet::Parser::Resource a subclass
of Puppet::Resource.

There are still broken tests in test/, but this was a big
enough commit I wanted to get it in.

Signed-off-by: Luke Kanies <luke@reductivelabs.com>

56 files changed, 842 insertions, 1696 deletions

diff --git a/lib/puppet.rb b/lib/puppet.rb
index 2e531ad75..09ae531aa 100644
--- a/lib/puppet.rb
+++ b/lib/puppet.rb
@@ -153,7 +153,6 @@ end
 require 'puppet/type'
 require 'puppet/parser'
 require 'puppet/resource'
-require 'puppet/resource/reference'
 require 'puppet/network'
 require 'puppet/ssl'
 require 'puppet/module'
diff --git a/lib/puppet/parser/ast/resource.rb b/lib/puppet/parser/ast/resource.rb
index d222893b3..5da40b32f 100644
--- a/lib/puppet/parser/ast/resource.rb
+++ b/lib/puppet/parser/ast/resource.rb
@@ -14,7 +14,7 @@ class Resource < AST::ResourceReference
     # in the current scope.
     def evaluate(scope)
         # Evaluate all of the specified params.
-        paramobjects = @params.collect { |param|
+        paramobjects = params.collect { |param|
             param.safeevaluate(scope)
         }
 
@@ -25,8 +25,6 @@ class Resource < AST::ResourceReference
             resource_titles = [resource_titles]
         end
 
-        resource_type = qualified_type(scope)
-
         # We want virtual to be true if exported is true.  We can't
         # just set :virtual => self.virtual in the initialization,
         # because sometimes the :virtual attribute is set *after*
@@ -39,9 +37,7 @@ class Resource < AST::ResourceReference
         # many times.
         resource_titles.flatten.collect { |resource_title|
             exceptwrap :type => Puppet::ParseError do
-                resource = Puppet::Parser::Resource.new(
-                    :type => resource_type,
-                    :title => resource_title,
+                resource = Puppet::Parser::Resource.new(type, resource_title,
                     :params => paramobjects,
                     :file => self.file,
                     :line => self.line,
diff --git a/lib/puppet/parser/ast/resource_defaults.rb b/lib/puppet/parser/ast/resource_defaults.rb
index 3fde7ade2..f0746ecf1 100644
--- a/lib/puppet/parser/ast/resource_defaults.rb
+++ b/lib/puppet/parser/ast/resource_defaults.rb
@@ -12,7 +12,7 @@ class Puppet::Parser::AST
         # object type.
         def evaluate(scope)
             # Use a resource reference to canonize the type
-            ref = Puppet::Resource::Reference.new(@type, "whatever")
+            ref = Puppet::Resource.new(@type, "whatever")
             type = ref.type
             params = @params.safeevaluate(scope)
 
diff --git a/lib/puppet/parser/ast/resource_override.rb b/lib/puppet/parser/ast/resource_override.rb
index 5eac50982..2d4f7a871 100644
--- a/lib/puppet/parser/ast/resource_override.rb
+++ b/lib/puppet/parser/ast/resource_override.rb
@@ -36,9 +36,7 @@ class Puppet::Parser::AST
             resource = [resource] unless resource.is_a?(Array)
 
             resource = resource.collect do |r|
-                res = Puppet::Parser::Resource.new(
-                    :type => r.type,
-                    :title => r.title,
+                res = Puppet::Parser::Resource.new(r.type, r.title,
                     :params => params,
                     :file => file,
                     :line => line,
diff --git a/lib/puppet/parser/ast/resource_reference.rb b/lib/puppet/parser/ast/resource_reference.rb
index 794e505b8..8e09a8e3b 100644
--- a/lib/puppet/parser/ast/resource_reference.rb
+++ b/lib/puppet/parser/ast/resource_reference.rb
@@ -1,76 +1,23 @@
+require 'puppet/parser/ast'
 require 'puppet/parser/ast/branch'
+require 'puppet/resource'
 
-class Puppet::Parser::AST
-    # A reference to an object.  Only valid as an rvalue.
-    class ResourceReference < AST::Branch
-        attr_accessor :title, :type
-        # Is the type a builtin type?
-        def builtintype?(type)
-            if typeklass = Puppet::Type.type(type)
-                return typeklass
-            else
-                return false
-            end
-        end
-
-        def each
-            [@type,@title].flatten.each { |param|
-                #Puppet.debug("yielding param %s" % param)
-                yield param
-            }
-        end
+class Puppet::Parser::AST::ResourceReference < Puppet::Parser::AST::Branch
+    attr_accessor :title, :type
 
-        # Evaluate our object, but just return a simple array of the type
-        # and name.
-        def evaluate(scope)
-            title = @title.safeevaluate(scope)
-            title = [title] unless title.is_a?(Array)
-
-            if @type.to_s.downcase == "class"
-                resource_type = "class"
-                title = title.collect { |t| qualified_class(scope, t) }
-            else
-                resource_type = qualified_type(scope)
-            end
-
-            title = title.collect { |t| Puppet::Parser::Resource::Reference.new(
-                :type => resource_type, :title => t
-            ) }
-            return title.pop if title.length == 1
-            return title
-        end
-
-        # Look up a fully qualified class name.
-        def qualified_class(scope, title)
-            # Look up the full path to the class
-            if classobj = scope.find_hostclass(title)
-                title = classobj.name
-            else
-                raise Puppet::ParseError, "Could not find class %s" % title
-            end
-        end
-
-        # Look up a fully-qualified type.  This method is
-        # also used in AST::Resource.
-        def qualified_type(scope, title = nil)
-            # We want a lower-case type.  For some reason.
-            objtype = @type.downcase
-            unless builtintype?(objtype)
-                if dtype = scope.find_definition(objtype)
-                    objtype = dtype.name
-                else
-                    raise Puppet::ParseError, "Could not find resource type %s" % objtype
-                end
-            end
-            return objtype
-        end
+    # Evaluate our object, but just return a simple array of the type
+    # and name.
+    def evaluate(scope)
+        titles = Array(title.safeevaluate(scope)).collect { |t| Puppet::Resource.new(type, t, :namespaces => scope.namespaces) }
+        return titles.pop if titles.length == 1
+        return titles
+    end
 
-        def to_s
-            if title.is_a?(ASTArray)
-                "#{type.to_s.capitalize}#{title}"
-            else
-                "#{type.to_s.capitalize}[#{title}]"
-            end
+    def to_s
+        if title.is_a?(Puppet::Parser::AST::ASTArray)
+            "#{type.to_s.capitalize}#{title}"
+        else
+            "#{type.to_s.capitalize}[#{title}]"
         end
     end
 end
diff --git a/lib/puppet/parser/collector.rb b/lib/puppet/parser/collector.rb
index a6763c419..044518793 100644
--- a/lib/puppet/parser/collector.rb
+++ b/lib/puppet/parser/collector.rb
@@ -75,7 +75,7 @@ class Puppet::Parser::Collector
         @collected = {}
 
         # Canonize the type
-        @type = Puppet::Resource::Reference.new(type, "whatever").type
+        @type = Puppet::Resource.new(type, "whatever").type
         @equery = equery
         @vquery = vquery
 
diff --git a/lib/puppet/parser/compiler.rb b/lib/puppet/parser/compiler.rb
index c669076bb..8e84f5a5b 100644
--- a/lib/puppet/parser/compiler.rb
+++ b/lib/puppet/parser/compiler.rb
@@ -275,9 +275,9 @@ class Puppet::Parser::Compiler
 
     # Find and evaluate our main object, if possible.
     def evaluate_main
-        @main = known_resource_types.find_hostclass("", "") || known_resource_types.add(Puppet::Resource::Type.new(:hostclass, ""))
+        @main = known_resource_types.find_hostclass([""], "") || known_resource_types.add(Puppet::Resource::Type.new(:hostclass, ""))
         @topscope.source = @main
-        @main_resource = Puppet::Parser::Resource.new(:type => "class", :title => :main, :scope => @topscope, :source => @main)
+        @main_resource = Puppet::Parser::Resource.new("class", :main, :scope => @topscope, :source => @main)
         @topscope.resource = @main_resource
 
         @resources << @main_resource
diff --git a/lib/puppet/parser/functions/defined.rb b/lib/puppet/parser/functions/defined.rb
index 5ad74a79e..4d1d8c6fd 100644
--- a/lib/puppet/parser/functions/defined.rb
+++ b/lib/puppet/parser/functions/defined.rb
@@ -6,21 +6,21 @@ Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :doc => "Dete
     (e.g., ``if defined(File['/tmp/myfile']) { ... }``).  This function is unfortunately
     dependent on the parse order of the configuration when testing whether a resource is defined.") do |vals|
         result = false
+        vals = [vals] unless vals.is_a?(Array)
         vals.each do |val|
             case val
             when String
-                # For some reason, it doesn't want me to return from here.
                 if Puppet::Type.type(val) or find_definition(val) or find_hostclass(val)
                     result = true
                     break
                 end
-            when Puppet::Parser::Resource::Reference
+            when Puppet::Resource
                 if findresource(val.to_s)
                     result = true
                     break
                 end
             else
-                raise ArgumentError, "Invalid argument of type %s to 'defined'" % val.class
+                raise ArgumentError, "Invalid argument of type '#{val.class}' to 'defined'"
             end
         end
         result
diff --git a/lib/puppet/parser/functions/require.rb b/lib/puppet/parser/functions/require.rb
index 66d60b9ce..294484a2b 100644
--- a/lib/puppet/parser/functions/require.rb
+++ b/lib/puppet/parser/functions/require.rb
@@ -49,7 +49,7 @@ fail if used with earlier clients.
             # The 'obvious' way is just to add an edge in the catalog,
             # but that is considered a containment edge, not a dependency
             # edge, so it usually gets lost on the client.
-            ref = Puppet::Parser::Resource::Reference.new(:type => :class, :title => klass)
+            ref = Puppet::Resource.new(:class, klass)
             resource.set_parameter(:require, [resource[:require]].flatten.compact << ref)
         end
     end
diff --git a/lib/puppet/parser/parser_support.rb b/lib/puppet/parser/parser_support.rb
index e6bc46b86..d43b0d37d 100644
--- a/lib/puppet/parser/parser_support.rb
+++ b/lib/puppet/parser/parser_support.rb
@@ -388,15 +388,4 @@ class Puppet::Parser::Parser
     def watch_file(filename)
         known_resource_types.watch_file(filename)
     end
-
-    private
-
-    def check_and_add_to_watched_files(filename)
-        unless @files.include?(filename)
-            @files[filename] = Puppet::Util::LoadedFile.new(filename)
-            return true
-        else
-            return false
-        end
-    end
 end
diff --git a/lib/puppet/parser/resource.rb b/lib/puppet/parser/resource.rb
index 428b9df50..36f1fbe93 100644
--- a/lib/puppet/parser/resource.rb
+++ b/lib/puppet/parser/resource.rb
@@ -1,8 +1,11 @@
-# A resource that we're managing.  This handles making sure that only subclasses
-# can set parameters.
-class Puppet::Parser::Resource
+require 'puppet/resource'
+
+# The primary difference between this class and its
+# parent is that this class has rules on who can set
+# parameters
+class Puppet::Parser::Resource < Puppet::Resource
     require 'puppet/parser/resource/param'
-    require 'puppet/parser/resource/reference'
+    require 'puppet/resource'
     require 'puppet/util/tagging'
     require 'puppet/file_collection/lookup'
     require 'puppet/parser/yaml_trimmer'
@@ -29,15 +32,8 @@ class Puppet::Parser::Resource
         @relationship_names.include?(name)
     end
 
-    # Proxy a few methods to our @ref object.
-    [:builtin?, :type, :title].each do |method|
-        define_method(method) do
-            @ref.send(method)
-        end
-    end
-
     # Set up some boolean test methods
-    [:exported, :translated, :override, :virtual, :evaluated].each do |method|
+    [:translated, :override, :evaluated].each do |method|
         newmeth = (method.to_s + "?").intern
         define_method(newmeth) do
             self.send(method)
@@ -60,25 +56,25 @@ class Puppet::Parser::Resource
         set_parameter(param, value)
     end
 
-    def builtin=(bool)
-        @ref.builtin = bool
-    end
-
     def eachparam
         @params.each do |name, param|
             yield param
         end
     end
 
+    def environment
+        scope.environment
+    end
+
     # Retrieve the associated definition and evaluate it.
     def evaluate
-        if klass = @ref.definedtype
+        if klass = resource_type and ! builtin_type?
             finish()
             return klass.evaluate_code(self)
         elsif builtin?
-            devfail "Cannot evaluate a builtin type"
+            devfail "Cannot evaluate a builtin type (#{type})"
         else
-            self.fail "Cannot find definition %s" % self.type
+            self.fail "Cannot find definition #{type}"
         end
     ensure
         @evaluated = true
@@ -111,61 +107,41 @@ class Puppet::Parser::Resource
         defined?(@finished) and @finished
     end
 
-    def initialize(options)
+    def initialize(type, title, options)
+        self.type = type
+        self.title = title
+
+        @params = {}
+        # Define all of the parameters
+        if params = options[:params]
+            extract_parameters(params)
+            options.delete(:params)
+        end
+
         # Set all of the options we can.
         options.each do |option, value|
             if respond_to?(option.to_s + "=")
                 send(option.to_s + "=", value)
                 options.delete(option)
+            else
+                raise ArgumentError, "Resources do not accept #{option}"
             end
         end
 
         unless self.scope
             raise ArgumentError, "Resources require a scope"
         end
-        @source ||= scope.source
-
-        options = symbolize_options(options)
-
-        # Set up our reference.
-        if type = options[:type] and title = options[:title]
-            options.delete(:type)
-            options.delete(:title)
-        else
-            raise ArgumentError, "Resources require a type and title"
-        end
-
-        @ref = Reference.new(:type => type, :title => title, :scope => self.scope)
-
-        @params = {}
-
-        # Define all of the parameters
-        if params = options[:params]
-            options.delete(:params)
-            params.each do |param|
-                # Don't set the same parameter twice
-                if @params[param.name]
-                    self.fail Puppet::ParseError, "Duplicate parameter '%s' for on %s" %
-                        [param.name, self.to_s]
-                end
-
-                set_parameter(param)
-            end
-        end
 
-        # Throw an exception if we've got any arguments left to set.
-        unless options.empty?
-            raise ArgumentError, "Resources do not accept %s" % options.keys.collect { |k| k.to_s }.join(", ")
-        end
+        @source ||= scope.source
 
-        tag(@ref.type)
-        tag(@ref.title) if valid_tag?(@ref.title.to_s)
+        tag(self.type)
+        tag(self.title) if valid_tag?(self.title.to_s)
     end
 
     # Is this resource modeling an isomorphic resource type?
     def isomorphic?
-        if builtin?
-            return @ref.builtintype.isomorphic?
+        if builtin_type?
+            return resource_type.isomorphic?
         else
             return true
         end
@@ -199,12 +175,8 @@ class Puppet::Parser::Resource
         @name
     end
 
-    # This *significantly* reduces the number of calls to Puppet.[].
-    def paramcheck?
-        unless defined? @@paramcheck
-            @@paramcheck = Puppet[:paramcheck]
-        end
-        @@paramcheck
+    def namespaces
+        scope.namespaces
     end
 
     # A temporary occasion, until I get paths in the scopes figured out.
@@ -212,11 +184,6 @@ class Puppet::Parser::Resource
         to_s
     end
 
-    # Return the short version of our name.
-    def ref
-        @ref.to_s
-    end
-
     # Define a parameter in our resource.
     # if we ever receive a parameter named 'tag', set
     # the resource tags with its value.
@@ -254,16 +221,16 @@ class Puppet::Parser::Resource
         result = Puppet::Resource.new(type, title)
 
         to_hash.each do |p, v|
-            if v.is_a?(Puppet::Parser::Resource::Reference)
-                v = Puppet::Resource::Reference.new(v.type, v.title)
+            if v.is_a?(Puppet::Resource)
+                v = Puppet::Resource.new(v.type, v.title)
             elsif v.is_a?(Array)
                 # flatten resource references arrays
-                if v.flatten.find { |av| av.is_a?(Puppet::Parser::Resource::Reference) }
+                if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
                     v = v.flatten
                 end
                 v = v.collect do |av|
-                    if av.is_a?(Puppet::Parser::Resource::Reference)
-                        av = Puppet::Resource::Reference.new(av.type, av.title)
+                    if av.is_a?(Puppet::Resource)
+                        av = Puppet::Resource.new(av.type, av.title)
                     end
                     av
                 end
@@ -289,10 +256,6 @@ class Puppet::Parser::Resource
         return result
     end
 
-    def to_s
-        self.ref
-    end
-
     # Translate our object to a transportable object.
     def to_trans
         return nil if virtual?
@@ -389,28 +352,26 @@ class Puppet::Parser::Resource
         set_parameter(param)
     end
 
-    # Verify that all passed parameters are valid.  This throws an error if
-    #  there's a problem, so we don't have to worry about the return value.
-    def paramcheck(param)
-        param = param.to_s
-        # Now make sure it's a valid argument to our class.  These checks
-        # are organized in order of commonhood -- most types, it's a valid
-        # argument and paramcheck is enabled.
-        if @ref.typeclass.valid_parameter?(param)
-            true
-        elsif %w{name title}.include?(param) # always allow these
-            true
-        elsif paramcheck?
-            self.fail Puppet::ParseError, "Invalid parameter '%s' for type '%s'" %
-                    [param, @ref.type]
-        end
-    end
-
     # Make sure the resource's parameters are all valid for the type.
     def validate
         @params.each do |name, param|
-            # Make sure it's a valid parameter.
-            paramcheck(name)
+            validate_parameter(name)
+        end
+    rescue => detail
+        fail Puppet::ParseError, detail.to_s
+    end
+
+    private
+
+    def extract_parameters(params)
+        params.each do |param|
+            # Don't set the same parameter twice
+            if @params[param.name]
+                self.fail Puppet::ParseError, "Duplicate parameter '%s' for on %s" %
+                    [param.name, self.to_s]
+            end
+
+            set_parameter(param)
         end
     end
 end
diff --git a/lib/puppet/parser/resource/reference.rb b/lib/puppet/parser/resource/reference.rb
deleted file mode 100644
index ac1c79aef..000000000
--- a/lib/puppet/parser/resource/reference.rb
+++ /dev/null
@@ -1,103 +0,0 @@
-# A reference to a resource.  Mostly just the type and title.
-require 'puppet/resource/reference'
-require 'puppet/file_collection/lookup'
-require 'puppet/parser/yaml_trimmer'
-
-require 'puppet/resource/type_collection_helper'
-
-# A reference to a resource.  Mostly just the type and title.
-class Puppet::Parser::Resource::Reference < Puppet::Resource::Reference
-    include Puppet::Parser::YamlTrimmer
-    include Puppet::FileCollection::Lookup
-    include Puppet::Util::MethodHelper
-    include Puppet::Util::Errors
-    include Puppet::Resource::TypeCollectionHelper
-
-    attr_accessor :builtin, :file, :line, :scope
-
-    # Are we a builtin type?
-    def builtin?
-        unless defined? @builtin
-            if builtintype()
-                @builtin = true
-            else
-                @builtin = false
-            end
-        end
-
-        @builtin
-    end
-
-    def builtintype
-        if t = Puppet::Type.type(self.type.downcase) and t.name != :component
-            t
-        else
-            nil
-        end
-    end
-
-    # Return the defined type for our obj.  This can return classes,
-    # definitions or nodes.
-    def definedtype
-        unless defined? @definedtype
-            case self.type
-            when "Class" # look for host classes
-                name = self.title == :main ? "" : self.title
-                unless tmp = known_resource_types.find_hostclass("", name)
-                    fail Puppet::ParseError, "Could not find '#{title}' class"
-                end
-            when "Node" # look for node definitions
-                unless tmp = known_resource_types.node(self.title)
-                    fail Puppet::ParseError, "Could not find node '%s'" % self.title
-                end
-            else # normal definitions
-                # The resource type is capitalized, so we have to downcase.  Really,
-                # we should have a better interface for finding these, but eh.
-                tmp = known_resource_types.definition(self.type.downcase)
-            end
-
-            if tmp
-                @definedtype = tmp
-            else
-                fail Puppet::ParseError, "Could not find resource type '%s'" % self.type
-            end
-        end
-
-        @definedtype
-    end
-
-    def environment
-        scope.environment
-    end
-
-    def initialize(hash)
-        set_options(hash)
-        requiredopts(:type, :title)
-    end
-
-    def skip_for_yaml
-        %w{@typeclass @definedtype}
-    end
-
-    def to_ref
-        # We have to return different cases to provide backward compatibility
-        # from 0.24.x to 0.23.x.
-        if builtin?
-            return [type.to_s.downcase, title.to_s]
-        else
-            return [type.to_s, title.to_s]
-        end
-    end
-
-    def typeclass
-        unless defined? @typeclass
-            if tmp = builtintype || definedtype
-                @typeclass = tmp
-            else
-                fail Puppet::ParseError, "Could not find type %s" % self.type
-            end
-        end
-
-        @typeclass
-    end
-end
diff --git a/lib/puppet/rails/param_value.rb b/lib/puppet/rails/param_value.rb
index b298924f3..d0bb8d7d3 100644
--- a/lib/puppet/rails/param_value.rb
+++ b/lib/puppet/rails/param_value.rb
@@ -23,7 +23,7 @@ class Puppet::Rails::ParamValue < ActiveRecord::Base
     def self.munge_parser_values(value)
         values = value.is_a?(Array) ? value : [value]
         values.map do |v|
-            if v.is_a?(Puppet::Resource::Reference)
+            if v.is_a?(Puppet::Resource)
                 v
             else
                 v.to_s
diff --git a/lib/puppet/resource.rb b/lib/puppet/resource.rb
index 010cd956e..ec1fd2eae 100644
--- a/lib/puppet/resource.rb
+++ b/lib/puppet/resource.rb
@@ -5,7 +5,6 @@ require 'puppet/util/pson'
 # The simplest resource class.  Eventually it will function as the
 # base class for all resource-like behaviour.
 class Puppet::Resource
-    require 'puppet/resource/reference'
     include Puppet::Util::Tagging
 
     require 'puppet/resource/type_collection_helper'
@@ -13,8 +12,8 @@ class Puppet::Resource
 
     extend Puppet::Util::Pson
     include Enumerable
-    attr_accessor :file, :line, :catalog, :exported, :virtual, :namespace, :validate_parameters
-    attr_writer :type, :title, :environment
+    attr_accessor :file, :line, :catalog, :exported, :virtual, :validate_parameters
+    attr_reader :type, :title, :namespaces
 
     require 'puppet/indirector'
     extend Puppet::Indirector
@@ -95,6 +94,13 @@ class Puppet::Resource
         @parameters[parameter_name(param)]
     end
 
+    def ==(other)
+        return false unless other.respond_to?(:title) and self.type == other.type and self.title == other.title
+
+        return false unless to_hash == other.to_hash
+        true
+    end
+
     # Compatibility method.
     def builtin?
         builtin_type?
@@ -102,7 +108,7 @@ class Puppet::Resource
 
     # Is this a builtin resource type?
     def builtin_type?
-        @reference.builtin_type?
+        resource_type.is_a?(Class)
     end
 
     # Iterate over each param/value pair, as required for Enumerable.
@@ -114,6 +120,23 @@ class Puppet::Resource
         super || @parameters.keys.include?( parameter_name(parameter) )
     end
 
+    # These two methods are extracted into a Helper
+    # module, but file load order prevents me
+    # from including them in the class, and I had weird
+    # behaviour (i.e., sometimes it didn't work) when
+    # I directly extended each resource with the helper.
+    def environment
+        Puppet::Node::Environment.new(@environment)
+    end
+
+    def environment=(env)
+        if env.is_a?(String) or env.is_a?(Symbol)
+            @environment = env
+        else
+            @environment = env.name
+        end
+    end
+
     %w{exported virtual}.each do |m|
         define_method(m+"?") do
             self.send(m)
@@ -121,14 +144,11 @@ class Puppet::Resource
     end
 
     # Create our resource.
-    def initialize(type, title, attributes = {})
-        # Doing this, instead of including it in the class,
-        # is the only way I could get the load order to work
-        # here.
-        extend Puppet::Node::Environment::Helper
+    def initialize(type, title = nil, attributes = {})
+        self.type, self.title = extract_type_and_title(type, title)
 
         @parameters = {}
-        @namespace = ""
+        @namespaces = [""]
 
         (attributes[:parameters] || {}).each do |param, value|
             self[param] = value
@@ -139,15 +159,25 @@ class Puppet::Resource
             send(attr.to_s + "=", value)
         end
 
-        @reference = Puppet::Resource::Reference.new(type, title)
-
-        tag(@reference.type)
-        tag(@reference.title) if valid_tag?(@reference.title)
+        tag(self.type)
+        tag(self.title) if valid_tag?(self.title)
     end
 
-    # Provide a reference to our resource in the canonical form.
     def ref
-        @reference.to_s
+        to_s
+    end
+
+    # Find our resource.
+    def resolve
+        return catalog.resource(to_s) if catalog
+        return nil
+    end
+
+    def title=(value)
+        if @type and klass = Puppet::Type.type(@type.to_s.downcase)
+            value = klass.canonicalize_ref(value)
+        end
+        @title = value
     end
 
     def resource_type
@@ -159,16 +189,6 @@ class Puppet::Resource
         end
     end
 
-    # Get our title information from the reference, since it will canonize it for us.
-    def title
-        @reference.title
-    end
-
-    # Get our type information from the reference, since it will canonize it for us.
-    def type
-        @reference.type
-    end
-
     # Produce a simple hash of our parameters.
     def to_hash
         result = @parameters.dup
@@ -179,7 +199,7 @@ class Puppet::Resource
     end
 
     def to_s
-        return ref
+        "#{type}[#{title}]"
     end
 
     # Convert our resource to Puppet code.
@@ -211,7 +231,7 @@ class Puppet::Resource
 
     # Translate our object to a backward-compatible transportable object.
     def to_trans
-        if @reference.builtin_type?
+        if builtin_type?
             result = to_transobject
         else
             result = to_transbucket
@@ -223,16 +243,20 @@ class Puppet::Resource
         return result
     end
 
+    def to_trans_ref
+        [type.to_s, title.to_s]
+    end
+
     # Create an old-style TransObject instance, for builtin resource types.
     def to_transobject
         # Now convert to a transobject
-        result = Puppet::TransObject.new(@reference.title, @reference.type)
+        result = Puppet::TransObject.new(title, type)
         to_hash.each do |p, v|
-            if v.is_a?(Puppet::Resource::Reference)
+            if v.is_a?(Puppet::Resource)
                 v = v.to_trans_ref
             elsif v.is_a?(Array)
                 v = v.collect { |av|
-                    if av.is_a?(Puppet::Resource::Reference)
+                    if av.is_a?(Puppet::Resource)
                         av = av.to_trans_ref
                     end
                     av
@@ -266,6 +290,15 @@ class Puppet::Resource
         self
     end
 
+    # Canonize the type so we know it's always consistent.
+    def type=(value)
+        if value.nil? or value.to_s.downcase == "component"
+            @type = "Class"
+        else
+            @type = value.to_s.split("::").collect { |s| s.capitalize }.join("::")
+        end
+    end
+
     def valid_parameter?(name)
         resource_type.valid_parameter?(name)
     end
@@ -282,7 +315,7 @@ class Puppet::Resource
 
     def find_hostclass
         name = title == :main ? "" : title
-        known_resource_types.find_hostclass(namespace, name)
+        known_resource_types.find_hostclass(namespaces, name)
     end
 
     def find_builtin_resource_type
@@ -290,7 +323,7 @@ class Puppet::Resource
     end
 
     def find_defined_resource_type
-        known_resource_types.find_definition(namespace, type.to_s.downcase)
+        known_resource_types.find_definition(namespaces, type.to_s.downcase)
     end
 
     # Produce a canonical method name.
@@ -302,10 +335,14 @@ class Puppet::Resource
         param
     end
 
+    def namespaces=(ns)
+        @namespaces = Array(ns)
+    end
+
     # The namevar for our resource type. If the type doesn't exist,
     # always use :name.
     def namevar
-        if t = resource_type
+        if builtin_type? and t = resource_type
             t.namevar
         else
             :name
@@ -322,4 +359,14 @@ class Puppet::Resource
         # TransBuckets don't support parameters, which is why they're being deprecated.
         return bucket
     end
+
+    private
+
+    def extract_type_and_title(argtype, argtitle)
+	    if    (argtitle || argtype) =~ /^([^\[\]]+)\[(.+)\]$/m then [ $1,                 $2            ]
+	    elsif argtitle                                         then [ argtype,            argtitle      ]
+	    elsif argtype.is_a?(Puppet::Type)                      then [ argtype.class.name, argtype.title ]
+	    else raise ArgumentError, "No title provided and #{argtype.inspect} is not a valid resource reference"
+	    end
+    end
 end
diff --git a/lib/puppet/resource/catalog.rb b/lib/puppet/resource/catalog.rb
index 6e064a9a1..e63c00c62 100644
--- a/lib/puppet/resource/catalog.rb
+++ b/lib/puppet/resource/catalog.rb
@@ -376,12 +376,12 @@ class Puppet::Resource::Catalog < Puppet::SimpleGraph
         # Always create a resource reference, so that it always canonizes how we
         # are referring to them.
         if title
-            ref = Puppet::Resource::Reference.new(type, title).to_s
+            ref = Puppet::Resource.new(type, title).to_s
         else
             # If they didn't provide a title, then we expect the first
             # argument to be of the form 'Class[name]', which our
             # Reference class canonizes for us.
-            ref = Puppet::Resource::Reference.new(nil, type).to_s
+            ref = Puppet::Resource.new(nil, type).to_s
         end
         @resource_table[ref]
     end
diff --git a/lib/puppet/resource/reference.rb b/lib/puppet/resource/reference.rb
deleted file mode 100644
index eddb2d96b..000000000
--- a/lib/puppet/resource/reference.rb
+++ /dev/null
@@ -1,90 +0,0 @@
-#
-#  Created by Luke Kanies on 2007-11-28.
-#  Copyright (c) 2007. All rights reserved.
-
-require 'puppet'
-require 'puppet/resource'
-
-# A simple class to canonize how we refer to and retrieve
-# resources.
-class Puppet::Resource::Reference
-    attr_reader :type, :title
-    attr_accessor :catalog
-
-    def ==(other)
-        other.respond_to?(:title) and self.type == other.type and self.title == other.title
-    end
-
-    def builtin_type?
-        builtin_type ? true : false
-    end
-
-    def initialize(argtype, argtitle = nil)
-        self.type,self.title = 
-	    if    (argtitle || argtype) =~ /^([^\[\]]+)\[(.+)\]$/m then [ $1,                 $2            ]
-	    elsif argtitle                                         then [ argtype,            argtitle      ]
-	    elsif argtype.is_a?(Puppet::Type)                      then [ argtype.class.name, argtype.title ]
-	    else raise ArgumentError, "No title provided and #{argtype.inspect} is not a valid resource reference"
-	    end
-        @builtin_type = nil
-    end
-
-    # Find our resource.
-    def resolve
-        return catalog.resource(to_s) if catalog
-        return nil
-    end
-
-    def title=(value)
-        if @type and klass = Puppet::Type.type(@type.to_s.downcase)
-            value = klass.canonicalize_ref(value)
-        end
-        @title = value
-    end
-
-    # Canonize the type so we know it's always consistent.
-    def type=(value)
-        if value.nil? or value.to_s.downcase == "component"
-            @type = "Class"
-        else
-            # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
-            x = @type = value.to_s.split("::").collect { |s| s.capitalize }.join("::")
-        end
-
-        if @title
-            self.title = @title
-        end
-    end
-
-    # Convert to the reference format that TransObject uses.  Yay backward
-    # compatibility.
-    def to_trans_ref
-        # We have to return different cases to provide backward compatibility
-        # from 0.24.x to 0.23.x.
-        if builtin_type?
-            return [type.to_s.downcase, title.to_s]
-        else
-            return [type.to_s, title.to_s]
-        end
-    end
-
-    # Convert to the standard way of referring to resources.
-    def to_s
-        "%s[%s]" % [@type, @title]
-    end
-
-    private
-
-    def builtin_type
-        if @builtin_type.nil?
-            if @type =~ /::/
-                @builtin_type = false
-            elsif klass = Puppet::Type.type(@type.to_s.downcase)
-                @builtin_type = true
-            else
-                @builtin_type = false
-            end
-        end
-        @builtin_type
-    end
-end
diff --git a/lib/puppet/resource/type.rb b/lib/puppet/resource/type.rb
index d47658284..c615a2ccb 100644
--- a/lib/puppet/resource/type.rb
+++ b/lib/puppet/resource/type.rb
@@ -60,11 +60,11 @@ class Puppet::Resource::Type
 
     # Add code from a new instance to our code.
     def merge(other)
-        fail ArgumentError, "#{name} is not a class; cannot add code to it" unless type == :hostclass
-        fail ArgumentError, "#{other.name} is not a class; cannot add code from it" unless other.type == :hostclass
+        fail "#{name} is not a class; cannot add code to it" unless type == :hostclass
+        fail "#{other.name} is not a class; cannot add code from it" unless other.type == :hostclass
 
         if parent and other.parent and parent != other.parent
-            fail ArgumentError, "Cannot merge classes with different parent classes"
+            fail "Cannot merge classes with different parent classes (#{name} => #{parent} vs. #{other.name} => #{other.parent})"
         end
 
         # We know they're either equal or only one is set, so keep whichever parent is specified.
@@ -114,7 +114,7 @@ class Puppet::Resource::Type
             return resource
         end
 
-        resource = Puppet::Parser::Resource.new(:type => resource_type, :title => name, :scope => scope, :source => self)
+        resource = Puppet::Parser::Resource.new(resource_type, name, :scope => scope, :source => self)
         scope.compiler.add_resource(scope, resource)
         scope.catalog.tag(*resource.tags)
         resource
diff --git a/lib/puppet/resource/type_collection.rb b/lib/puppet/resource/type_collection.rb
index a0bd2ddf5..e2ca56290 100644
--- a/lib/puppet/resource/type_collection.rb
+++ b/lib/puppet/resource/type_collection.rb
@@ -1,6 +1,12 @@
 class Puppet::Resource::TypeCollection
     attr_reader :environment
 
+    def clear
+        @hostclasses.clear
+        @definitions.clear
+        @nodes.clear
+    end
+
     def initialize(env)
         @environment = env.is_a?(String) ? Puppet::Node::Environment.new(env) : env
         @hostclasses = {}
@@ -19,6 +25,10 @@ class Puppet::Resource::TypeCollection
     end
 
     def add(instance)
+        if instance.type == :hostclass and other = @hostclasses[instance.name] and other.type == :hostclass
+            other.merge(instance)
+            return other
+        end
         method = "add_#{instance.type}"
         send(method, instance)
         instance.code_collection = self
@@ -26,8 +36,8 @@ class Puppet::Resource::TypeCollection
     end
 
     def add_hostclass(instance)
-        dupe_check(instance, @hostclasses) { |dupe| "Class #{instance.name} is already defined#{dupe.error_context}; cannot redefine" }
-        dupe_check(instance, @definitions) { |dupe| "Definition #{instance.name} is already defined#{dupe.error_context}; cannot be redefined as a class" }
+        dupe_check(instance, @hostclasses) { |dupe| "Class '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
+        dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined as a class" }
 
         @hostclasses[instance.name] = instance
         instance
@@ -38,7 +48,7 @@ class Puppet::Resource::TypeCollection
     end
 
     def add_node(instance)
-        dupe_check(instance, @nodes) { |dupe| "Node #{instance.name} is already defined#{dupe.error_context}; cannot redefine" }
+        dupe_check(instance, @nodes) { |dupe| "Node '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
 
         @node_list << instance
         @nodes[instance.name] = instance
@@ -67,8 +77,10 @@ class Puppet::Resource::TypeCollection
         @nodes.length > 0
     end
 
-    def add_definition(code)
-        @definitions[code.name] = code
+    def add_definition(instance)
+        dupe_check(instance, @hostclasses) { |dupe| "'#{instance.name}' is already defined#{dupe.error_context} as a class; cannot redefine as a definition" }
+        dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined" }
+        @definitions[instance.name] = instance
     end
 
     def definition(name)
@@ -76,12 +88,13 @@ class Puppet::Resource::TypeCollection
     end
 
     def find(namespaces, name, type)
+        #Array("") == [] for some reason
+        namespaces = [namespaces] unless namespaces.is_a?(Array)
+
         if r = find_fully_qualified(name, type)
             return r
         end
 
-        namespaces = Array(namespaces)
-
         namespaces.each do |namespace|
             ary = namespace.split("::")
 
diff --git a/lib/puppet/transportable.rb b/lib/puppet/transportable.rb
index 1970d9f1e..c4881701c 100644
--- a/lib/puppet/transportable.rb
+++ b/lib/puppet/transportable.rb
@@ -1,5 +1,5 @@
 require 'puppet'
-require 'puppet/resource/reference'
+require 'puppet/resource'
 require 'yaml'
 
 module Puppet
@@ -36,7 +36,7 @@ module Puppet
 
         def ref
             unless defined? @ref
-                @ref = Puppet::Resource::Reference.new(@type, @name)
+                @ref = Puppet::Resource.new(@type, @name)
             end
             @ref.to_s
         end
@@ -225,11 +225,11 @@ module Puppet
         def to_ref
             unless defined? @ref
                 if self.type and self.name
-                    @ref = Puppet::Resource::Reference.new(self.type, self.name)
+                    @ref = Puppet::Resource.new(self.type, self.name)
                 elsif self.type and ! self.name # This is old-school node types
-                    @ref = Puppet::Resource::Reference.new("node", self.type)
+                    @ref = Puppet::Resource.new("node", self.type)
                 elsif ! self.type and self.name
-                    @ref = Puppet::Resource::Reference.new("component", self.name)
+                    @ref = Puppet::Resource.new("component", self.name)
                 else
                     @ref = nil
                 end
@@ -244,7 +244,7 @@ module Puppet
         # Create a normalized resource from our TransObject.
         def to_resource
             params = defined?(@parameters) ? @parameters.dup : {}
-            Puppet::Resource.new(type, name, params)
+            Puppet::Resource.new(type, name, :parameters => params)
         end
 
         def param(param,value)
diff --git a/lib/puppet/type.rb b/lib/puppet/type.rb
index 31728c374..ee545a99b 100644
--- a/lib/puppet/type.rb
+++ b/lib/puppet/type.rb
@@ -9,7 +9,7 @@ require 'puppet/metatype/manager'
 require 'puppet/util/errors'
 require 'puppet/util/log_paths'
 require 'puppet/util/logging'
-require 'puppet/resource/reference'
+require 'puppet/resource'
 require 'puppet/util/cacher'
 require 'puppet/file_collection/lookup'
 require 'puppet/util/tagging'
@@ -1231,10 +1231,10 @@ class Type
         def munge(references)
             references = [references] unless references.is_a?(Array)
             references.collect do |ref|
-                if ref.is_a?(Puppet::Resource::Reference)
+                if ref.is_a?(Puppet::Resource)
                     ref
                 else
-                    Puppet::Resource::Reference.new(ref)
+                    Puppet::Resource.new(ref)
                 end
             end
         end
diff --git a/lib/puppet/type/component.rb b/lib/puppet/type/component.rb
index bf9007ab4..d16cdda06 100644
--- a/lib/puppet/type/component.rb
+++ b/lib/puppet/type/component.rb
@@ -65,7 +65,7 @@ Puppet::Type.newtype(:component) do
     end
 
     def title=(str)
-        @reference = Puppet::Resource::Reference.new(str)
+        @reference = Puppet::Resource.new(str)
     end
 
     def refresh
diff --git a/lib/puppet/type/tidy.rb b/lib/puppet/type/tidy.rb
index 830f47640..c912ad3ad 100755
--- a/lib/puppet/type/tidy.rb
+++ b/lib/puppet/type/tidy.rb
@@ -275,9 +275,9 @@ Puppet::Type.newtype(:tidy) do
             dir = File.dirname(path)
             next unless resource = files_by_name[dir]
             if resource[:require]
-                resource[:require] << Puppet::Resource::Reference.new(:file, path)
+                resource[:require] << Puppet::Resource.new(:file, path)
             else
-                resource[:require] = [Puppet::Resource::Reference.new(:file, path)]
+                resource[:require] = [Puppet::Resource.new(:file, path)]
             end
         end
 
diff --git a/lib/puppet/util/settings.rb b/lib/puppet/util/settings.rb
index f50d46642..e3f95d89e 100644
--- a/lib/puppet/util/settings.rb
+++ b/lib/puppet/util/settings.rb
@@ -5,7 +5,6 @@ require 'puppet/external/event-loop'
 require 'puppet/util/cacher'
 require 'puppet/util/loadedfile'
 require 'puppet/resource'
-require 'puppet/resource/reference'
 
 # The class for handling configuration files.
 class Puppet::Util::Settings
diff --git a/spec/integration/application/puppet.rb b/spec/integration/application/puppet.rb
index 1342f3c5f..cfafc9c0c 100755
--- a/spec/integration/application/puppet.rb
+++ b/spec/integration/application/puppet.rb
@@ -14,7 +14,7 @@ describe "Puppet" do
         it "should be able to apply catalogs provided in a file in pson" do
             file_to_create = tmpfile("pson_catalog")
             catalog = Puppet::Resource::Catalog.new
-            resource = Puppet::Resource.new(:file, file_to_create, :content => "my stuff")
+            resource = Puppet::Resource.new(:file, file_to_create, :parameters => {:content => "my stuff"})
             catalog.add_resource resource
 
             manifest = tmpfile("manifest")
diff --git a/spec/integration/indirector/catalog/compiler.rb b/spec/integration/indirector/catalog/compiler.rb
index 16102cafe..b4067a6bb 100755
--- a/spec/integration/indirector/catalog/compiler.rb
+++ b/spec/integration/indirector/catalog/compiler.rb
@@ -8,6 +8,7 @@ Puppet::Resource::Catalog.indirection.terminus(:compiler)
 
 describe Puppet::Resource::Catalog::Compiler do
     before do
+        Facter.stubs(:value).returns "something"
         @catalog = Puppet::Resource::Catalog.new
 
         @one = Puppet::Resource.new(:file, "/one")
diff --git a/spec/unit/configurer.rb b/spec/unit/configurer.rb
index 9fc46affd..48a197a37 100755
--- a/spec/unit/configurer.rb
+++ b/spec/unit/configurer.rb
@@ -84,6 +84,7 @@ describe Puppet::Configurer, "when executing a catalog run" do
     before do
         Puppet.settings.stubs(:use).returns(true)
         @agent = Puppet::Configurer.new
+        @agent.stubs(:prepare)
         @agent.stubs(:facts_for_uploading).returns({})
         @agent.stubs(:retrieve_catalog).returns Puppet::Resource::Catalog.new
 
@@ -122,7 +123,7 @@ describe Puppet::Configurer, "when executing a catalog run" do
     it "should log a failure and do nothing if no catalog can be retrieved" do
         @agent.expects(:retrieve_catalog).returns nil
 
-        Puppet.expects(:err)
+        Puppet.expects(:err).with "Could not retrieve catalog; skipping run"
 
         @agent.run
     end
diff --git a/spec/unit/indirector/catalog/compiler.rb b/spec/unit/indirector/catalog/compiler.rb
index d11daaa96..8339d1861 100755
--- a/spec/unit/indirector/catalog/compiler.rb
+++ b/spec/unit/indirector/catalog/compiler.rb
@@ -11,7 +11,7 @@ describe Puppet::Resource::Catalog::Compiler do
     before do
         Puppet::Rails.stubs(:init)
         Facter.stubs(:to_hash).returns({})
-        Facter.stubs(:[]).returns(Facter::Util::Fact.new("something"))
+        Facter.stubs(:value).returns(Facter::Util::Fact.new("something"))
     end
 
     describe "when initializing" do
@@ -44,7 +44,7 @@ describe Puppet::Resource::Catalog::Compiler do
 
         describe "and storeconfigs is enabled" do
             before do
-                Puppet.settings[:storeconfigs] = true
+                Puppet.settings.expects(:value).with(:storeconfigs).returns true
             end
 
             it "should initialize Rails if it is available" do
@@ -141,11 +141,11 @@ describe Puppet::Resource::Catalog::Compiler do
 
     describe "when extracting facts from the request" do
         before do
+            Facter.stubs(:value).returns "something"
             @compiler = Puppet::Resource::Catalog::Compiler.new
             @request = stub 'request', :options => {}
 
             @facts = stub 'facts', :save => nil
-            Facter.stubs(:value).returns "something"
         end
 
         it "should do nothing if no facts are provided" do
diff --git a/spec/unit/parser/ast/resource.rb b/spec/unit/parser/ast/resource.rb
index b257cb116..391f4c770 100755
--- a/spec/unit/parser/ast/resource.rb
+++ b/spec/unit/parser/ast/resource.rb
@@ -9,16 +9,15 @@ describe Puppet::Parser::AST::Resource do
         @title = stub_everything 'title'
         @compiler = stub_everything 'compiler'
         @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
-        @param1 = stub_everything 'parameter', :is_a? => true
         @scope.stubs(:resource).returns(stub_everything)
-        @params = ast::ASTArray.new( :children => [@param1])
-        @resource = ast::Resource.new(:title => @title, :type => "Resource", :params => @params )
+        @resource = ast::Resource.new(:title => @title, :type => "Resource", :params => ast::ASTArray.new(:children => []) )
         @resource.stubs(:qualified_type).returns("Resource")
-        Puppet::Parser::Resource.stubs(:new).returns(stub_everything)
     end
 
     it "should evaluate all its parameters" do
-        @param1.expects(:safeevaluate).with(@scope)
+        param = stub 'param'
+        param.expects(:safeevaluate).with(@scope).returns Puppet::Parser::Resource::Param.new(:name => "myparam", :value => "myvalue", :source => stub("source"))
+        @resource.stubs(:params).returns [param]
 
         @resource.evaluate(@scope)
     end
@@ -49,10 +48,10 @@ describe Puppet::Parser::AST::Resource do
         title_array.stubs(:flatten).returns([@title])
         titles.stubs(:safeevaluate).with(@scope).returns(title_array)
 
-        Puppet::Parser::Resource.expects(:new).with { |hash| hash[:title] == @title }
-
         @resource.title = titles
-        @resource.evaluate(@scope)
+        result = @resource.evaluate(@scope)
+        result[0].should be_instance_of(Puppet::Parser::Resource)
+        result[0].title.should == @title
     end
 
     it "should handover resources to the compiler" do
@@ -77,18 +76,18 @@ describe Puppet::Parser::AST::Resource do
 
         title_array.stubs(:flatten).returns([@title])
         titles.stubs(:safeevaluate).with(@scope).returns(title_array)
-        Puppet::Parser::Resource.stubs(:new).returns(resource)
 
-        @compiler.stubs(:add_resource).with(resource)
+        @compiler.stubs(:add_resource)
 
         @resource.title = titles
-        @resource.evaluate(@scope).should == [resource]
+        @resource.evaluate(@scope)[0].should be_instance_of(Puppet::Parser::Resource)
     end
 
     it "should generate virtual resources if it is virtual" do
         @resource.virtual = true
 
-        Puppet::Parser::Resource.expects(:new).with { |hash| hash[:virtual] == true }
+        result = @resource.evaluate(@scope)
+        result[0].should be_virtual
 
         @resource.evaluate(@scope)
     end
@@ -96,8 +95,8 @@ describe Puppet::Parser::AST::Resource do
     it "should generate virtual and exported resources if it is exported" do
         @resource.exported = true
 
-        Puppet::Parser::Resource.expects(:new).with { |hash| hash[:virtual] == true and hash[:exported] == true }
-
-        @resource.evaluate(@scope)
+        result = @resource.evaluate(@scope)
+        result[0].should be_virtual
+        result[0].should be_exported
     end
 end
diff --git a/spec/unit/parser/ast/resource_reference.rb b/spec/unit/parser/ast/resource_reference.rb
index 10d9678c3..ee42694b9 100755
--- a/spec/unit/parser/ast/resource_reference.rb
+++ b/spec/unit/parser/ast/resource_reference.rb
@@ -10,54 +10,31 @@ describe Puppet::Parser::AST::ResourceReference do
         @scope = Puppet::Parser::Scope.new()
     end
 
-    def newref(title, type)
+    def newref(type, title)
         title = stub 'title', :safeevaluate => title
         ref = Puppet::Parser::AST::ResourceReference.new(:type => type, :title => title)
     end
 
-    it "should evaluate correctly reference to builtin types" do
-        newref("/tmp/yay", "File").evaluate(@scope).to_s.should == "File[/tmp/yay]"
+    it "should correctly produce reference strings" do
+        newref("File", "/tmp/yay").evaluate(@scope).to_s.should == "File[/tmp/yay]"
     end
 
-    %{ "one::two" "one-two"}.each do |type|
-        it "should evaluate correctly reference to define" do
-            klass = stub 'klass', :title => "three", :name => type
-            @scope.stubs(:find_definition).returns(klass)
-        
-            newref("three", type).evaluate(@scope).to_ref.should == Puppet::Parser::Resource::Reference.new( :type => type, :title => "three" ).to_ref
-        end
+    it "should produce a single resource when the title evaluates to a string" do
+        newref("File", "/tmp/yay").evaluate(@scope).should == Puppet::Resource.new("file", "/tmp/yay")
     end
 
-    it "should be able to call qualified_class" do
-        klass = stub 'klass', :title => "three", :name => "one"
-        @scope.expects(:find_hostclass).with("one").returns(klass)
-        newref("three","class").qualified_class(@scope,"one").should == "one" 
-    end
-
-    it "should be able to find qualified classes when evaluating" do
-        klass = stub 'klass', :title => "one", :name => "one"
-        @scope.stubs(:find_hostclass).returns(klass)
-        
-        evaled = newref("one", "class").evaluate(@scope)
-        evaled.type.should == "Class"
-        evaled.title.should == "one"
-    end
-
-    it "should return an array of reference if given an array of titles" do
+    it "should return an array of resources if given an array of titles" do
         titles = mock 'titles', :safeevaluate => ["title1","title2"]
-        ref = ast::ResourceReference.new( :title => titles, :type => "Resource" )
-        ref.stubs(:qualified_type).with(@scope).returns("Resource")
-
-        ref.evaluate(@scope).should have(2).elements
+        ref = ast::ResourceReference.new( :title => titles, :type => "File" )
+        ref.evaluate(@scope).should == [
+            Puppet::Resource.new("file", "title1"),
+            Puppet::Resource.new("file", "title2")
+        ]
     end
 
-    it "should qualify class of all titles for Class resource references" do
-        titles = mock 'titles', :safeevaluate => ["title1","title2"]
-        ref = ast::ResourceReference.new( :title => titles, :type => "Class" )
-        ref.expects(:qualified_class).with(@scope,"title1").returns("class")
-        ref.expects(:qualified_class).with(@scope,"title2").returns("class")
-
-        ref.evaluate(@scope)
+    it "should pass its scope's namespaces to all created resource references" do
+        @scope.add_namespace "foo"
+        newref("File", "/tmp/yay").evaluate(@scope).namespaces.should == ["foo"]
     end
 
     it "should return a correct representation when converting to string" do
diff --git a/spec/unit/parser/collector.rb b/spec/unit/parser/collector.rb
index 7f88bf754..9c2d722e5 100755
--- a/spec/unit/parser/collector.rb
+++ b/spec/unit/parser/collector.rb
@@ -52,11 +52,10 @@ end
 describe Puppet::Parser::Collector, "when collecting specific virtual resources" do
     before do
         @scope = mock 'scope'
-        @resource_type = mock 'resource_type'
         @vquery = mock 'vquery'
         @equery = mock 'equery'
 
-        @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @equery, @vquery, :virtual)
+        @collector = Puppet::Parser::Collector.new(@scope, "resource_type", @equery, @vquery, :virtual)
     end
 
     it "should not fail when it does not find any resources to collect" do
diff --git a/spec/unit/parser/compiler.rb b/spec/unit/parser/compiler.rb
index 333046c77..6fd4d1fb5 100755
--- a/spec/unit/parser/compiler.rb
+++ b/spec/unit/parser/compiler.rb
@@ -174,10 +174,9 @@ describe Puppet::Parser::Compiler do
 
         it "should evaluate the main class if it exists" do
             compile_stub(:evaluate_main)
-            main_class = mock 'main_class'
+            main_class = @known_resource_types.add Puppet::Resource::Type.new(:hostclass, "")
             main_class.expects(:evaluate_code).with { |r| r.is_a?(Puppet::Parser::Resource) }
             @compiler.topscope.expects(:source=).with(main_class)
-            @known_resource_types.stubs(:find_hostclass).with("", "").returns(main_class)
 
             @compiler.compile
         end
@@ -185,7 +184,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::Resource::Type)
+            @known_resource_types.find_hostclass([""], "").should be_instance_of(Puppet::Resource::Type)
         end
 
         it "should evaluate any node classes" do
@@ -252,7 +251,7 @@ describe Puppet::Parser::Compiler do
 
         it "should call finish() on all resources" do
             # Add a resource that does respond to :finish
-            resource = Puppet::Parser::Resource.new :scope => @scope, :type => "file", :title => "finish"
+            resource = Puppet::Parser::Resource.new "file", "finish", :scope => @scope
             resource.expects(:finish)
 
             @compiler.add_resource(@scope, resource)
@@ -268,12 +267,12 @@ describe Puppet::Parser::Compiler do
         it "should call finish() in add_resource order" do
             resources = sequence('resources')
 
-            resource1 = Puppet::Parser::Resource.new :scope => @scope, :type => "file", :title => "finish1"
+            resource1 = Puppet::Parser::Resource.new "file", "finish1", :scope => @scope
             resource1.expects(:finish).in_sequence(resources)
 
             @compiler.add_resource(@scope, resource1)
 
-            resource2 = Puppet::Parser::Resource.new :scope => @scope, :type => "file", :title => "finish2"
+            resource2 = Puppet::Parser::Resource.new "file", "finish2", :scope => @scope
             resource2.expects(:finish).in_sequence(resources)
 
             @compiler.add_resource(@scope, resource2)
diff --git a/spec/unit/parser/functions/defined.rb b/spec/unit/parser/functions/defined.rb
new file mode 100755
index 000000000..0da8c4a31
--- /dev/null
+++ b/spec/unit/parser/functions/defined.rb
@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "the 'defined' function" do
+
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+        @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
+        @scope.compiler = @compiler
+    end
+
+    it "should exist" do
+        Puppet::Parser::Functions.function("defined").should == "function_defined"
+    end
+
+    it "should be true when the name is defined as a class" do
+        @scope.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "yayness")
+        @scope.function_defined("yayness").should be_true
+    end
+    
+    it "should be true when the name is defined as a definition" do
+        @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yayness")
+        @scope.function_defined("yayness").should be_true
+    end
+
+    it "should be true when the name is defined as a builtin type" do
+        @scope.function_defined("file").should be_true
+    end
+
+
+    it "should be true when any of the provided names are defined" do
+        @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yayness")
+        @scope.function_defined(["meh", "yayness", "booness"]).should be_true
+    end
+
+    it "should be false when a single given name is not defined" do
+        @scope.function_defined("meh").should be_false
+    end
+
+    it "should be false when none of the names are defined" do
+        @scope.function_defined(["meh", "yayness", "booness"]).should be_false
+    end
+
+    it "should be true when a resource reference is provided and the resource is in the catalog" do
+        resource = Puppet::Resource.new("file", "/my/file")
+        @compiler.add_resource(@scope, resource)
+        @scope.function_defined(resource).should be_true
+    end
+end
diff --git a/spec/unit/parser/functions/require.rb b/spec/unit/parser/functions/require.rb
index 924990a5d..1d9ce931c 100755
--- a/spec/unit/parser/functions/require.rb
+++ b/spec/unit/parser/functions/require.rb
@@ -28,7 +28,7 @@ describe "the require function" do
     end
 
     it "should set the 'require' prarameter on the resource to a resource reference" do
-        @resource.expects(:set_parameter).with { |name, value| name == :require and value[0].is_a?(Puppet::Parser::Resource::Reference) }
+        @resource.expects(:set_parameter).with { |name, value| name == :require and value[0].is_a?(Puppet::Resource) }
         @scope.stubs(:function_include)
         @scope.function_require("myclass")
     end
diff --git a/spec/unit/parser/functions/tag.rb b/spec/unit/parser/functions/tag.rb
new file mode 100755
index 000000000..5fb467e59
--- /dev/null
+++ b/spec/unit/parser/functions/tag.rb
@@ -0,0 +1,24 @@
+#! /usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "the 'tag' function" do
+
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+    end
+
+    it "should exist" do
+        Puppet::Parser::Functions.function(:tag).should == "function_tag"
+    end
+
+    it "should tag the resource with any provided tags" do
+        resource = Puppet::Parser::Resource.new(:file, "/file", :scope => @scope)
+        @scope.expects(:resource).returns resource
+
+        @scope.function_tag ["one", "two"]
+
+        resource.should be_tagged("one")
+        resource.should be_tagged("two")
+    end
+end
diff --git a/spec/unit/parser/parser.rb b/spec/unit/parser/parser.rb
index 84749c3fb..8cc29c9b8 100755
--- a/spec/unit/parser/parser.rb
+++ b/spec/unit/parser/parser.rb
@@ -429,6 +429,12 @@ describe Puppet::Parser do
             @krt.hostclass("foobar").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"
+        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
@@ -451,5 +457,15 @@ describe Puppet::Parser do
             @krt.add(Puppet::Resource::Type.new(:hostclass, "foobar", :arguments => {"biz" => nil}))
             lambda { @parser.parse("class { foobar: biz => stuff }") }.should_not raise_error
         end
+        
+        it "should correctly mark exported resources as exported" do
+            @parser.parse("@@file { '/file': }")
+            @krt.hostclass("").code[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
+        end
     end
 end
diff --git a/spec/unit/parser/resource.rb b/spec/unit/parser/resource.rb
index bb3001c8e..0c70c817e 100755
--- a/spec/unit/parser/resource.rb
+++ b/spec/unit/parser/resource.rb
@@ -19,7 +19,7 @@ describe Puppet::Parser::Resource do
         args[:source] ||= "source"
         args[:scope] ||= stub('scope', :source => mock('source'))
 
-        {:type => "resource", :title => "testing", :source => "source", :scope => "scope"}.each do |param, value|
+        {:source => "source", :scope => "scope"}.each do |param, value|
             args[param] ||= value
         end
 
@@ -30,7 +30,7 @@ describe Puppet::Parser::Resource do
             args[:params] = paramify(args[:source], params)
         end
 
-        Puppet::Parser::Resource.new(args)
+        Puppet::Parser::Resource.new("resource", "testing", args)
     end
 
     def param(name, value, source)
@@ -61,19 +61,31 @@ describe Puppet::Parser::Resource do
         Puppet::Parser::Resource.ancestors.should be_include(Puppet::FileCollection::Lookup)
     end
 
+    it "should get its environment from its scope" do
+        scope = stub 'scope', :source => stub("source")
+        scope.expects(:environment).returns "foo"
+        Puppet::Parser::Resource.new("file", "whatever", :scope => scope).environment.should == "foo"
+    end
+
+    it "should get its namespaces from its scope" do
+        scope = stub 'scope', :source => stub("source")
+        scope.expects(:namespaces).returns %w{one two}
+        Puppet::Parser::Resource.new("file", "whatever", :scope => scope).namespaces.should == %w{one two}
+    end
+
     it "should be isomorphic if it is builtin and models an isomorphic type" do
         Puppet::Type.type(:file).expects(:isomorphic?).returns(true)
-        @resource = Puppet::Parser::Resource.new(:type => "file", :title => "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
+        @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
     end
 
     it "should not be isomorphic if it is builtin and models a non-isomorphic type" do
         Puppet::Type.type(:file).expects(:isomorphic?).returns(false)
-        @resource = Puppet::Parser::Resource.new(:type => "file", :title => "whatever", :scope => @scope, :source => @source).isomorphic?.should be_false
+        @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source).isomorphic?.should be_false
     end
 
     it "should be isomorphic if it is not builtin" do
         newdefine "whatever"
-        @resource = Puppet::Parser::Resource.new(:type => "whatever", :title => "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
+        @resource = Puppet::Parser::Resource.new("whatever", "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
     end
 
     it "should have a array-indexing method for retrieving parameter values" do
@@ -89,77 +101,68 @@ describe Puppet::Parser::Resource do
     end
 
     it "should be able to use the indexing operator to access parameters" do
-        resource = Puppet::Parser::Resource.new(:type => "resource", :title => "testing", :source => "source", :scope => "scope")
+        resource = Puppet::Parser::Resource.new("resource", "testing", :source => "source", :scope => "scope")
         resource["foo"] = "bar"
         resource["foo"].should == "bar"
     end
 
     it "should return the title when asked for a parameter named 'title'" do
-        Puppet::Parser::Resource.new(:type => "resource", :title => "testing", :source => "source", :scope => "scope")[:title].should == "testing"
+        Puppet::Parser::Resource.new("resource", "testing", :source => "source", :scope => "scope")[:title].should == "testing"
     end
 
     describe "when initializing" do
         before do
-            @arguments = {:type => "resource", :title => "testing", :scope => stub('scope', :source => mock('source'))}
+            @arguments = {:scope => stub('scope', :source => mock('source'))}
         end
 
-        [:type, :title, :scope].each do |name|
-            it "should fail unless #{name.to_s} is specified" do
-                try = @arguments.dup
-                try.delete(name)
-                lambda { Puppet::Parser::Resource.new(try) }.should raise_error(ArgumentError)
-            end
+        it "should fail unless #{name.to_s} is specified" do
+            lambda { Puppet::Parser::Resource.new('file', '/my/file') }.should raise_error(ArgumentError)
         end
 
         it "should set the reference correctly" do
-            res = Puppet::Parser::Resource.new(@arguments)
+            res = Puppet::Parser::Resource.new("resource", "testing", @arguments)
             res.ref.should == "Resource[testing]"
         end
 
         it "should be tagged with user tags" do
             tags = [ "tag1", "tag2" ]
             @arguments[:params] = [ param(:tag, tags , :source) ]
-            res = Puppet::Parser::Resource.new(@arguments)
+            res = Puppet::Parser::Resource.new("resource", "testing", @arguments)
             (res.tags & tags).should == tags
         end
     end
 
     describe "when refering to a resource with name canonicalization" do
         before do
-            @arguments = {:type => "file", :title => "/path/", :scope => stub('scope', :source => mock('source'))}
+            @arguments = {:scope => stub('scope', :source => mock('source'))}
         end
 
         it "should canonicalize its own name" do
-            res = Puppet::Parser::Resource.new(@arguments)
+            res = Puppet::Parser::Resource.new("file", "/path/", @arguments)
             res.ref.should == "File[/path]"
         end
     end
 
     describe "when evaluating" do
-        before do
-            @type = Puppet::Parser::Resource
-
-            @definition = newdefine "mydefine"
-            @class = newclass "myclass"
-            @nodedef = newnode("mynode")
-        end
-
         it "should evaluate the associated AST definition" do
-            res = @type.new(:type => "mydefine", :title => "whatever", :scope => @scope, :source => @source)
-            @definition.expects(:evaluate_code).with(res)
+            definition = newdefine "mydefine"
+            res = Puppet::Parser::Resource.new("mydefine", "whatever", :scope => @scope, :source => @source)
+            definition.expects(:evaluate_code).with(res)
 
             res.evaluate
         end
 
         it "should evaluate the associated AST class" do
-            res = @type.new(:type => "class", :title => "myclass", :scope => @scope, :source => @source)
+            @class = newclass "myclass"
+            res = Puppet::Parser::Resource.new("class", "myclass", :scope => @scope, :source => @source)
             @class.expects(:evaluate_code).with(res)
             res.evaluate
         end
 
         it "should evaluate the associated AST node" do
-            res = @type.new(:type => "node", :title => "mynode", :scope => @scope, :source => @source)
-            @nodedef.expects(:evaluate_code).with(res)
+            nodedef = newnode("mynode")
+            res = Puppet::Parser::Resource.new("node", "mynode", :scope => @scope, :source => @source)
+            nodedef.expects(:evaluate_code).with(res)
             res.evaluate
         end
     end
@@ -169,7 +172,7 @@ describe Puppet::Parser::Resource do
             @class = newclass "myclass"
             @nodedef = newnode("mynode")
 
-            @resource = Puppet::Parser::Resource.new(:type => "file", :title => "whatever", :scope => @scope, :source => @source)
+            @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source)
         end
 
         it "should do nothing if it has already been finished" do
@@ -292,7 +295,7 @@ describe Puppet::Parser::Resource do
         before do
             @scope_resource = stub 'scope_resource', :tags => %w{srone srtwo}
             @scope = stub 'scope', :resource => @scope_resource
-            @resource = Puppet::Parser::Resource.new(:type => "file", :title => "yay", :scope => @scope, :source => mock('source'))
+            @resource = Puppet::Parser::Resource.new("file", "yay", :scope => @scope, :source => mock('source'))
         end
 
         it "should get tagged with the resource type" do
@@ -304,19 +307,19 @@ describe Puppet::Parser::Resource do
         end
 
         it "should get tagged with each name in the title if the title is a qualified class name" do
-            resource = Puppet::Parser::Resource.new(:type => "file", :title => "one::two", :scope => @scope, :source => mock('source'))
+            resource = Puppet::Parser::Resource.new("file", "one::two", :scope => @scope, :source => mock('source'))
             resource.tags.should be_include("one")
             resource.tags.should be_include("two")
         end
 
         it "should get tagged with each name in the type if the type is a qualified class name" do
-            resource = Puppet::Parser::Resource.new(:type => "one::two", :title => "whatever", :scope => @scope, :source => mock('source'))
+            resource = Puppet::Parser::Resource.new("one::two", "whatever", :scope => @scope, :source => mock('source'))
             resource.tags.should be_include("one")
             resource.tags.should be_include("two")
         end
 
         it "should not get tagged with non-alphanumeric titles" do
-            resource = Puppet::Parser::Resource.new(:type => "file", :title => "this is a test", :scope => @scope, :source => mock('source'))
+            resource = Puppet::Parser::Resource.new("file", "this is a test", :scope => @scope, :source => mock('source'))
             resource.tags.should_not be_include("this is a test")
         end
 
@@ -496,26 +499,26 @@ describe Puppet::Parser::Resource do
             @parser_resource.to_resource.virtual.should be_true
         end
 
-        it "should convert any parser resource references to Puppet::Resource::Reference instances" do
-            ref = Puppet::Parser::Resource::Reference.new(:title => "/my/file", :type => "file")
+        it "should convert any parser resource references to Puppet::Resource instances" do
+            ref = Puppet::Resource.new("file", "/my/file")
             @parser_resource = mkresource :source => @source, :params => {:foo => "bar", :fee => ref}
             result = @parser_resource.to_resource
-            result[:fee].should == Puppet::Resource::Reference.new(:file, "/my/file")
+            result[:fee].should == Puppet::Resource.new(:file, "/my/file")
         end
 
-        it "should convert any parser resource references to Puppet::Resource::Reference instances even if they are in an array" do
-            ref = Puppet::Parser::Resource::Reference.new(:title => "/my/file", :type => "file")
+        it "should convert any parser resource references to Puppet::Resource instances even if they are in an array" do
+            ref = Puppet::Resource.new("file", "/my/file")
             @parser_resource = mkresource :source => @source, :params => {:foo => "bar", :fee => ["a", ref]}
             result = @parser_resource.to_resource
-            result[:fee].should == ["a", Puppet::Resource::Reference.new(:file, "/my/file")]
+            result[:fee].should == ["a", Puppet::Resource.new(:file, "/my/file")]
         end
 
-        it "should convert any parser resource references to Puppet::Resource::Reference instances even if they are in an array of array, and even deeper" do
-            ref1 = Puppet::Parser::Resource::Reference.new(:title => "/my/file1", :type => "file")
-            ref2 = Puppet::Parser::Resource::Reference.new(:title => "/my/file2", :type => "file")
+        it "should convert any parser resource references to Puppet::Resource instances even if they are in an array of array, and even deeper" do
+            ref1 = Puppet::Resource.new("file", "/my/file1")
+            ref2 = Puppet::Resource.new("file", "/my/file2")
             @parser_resource = mkresource :source => @source, :params => {:foo => "bar", :fee => ["a", [ref1,ref2]]}
             result = @parser_resource.to_resource
-            result[:fee].should == ["a", Puppet::Resource::Reference.new(:file, "/my/file1"), Puppet::Resource::Reference.new(:file, "/my/file2")]
+            result[:fee].should == ["a", Puppet::Resource.new(:file, "/my/file1"), Puppet::Resource.new(:file, "/my/file2")]
         end
 
         it "should fail if the same param is declared twice" do
@@ -531,4 +534,52 @@ describe Puppet::Parser::Resource do
             end.should raise_error(Puppet::ParseError)
         end
     end
+
+    describe "when validating" do
+        it "should check each parameter" do
+            resource = Puppet::Parser::Resource.new :foo, "bar", :scope => stub("scope"), :source => stub("source")
+            resource[:one] = :two
+            resource[:three] = :four
+            resource.expects(:validate_parameter).with(:one)
+            resource.expects(:validate_parameter).with(:three)
+            resource.send(:validate)
+        end
+
+        it "should raise a parse error when there's a failure" do
+            resource = Puppet::Parser::Resource.new :foo, "bar", :scope => stub("scope"), :source => stub("source")
+            resource[:one] = :two
+            resource.expects(:validate_parameter).with(:one).raises ArgumentError
+            lambda { resource.send(:validate) }.should raise_error(Puppet::ParseError)
+        end
+    end
+
+    describe "when setting parameters" do
+        before do
+            @source = newclass "foobar"
+            @resource = Puppet::Parser::Resource.new :foo, "bar", :scope => stub("scope"), :source => @source
+        end
+
+        it "should accept Param instances and add them to the parameter list" do
+            param = Puppet::Parser::Resource::Param.new :name => "foo", :value => "bar", :source => @source
+            @resource.set_parameter(param)
+            @resource["foo"].should == "bar"
+        end
+
+        it "should fail when provided a parameter name but no value" do
+            lambda { @resource.set_parameter("myparam") }.should raise_error(ArgumentError)
+        end
+
+        it "should use its source when provided a parameter name and value" do
+            @resource.set_parameter("myparam", "myvalue")
+            @resource["myparam"].should == "myvalue"
+        end
+    end
+
+    # part of #629 -- the undef keyword.  Make sure 'undef' params get skipped.
+    it "should not include 'undef' parameters when converting itself to a hash" do
+        resource = Puppet::Parser::Resource.new "file", "/tmp/testing", :source => mock("source"), :scope => mock("scope")
+        resource[:owner] = :undef
+        resource[:mode] = "755"
+        resource.to_hash[:owner].should be_nil
+    end
 end
diff --git a/spec/unit/parser/resource/reference.rb b/spec/unit/parser/resource/reference.rb
deleted file mode 100755
index a38604226..000000000
--- a/spec/unit/parser/resource/reference.rb
+++ /dev/null
@@ -1,134 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-describe Puppet::Parser::Resource::Reference do
-    before do
-        @type = Puppet::Parser::Resource::Reference
-    end
-
-    it "should get its environment from its scope" do
-        env = stub 'environment'
-        scope = stub 'scope', :environment => env
-        @type.new(:title => "foo", :type => "bar", :scope => scope).environment.should equal(env)
-    end
-
-    it "should use the resource type collection helper to find its known resource types" do
-        Puppet::Parser::Resource::Reference.ancestors.should include(Puppet::Resource::TypeCollectionHelper)
-    end
-
-    it "should use the file lookup module" do
-        Puppet::Parser::Resource::Reference.ancestors.should be_include(Puppet::FileCollection::Lookup)
-    end
-
-    it "should require a type" do
-        proc { @type.new(:title => "yay") }.should raise_error(Puppet::DevError)
-    end
-
-    it "should require a title" do
-        proc { @type.new(:type => "file") }.should raise_error(Puppet::DevError)
-    end
-
-    it "should know when it refers to a builtin type" do
-        ref = @type.new(:type => "file", :title => "/tmp/yay")
-        ref.builtin?.should be_true
-        ref.builtintype.should equal(Puppet::Type.type(:file))
-    end
-
-    it "should return a downcased relationship-style resource reference for defined types" do
-        ref = @type.new(:type => "file", :title => "/tmp/yay")
-        ref.to_ref.should == ["file", "/tmp/yay"]
-    end
-
-    it "should return a capitalized relationship-style resource reference for defined types" do
-        ref = @type.new(:type => "whatever", :title => "/tmp/yay")
-        ref.to_ref.should == ["Whatever", "/tmp/yay"]
-    end
-
-    it "should return a resource reference string when asked" do
-        ref = @type.new(:type => "file", :title => "/tmp/yay")
-        ref.to_s.should == "File[/tmp/yay]"
-    end
-
-    it "should canonize resource reference types" do
-        ref = @type.new(:type => "foo::bar", :title => "/tmp/yay")
-        ref.to_s.should == "Foo::Bar[/tmp/yay]"
-    end
-
-    it "should canonize resource reference values" do
-        ref = @type.new(:type => "file", :title => "/tmp/yay/")
-        ref.to_s.should == "File[/tmp/yay]"
-    end
-
-    it "should canonize resource reference values without order dependencies" do
-        args = [[:title, "/tmp/yay/"], [:type, "file"]]
-        ref = @type.new(args)
-        ref.to_s.should == "File[/tmp/yay]"
-    end
-
-end
-
-describe Puppet::Parser::Resource::Reference, " when modeling defined types" do
-    def newclass(name)
-        @known_resource_types.add Puppet::Resource::Type.new(:hostclass, name)
-    end
-
-    def newdefine(name)
-        @known_resource_types.add Puppet::Resource::Type.new(:definition, name)
-    end
-
-    def newnode(name)
-        @known_resource_types.add Puppet::Resource::Type.new(:node, name)
-    end
-
-    before do
-        @type = Puppet::Parser::Resource::Reference
-
-        @known_resource_types = Puppet::Resource::TypeCollection.new("myenv")
-        @definition = newdefine("mydefine")
-        @class = newclass("myclass")
-        @nodedef = newnode("mynode")
-        @node = Puppet::Node.new("yaynode")
-
-        @compiler = Puppet::Parser::Compiler.new(@node)
-        @compiler.environment.stubs(:known_resource_types).returns @known_resource_types
-    end
-
-    it "should be able to find defined types" do
-        ref = @type.new(:type => "mydefine", :title => "/tmp/yay", :scope => @compiler.topscope)
-        ref.builtin?.should be_false
-        ref.definedtype.should equal(@definition)
-    end
-
-    it "should be able to find classes" do
-        ref = @type.new(:type => "class", :title => "myclass", :scope => @compiler.topscope)
-        ref.builtin?.should be_false
-        ref.definedtype.should equal(@class)
-    end
-
-    it "should be able to find nodes" do
-        ref = @type.new(:type => "node", :title => "mynode", :scope => @compiler.topscope)
-        ref.builtin?.should be_false
-        ref.definedtype.object_id.should  == @nodedef.object_id
-    end
-
-    it "should only look for fully qualified classes" do
-        top = newclass "top"
-        sub = newclass "other::top"
-
-        scope = @compiler.topscope.class.new(:parent => @compiler.topscope, :namespace => "other", :compiler => @compiler)
-
-        ref = @type.new(:type => "class", :title => "top", :scope => scope)
-        ref.definedtype.name.should equal(top.name)
-    end
-
-    it "should only look for fully qualified definitions" do
-        top = newdefine "top"
-        sub = newdefine "other::top"
-
-        scope = @compiler.topscope.class.new(:parent => @compiler.topscope, :namespace => "other", :compiler => @compiler)
-
-        ref = @type.new(:type => "top", :title => "foo", :scope => scope)
-        ref.definedtype.name.should equal(top.name)
-    end
-end
diff --git a/spec/unit/parser/scope.rb b/spec/unit/parser/scope.rb
index 799d05766..3d648fedf 100755
--- a/spec/unit/parser/scope.rb
+++ b/spec/unit/parser/scope.rb
@@ -8,6 +8,7 @@ describe Puppet::Parser::Scope do
         # This is necessary so we don't try to use the compiler to discover our parent.
         @topscope.parent = nil
         @scope = Puppet::Parser::Scope.new()
+        @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
         @scope.parent = @topscope
     end
  
@@ -104,7 +105,7 @@ describe Puppet::Parser::Scope do
 
             def create_class_scope(name)
                 klass = newclass(name)
-                Puppet::Parser::Resource.new(:type => "class", :title => name, :scope => @scope, :source => mock('source')).evaluate
+                Puppet::Parser::Resource.new("class", name, :scope => @scope, :source => mock('source')).evaluate
 
                 return @scope.class_scope(klass)
             end
@@ -315,6 +316,114 @@ describe Puppet::Parser::Scope do
 
             @scope.strinterp('==${10}==').should == "==value=="
         end
+
+        describe "with qualified variables" do
+            before do
+                @scopes = {}
+                klass = @scope.known_resource_types.add(Puppet::Resource::Type.new(:hostclass, ""))
+                Puppet::Parser::Resource.new("class", :main, :scope => @scope, :source => mock('source')).evaluate
+                @scopes[""] = @scope.compiler.class_scope(klass)
+                @scopes[""].setvar("test", "value")
+
+                %w{one one::two one::two::three}.each do |name|
+                    klass = @scope.known_resource_types.add(Puppet::Resource::Type.new(:hostclass, name))
+                    Puppet::Parser::Resource.new("class", name, :scope => @scope, :source => mock('source')).evaluate
+                    @scopes[name] = @scope.compiler.class_scope(klass)
+                    @scopes[name].setvar("test", "value-#{name.sub(/.+::/,'')}")
+                end
+            end
+            {
+                "===${one::two::three::test}===" => "===value-three===",
+                "===$one::two::three::test===" => "===value-three===",
+                "===${one::two::test}===" => "===value-two===",
+                "===$one::two::test===" => "===value-two===",
+                "===${one::test}===" => "===value-one===",
+                "===$one::test===" => "===value-one===",
+                "===${::test}===" => "===value===",
+                "===$::test===" => "===value==="
+            }.each do |input, output|
+                it "should parse '#{input}' correctly" do
+                    @scope.strinterp(input).should == output
+                end
+            end
+        end
+
+        tests = {
+            "===${test}===" => "===value===",
+            "===${test} ${test} ${test}===" => "===value value value===",
+            "===$test ${test} $test===" => "===value value value===",
+            "===\\$test===" => "===$test===",
+            '===\\$test string===' => "===$test string===",
+            '===$test string===' => "===value string===",
+            '===a testing $===' => "===a testing $===",
+            '===a testing \$===' => "===a testing $===",
+            "===an escaped \\\n carriage return===" => "===an escaped  carriage return===",
+            '\$' => "$",
+            '\s' => "\s",
+            '\t' => "\t",
+            '\n' => "\n"
+        }
+
+        tests.each do |input, output|
+            it "should parse '#{input}' correctly" do
+                @scope.setvar("test", "value")
+                @scope.strinterp(input).should == output
+            end
+        end
+
+        # #523
+        %w{d f h l w z}.each do |l|
+            it "should parse '#{l}' when escaped" do
+                string = "\\" + l
+                @scope.strinterp(string).should == string
+            end
+        end
+    end
+
+    def test_strinterp
+        # Make and evaluate our classes so the qualified lookups work
+        parser = mkparser
+        klass = parser.newclass("")
+        scope = mkscope(:parser => parser)
+        Puppet::Parser::Resource.new(:type => "class", :title => :main, :scope => scope, :source => mock('source')).evaluate
+
+        assert_nothing_raised {
+            scope.setvar("test","value")
+        }
+
+        scopes = {"" => scope}
+
+        %w{one one::two one::two::three}.each do |name|
+            klass = parser.newclass(name)
+            Puppet::Parser::Resource.new(:type => "class", :title => name, :scope => scope, :source => mock('source')).evaluate
+            scopes[name] = scope.compiler.class_scope(klass)
+            scopes[name].setvar("test", "value-%s" % name.sub(/.+::/,''))
+        end
+
+        assert_equal("value", scope.lookupvar("::test"), "did not look up qualified value correctly")
+        tests.each do |input, output|
+            assert_nothing_raised("Failed to scan %s" % input.inspect) do
+                assert_equal(output, scope.strinterp(input),
+                    'did not parserret %s correctly' % input.inspect)
+            end
+        end
+
+        logs = []
+        Puppet::Util::Log.close
+        Puppet::Util::Log.newdestination(logs)
+
+        # #523
+        %w{d f h l w z}.each do |l|
+            string = "\\" + l
+            assert_nothing_raised do
+                assert_equal(string, scope.strinterp(string),
+                    'did not parserret %s correctly' % string)
+            end
+
+            assert(logs.detect { |m| m.message =~ /Unrecognised escape/ },
+                "Did not get warning about escape sequence with %s" % string)
+            logs.clear
+        end
     end
 
     describe "when setting ephemeral vars from matches" do
@@ -357,4 +466,50 @@ describe Puppet::Parser::Scope do
             @scope.lookupvar("foo").should == ""
         end
     end
+
+    it "should use its namespaces to find hostclasses" do
+        klass = @scope.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "a::b::c")
+        @scope.add_namespace "a::b"
+        @scope.find_hostclass("c").should equal(klass)
+    end
+
+    it "should use its namespaces to find definitions" do
+        define = @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "a::b::c")
+        @scope.add_namespace "a::b"
+        @scope.find_definition("c").should equal(define)
+    end
+
+    describe "when managing defaults" do
+        it "should be able to set and lookup defaults" do
+            param = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
+            @scope.setdefaults(:mytype, param)
+            @scope.lookupdefaults(:mytype).should == {:myparam => param}
+        end
+
+        it "should fail if a default is already defined and a new default is being defined" do
+            param = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
+            @scope.setdefaults(:mytype, param)
+            lambda { @scope.setdefaults(:mytype, param) }.should raise_error(Puppet::ParseError)
+        end
+
+        it "should return multiple defaults at once" do
+            param1 = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
+            @scope.setdefaults(:mytype, param1)
+            param2 = Puppet::Parser::Resource::Param.new(:name => :other, :value => "myvalue", :source => stub("source"))
+            @scope.setdefaults(:mytype, param2)
+
+            @scope.lookupdefaults(:mytype).should == {:myparam => param1, :other => param2}
+        end
+
+        it "should look up defaults defined in parent scopes" do
+            param1 = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
+            @scope.setdefaults(:mytype, param1)
+
+            child_scope = @scope.newscope
+            param2 = Puppet::Parser::Resource::Param.new(:name => :other, :value => "myvalue", :source => stub("source"))
+            child_scope.setdefaults(:mytype, param2)
+
+            child_scope.lookupdefaults(:mytype).should == {:myparam => param1, :other => param2}
+        end
+    end
 end
diff --git a/spec/unit/rails/param_value.rb b/spec/unit/rails/param_value.rb
index 26e87fec2..070ac82ea 100755
--- a/spec/unit/rails/param_value.rb
+++ b/spec/unit/rails/param_value.rb
@@ -42,7 +42,7 @@ describe "Puppet::Rails::ParamValue" do
         end
 
         it "should not convert Resource References into strings" do
-            ref = Puppet::Resource::Reference.new(:file, "/file")
+            ref = Puppet::Resource.new(:file, "/file")
             Puppet::Rails::ParamValue.from_parser_param(:myparam, ref)[0][:value].should == ref
         end
     end
diff --git a/spec/unit/resource.rb b/spec/unit/resource.rb
index 73bbfd865..c97cd634f 100755
--- a/spec/unit/resource.rb
+++ b/spec/unit/resource.rb
@@ -12,71 +12,89 @@ describe Puppet::Resource do
         end
     end
 
-    describe "when initializing" do
-        it "should require the type and title" do
-            lambda { Puppet::Resource.new }.should raise_error(ArgumentError)
-        end
+    it "should have a :title attribute" do
+        Puppet::Resource.new(:file, "foo").title.should == "foo"
+    end
 
-        it "should create a resource reference with its type and title" do
-            ref = Puppet::Resource::Reference.new("file", "/f")
-            Puppet::Resource::Reference.expects(:new).with("file", "/f").returns ref
-            Puppet::Resource.new("file", "/f")
-        end
+    it "should require the type and title" do
+        lambda { Puppet::Resource.new }.should raise_error(ArgumentError)
+    end
 
-        it "should tag itself with its type" do
-            Puppet::Resource.new("file", "/f").should be_tagged("file")
-        end
+    it "should canonize types to capitalized strings" do
+        Puppet::Resource.new(:file, "foo").type.should == "File"
+    end
 
-        it "should tag itself with its title if the title is a valid tag" do
-            Puppet::Resource.new("file", "bar").should be_tagged("bar")
-        end
+    it "should canonize qualified types so all strings are capitalized" do
+        Puppet::Resource.new("foo::bar", "foo").type.should == "Foo::Bar"
+    end
 
-        it "should not tag itself with its title if the title is a not valid tag" do
-            Puppet::Resource.new("file", "/bar").should_not be_tagged("/bar")
-        end
+    it "should tag itself with its type" do
+        Puppet::Resource.new("file", "/f").should be_tagged("file")
+    end
 
-        it "should allow setting of attributes" do
-            Puppet::Resource.new("file", "/bar", :file => "/foo").file.should == "/foo"
-            Puppet::Resource.new("file", "/bar", :exported => true).should be_exported
-        end
+    it "should tag itself with its title if the title is a valid tag" do
+        Puppet::Resource.new("file", "bar").should be_tagged("bar")
     end
 
-    it "should use the resource reference to determine its type" do
-        ref = Puppet::Resource::Reference.new("file", "/f")
-        Puppet::Resource::Reference.expects(:new).returns ref
-        resource = Puppet::Resource.new("file", "/f")
-        ref.expects(:type).returns "mytype"
-        resource.type.should == "mytype"
+    it "should not tag itself with its title if the title is a not valid tag" do
+        Puppet::Resource.new("file", "/bar").should_not be_tagged("/bar")
     end
 
-    it "should use its resource reference to determine its title" do
-        ref = Puppet::Resource::Reference.new("file", "/f")
-        Puppet::Resource::Reference.expects(:new).returns ref
-        resource = Puppet::Resource.new("file", "/f")
-        ref.expects(:title).returns "mytitle"
-        resource.title.should == "mytitle"
+    it "should allow setting of attributes" do
+        Puppet::Resource.new("file", "/bar", :file => "/foo").file.should == "/foo"
+        Puppet::Resource.new("file", "/bar", :exported => true).should be_exported
     end
 
-    it "should use its resource reference to determine whether it is builtin" do
-        ref = Puppet::Resource::Reference.new("file", "/f")
-        Puppet::Resource::Reference.expects(:new).returns ref
-        resource = Puppet::Resource.new("file", "/f")
-        ref.expects(:builtin_type?).returns "yep"
-        resource.builtin_type?.should == "yep"
+    it "should set its type to 'Class' and its title to the passed title if the passed type is :component and the title has no square brackets in it" do
+        ref = Puppet::Resource.new(:component, "foo")
+        ref.type.should == "Class"
+        ref.title.should == "foo"
     end
 
-    it "should call its builtin_type? method when 'builtin?' is called" do
-        resource = Puppet::Resource.new("file", "/f")
-        resource.expects(:builtin_type?).returns "foo"
-        resource.builtin?.should == "foo"
+    it "should interpret the title as a reference and assign appropriately if the type is :component and the title contains square brackets" do
+        ref = Puppet::Resource.new(:component, "foo::bar[yay]")
+        ref.type.should == "Foo::Bar"
+        ref.title.should == "yay"
     end
 
-    it "should use its resource reference to produce its canonical reference string" do
-        ref = Puppet::Resource::Reference.new("file", "/f")
-        Puppet::Resource::Reference.expects(:new).returns ref
-        resource = Puppet::Resource.new("file", "/f")
-        ref.expects(:to_s).returns "Foo[bar]"
-        resource.ref.should == "Foo[bar]"
+    it "should set the type to 'Class' if it is nil and the title contains no square brackets" do
+        ref = Puppet::Resource.new(nil, "yay")
+        ref.type.should == "Class"
+        ref.title.should == "yay"
+    end
+
+    it "should interpret the title as a reference and assign appropriately if the type is nil and the title contains square brackets" do
+        ref = Puppet::Resource.new(nil, "foo::bar[yay]")
+        ref.type.should == "Foo::Bar"
+        ref.title.should == "yay"
+    end
+
+    it "should interpret the title as a reference and assign appropriately if the type is nil and the title contains nested square brackets" do
+        ref = Puppet::Resource.new(nil, "foo::bar[baz[yay]]")
+        ref.type.should == "Foo::Bar"
+        ref.title.should =="baz[yay]"
+    end
+
+    it "should interpret the type as a reference and assign appropriately if the title is nil and the type contains square brackets" do
+        ref = Puppet::Resource.new("foo::bar[baz]")
+        ref.type.should == "Foo::Bar"
+        ref.title.should =="baz"
+    end
+
+    it "should be able to extract its information from a Puppet::Type instance" do
+        ral = Puppet::Type.type(:file).new :path => "/foo"
+        ref = Puppet::Resource.new(ral)
+        ref.type.should == "File"
+        ref.title.should == "/foo"
+    end
+
+
+    it "should fail if the title is nil and the type is not a valid resource reference string" do
+        lambda { Puppet::Resource.new("foo") }.should raise_error(ArgumentError)
+    end
+
+    it "should be able to produce a backward-compatible reference array" do
+        Puppet::Resource.new("foobar", "/f").to_trans_ref.should == %w{Foobar /f}
     end
 
     it "should be taggable" do
@@ -94,12 +112,16 @@ describe Puppet::Resource do
         Puppet::Resource.new("file", "/my/file", :environment => :foo).environment.name.should == :foo
     end
 
-    it "should support a namespace attribute" do
-        Puppet::Resource.new("file", "/my/file", :namespace => :foo).namespace.should == :foo
+    it "should support specifying namespaces" do
+        Puppet::Resource.new("file", "/my/file", :namespaces => [:foo]).namespaces.should == [:foo]
+    end
+
+    it "should convert namespaces to an array if not specified as one" do
+        Puppet::Resource.new("file", "/my/file", :namespaces => :foo).namespaces.should == [:foo]
     end
 
-    it "should default to a namespace of an empty string" do
-        Puppet::Resource.new("file", "/my/file").namespace.should == ""
+    it "should default to a single amespace of an empty string" do
+        Puppet::Resource.new("file", "/my/file").namespaces.should == [""]
     end
 
     it "should be able to look up its resource type when the type is a builtin resource" do
@@ -130,16 +152,16 @@ describe Puppet::Resource do
         resource.resource_type.should equal(klass)
     end
 
-    it "should use its namespace when looking up defined resource types" do
-        resource = Puppet::Resource.new("bar", "/my/file", :namespace => "foo")
+    it "should use its namespaces when looking up defined resource types" do
+        resource = Puppet::Resource.new("bar", "/my/file", :namespaces => ["foo"])
         type = Puppet::Resource::Type.new(:definition, "foo::bar")
         resource.environment.known_resource_types.add type
 
         resource.resource_type.should equal(type)
     end
 
-    it "should use its namespace when looking up host classes" do
-        resource = Puppet::Resource.new("class", "bar", :namespace => "foo")
+    it "should use its namespaces when looking up host classes" do
+        resource = Puppet::Resource.new("class", "bar", :namespaces => ["foo"])
         type = Puppet::Resource::Type.new(:hostclass, "foo::bar")
         resource.environment.known_resource_types.add type
 
@@ -171,6 +193,30 @@ describe Puppet::Resource do
         resource[:yay] = true
     end
 
+    it "should be considered equivalent to another resource if their type and title match and no parameters are set" do
+        Puppet::Resource.new("file", "/f").should == Puppet::Resource.new("file", "/f")
+    end
+
+    it "should be considered equivalent to another resource if their type, title, and parameters are equal" do
+        Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"}).should == Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"})
+    end
+
+    it "should not be considered equivalent to another resource if their type and title match but parameters are different" do
+        Puppet::Resource.new("file", "/f", :parameters => {:fee => "baz"}).should_not == Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"})
+    end
+
+    it "should not be considered equivalent to a non-resource" do
+        Puppet::Resource.new("file", "/f").should_not == "foo"
+    end
+
+    it "should not be considered equivalent to another resource if their types do not match" do
+        Puppet::Resource.new("file", "/f").should_not == Puppet::Resource.new("exec", "/f")
+    end
+
+    it "should not be considered equivalent to another resource if their titles do not match" do
+        Puppet::Resource.new("file", "/foo").should_not == Puppet::Resource.new("file", "/f")
+    end
+
     describe "when managing parameters" do
         before do
             @resource = Puppet::Resource.new("file", "/my/file")
@@ -305,7 +351,10 @@ describe Puppet::Resource do
         end
 
         it "should set :name to the title if :name is not present for non-builtin types" do
+            krt = Puppet::Resource::TypeCollection.new("myenv")
+            krt.add Puppet::Resource::Type.new(:definition, :foo)
             resource = Puppet::Resource.new :foo, "bar"
+            resource.stubs(:known_resource_types).returns krt
             resource.to_hash[:name].should == "bar"
         end
     end
@@ -334,25 +383,19 @@ describe Puppet::Resource do
     end
 
     describe "when converting to a RAL resource" do
-        before do
-            @resource = Puppet::Resource.new("file", "/my/file")
-            @resource["one"] = "test"
-            @resource["two"] = "other"
-        end
-
-        it "should use the resource type's :create method to create the resource if the resource is of a builtin type" do
-            type = mock 'resource type'
-            type.expects(:new).with(@resource).returns(:myresource)
-            Puppet::Type.expects(:type).with(@resource.type).returns(type)
-            @resource.to_ral.should == :myresource
+        it "should use the resource type's :new method to create the resource if the resource is of a builtin type" do
+            resource = Puppet::Resource.new("file", "/my/file")
+            result = resource.to_ral
+            result.should be_instance_of(Puppet::Type.type(:file))
+            result[:path].should == "/my/file"
         end
 
         it "should convert to a component instance if the resource type is not of a builtin type" do
-            component = mock 'component type'
-            Puppet::Type::Component.expects(:new).with(@resource).returns "meh"
+            resource = Puppet::Resource.new("foobar", "somename")
+            result = resource.to_ral
 
-            Puppet::Type.expects(:type).with(@resource.type).returns(nil)
-            @resource.to_ral.should == "meh"
+            result.should be_instance_of(Puppet::Type.type(:component))
+            result.title.should == "Foobar[somename]"
         end
     end
 
@@ -450,13 +493,13 @@ describe Puppet::Resource do
             end
 
             it "should convert resource references into the backward-compatible form" do
-                @resource[:foo] = Puppet::Resource::Reference.new(:file, "/f")
-                @resource.to_trans["foo"].should == %w{file /f}
+                @resource[:foo] = Puppet::Resource.new(:file, "/f")
+                @resource.to_trans["foo"].should == %w{File /f}
             end
 
             it "should convert resource references into the backward-compatible form even when within arrays" do
-                @resource[:foo] = ["a", Puppet::Resource::Reference.new(:file, "/f")]
-                @resource.to_trans["foo"].should == ["a", %w{file /f}]
+                @resource[:foo] = ["a", Puppet::Resource.new(:file, "/f")]
+                @resource.to_trans["foo"].should == ["a", %w{File /f}]
             end
         end
     end
@@ -618,4 +661,16 @@ describe Puppet::Resource do
             Puppet::Resource.new("file", "/my/file").name.should == "File//my/file"
         end
     end
+
+    describe "when resolving resources with a catalog" do
+        it "should resolve all resources using the catalog" do
+            catalog = mock 'catalog'
+            resource = Puppet::Resource.new("foo::bar", "yay")
+            resource.catalog = catalog
+
+            catalog.expects(:resource).with("Foo::Bar[yay]").returns(:myresource)
+
+            resource.resolve.should == :myresource
+        end
+    end
 end
diff --git a/spec/unit/resource/catalog.rb b/spec/unit/resource/catalog.rb
index e2fe72489..6c6af24ce 100755
--- a/spec/unit/resource/catalog.rb
+++ b/spec/unit/resource/catalog.rb
@@ -109,7 +109,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
         end
 
         def mkresource(type, name)
-            Puppet::Parser::Resource.new(:type => type, :title => name, :source => @source, :scope => @scope)
+            Puppet::Parser::Resource.new(type, name, :source => @source, :scope => @scope)
         end
 
         it "should always create a TransBucket for the 'main' class" do
diff --git a/spec/unit/resource/reference.rb b/spec/unit/resource/reference.rb
deleted file mode 100755
index 7a9704508..000000000
--- a/spec/unit/resource/reference.rb
+++ /dev/null
@@ -1,111 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/resource/reference'
-
-describe Puppet::Resource::Reference do
-    it "should have a :title attribute" do
-        Puppet::Resource::Reference.new(:file, "foo").title.should == "foo"
-    end
-
-    it "should canonize types to capitalized strings" do
-        Puppet::Resource::Reference.new(:file, "foo").type.should == "File"
-    end
-
-    it "should canonize qualified types so all strings are capitalized" do
-        Puppet::Resource::Reference.new("foo::bar", "foo").type.should == "Foo::Bar"
-    end
-
-    it "should set its type to 'Class' and its title to the passed title if the passed type is :component and the title has no square brackets in it" do
-        ref = Puppet::Resource::Reference.new(:component, "foo")
-        ref.type.should == "Class"
-        ref.title.should == "foo"
-    end
-
-    it "should interpret the title as a reference and assign appropriately if the type is :component and the title contains square brackets" do
-        ref = Puppet::Resource::Reference.new(:component, "foo::bar[yay]")
-        ref.type.should == "Foo::Bar"
-        ref.title.should == "yay"
-    end
-
-    it "should set the type to 'Class' if it is nil and the title contains no square brackets" do
-        ref = Puppet::Resource::Reference.new(nil, "yay")
-        ref.type.should == "Class"
-        ref.title.should == "yay"
-    end
-
-    it "should interpret the title as a reference and assign appropriately if the type is nil and the title contains square brackets" do
-        ref = Puppet::Resource::Reference.new(nil, "foo::bar[yay]")
-        ref.type.should == "Foo::Bar"
-        ref.title.should == "yay"
-    end
-
-    it "should interpret the title as a reference and assign appropriately if the type is nil and the title contains nested square brackets" do
-        ref = Puppet::Resource::Reference.new(nil, "foo::bar[baz[yay]]")
-        ref.type.should == "Foo::Bar"
-        ref.title.should =="baz[yay]"
-    end
-
-    it "should interpret the type as a reference and assign appropriately if the title is nil and the type contains square brackets" do
-        ref = Puppet::Resource::Reference.new("foo::bar[baz]")
-        ref.type.should == "Foo::Bar"
-        ref.title.should =="baz"
-    end
-
-    it "should be able to extract its information from a Puppet::Type instance" do
-        ral = Puppet::Type.type(:file).new :path => "/foo"
-        ref = Puppet::Resource::Reference.new(ral)
-        ref.type.should == "File"
-        ref.title.should == "/foo"
-    end
-
-
-    it "should fail if the title is nil and the type is not a valid resource reference string" do
-        lambda { Puppet::Resource::Reference.new("foo") }.should raise_error(ArgumentError)
-    end
-
-    it "should be considered builtin if an existing resource type matches the type" do
-        Puppet::Resource::Reference.new("file", "/f").should be_builtin_type
-    end
-
-    it "should be not considered builtin if an existing resource type does not match the type" do
-        Puppet::Resource::Reference.new("foobar", "/f").should_not be_builtin_type
-    end
-
-    it "should be able to produce a backward-compatible reference array" do
-        Puppet::Resource::Reference.new("foobar", "/f").to_trans_ref.should == %w{Foobar /f}
-    end
-
-    it "should downcase resource types when producing a backward-compatible reference array for builtin resource types" do
-        Puppet::Resource::Reference.new("file", "/f").to_trans_ref.should == %w{file /f}
-    end
-
-    it "should be considered equivalent to another reference if their type and title match" do
-        Puppet::Resource::Reference.new("file", "/f").should == Puppet::Resource::Reference.new("file", "/f")
-    end
-
-    it "should not be considered equivalent to a non-reference" do
-        Puppet::Resource::Reference.new("file", "/f").should_not == "foo"
-    end
-
-    it "should not be considered equivalent to another reference if their types do not match" do
-        Puppet::Resource::Reference.new("file", "/f").should_not == Puppet::Resource::Reference.new("exec", "/f")
-    end
-
-    it "should not be considered equivalent to another reference if their titles do not match" do
-        Puppet::Resource::Reference.new("file", "/foo").should_not == Puppet::Resource::Reference.new("file", "/f")
-    end
-
-    describe "when resolving resources with a catalog" do
-        it "should resolve all resources using the catalog" do
-            config = mock 'catalog'
-            ref = Puppet::Resource::Reference.new("foo::bar", "yay")
-            ref.catalog = config
-
-            config.expects(:resource).with("Foo::Bar[yay]").returns(:myresource)
-
-            ref.resolve.should == :myresource
-        end
-    end
-end
diff --git a/spec/unit/resource/type.rb b/spec/unit/resource/type.rb
index 0a2f447ef..1a19cf4f0 100755
--- a/spec/unit/resource/type.rb
+++ b/spec/unit/resource/type.rb
@@ -456,13 +456,13 @@ describe Puppet::Resource::Type do
         end
 
         it "should fail unless it is a class" do
-            lambda { Puppet::Resource::Type.new(:node, "bar").merge("foo") }.should raise_error(ArgumentError)
+            lambda { Puppet::Resource::Type.new(:node, "bar").merge("foo") }.should raise_error(Puppet::Error)
         end
 
         it "should fail unless the source instance is a class" do
             dest = Puppet::Resource::Type.new(:hostclass, "bar")
             source = Puppet::Resource::Type.new(:node, "foo")
-            lambda { dest.merge(source) }.should raise_error(ArgumentError)
+            lambda { dest.merge(source) }.should raise_error(Puppet::Error)
         end
 
         it "should fail if both classes have different parent classes" do
@@ -471,7 +471,7 @@ describe Puppet::Resource::Type do
                 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)
+            lambda { code.hostclass("b").merge(code.hostclass("d")) }.should raise_error(Puppet::Error)
         end
 
         it "should copy the other class's parent if it has not parent" do
diff --git a/spec/unit/resource/type_collection.rb b/spec/unit/resource/type_collection.rb
index 3de5e504b..a2a213f5a 100644
--- a/spec/unit/resource/type_collection.rb
+++ b/spec/unit/resource/type_collection.rb
@@ -64,7 +64,32 @@ describe Puppet::Resource::TypeCollection do
         @code.definition("foo").should equal(define)
     end
 
+    it "should merge new classes with existing classes of the same name" do
+        loader = Puppet::Resource::TypeCollection.new("env")
+        first = Puppet::Resource::Type.new(:hostclass, "foo")
+        second = Puppet::Resource::Type.new(:hostclass, "foo")
+        loader.add first
+        first.expects(:merge).with(second)
+        loader.add(second)
+    end
+
+    it "should remove all nodes, classes, and definitions when cleared" do
+        loader = Puppet::Resource::TypeCollection.new("env")
+        loader.add Puppet::Resource::Type.new(:hostclass, "class")
+        loader.add Puppet::Resource::Type.new(:definition, "define")
+        loader.add Puppet::Resource::Type.new(:node, "node")
+
+        loader.clear
+        loader.hostclass("class").should be_nil
+        loader.definition("define").should be_nil
+        loader.node("node").should be_nil
+    end
+
     %w{hostclass node definition}.each do |data|
+        before do
+            @instance = Puppet::Resource::Type.new(data, "foo")
+        end
+
         it "should have a method for adding a #{data}" do
             Puppet::Resource::TypeCollection.new("env").should respond_to("add_" + data)
         end
@@ -75,10 +100,12 @@ describe Puppet::Resource::TypeCollection do
             loader.send(data, @instance.name).should equal(@instance)
         end
 
-        it "should fail to add a #{data} when one already exists" do
-            loader = Puppet::Resource::TypeCollection.new("env")
-            loader.add @instance
-            lambda { loader.add(@instance) }.should raise_error(Puppet::ParseError)
+        unless data == "hostclass"
+            it "should fail to add a #{data} when one already exists" do
+                loader = Puppet::Resource::TypeCollection.new("env")
+                loader.add @instance
+                lambda { loader.add(@instance) }.should raise_error(Puppet::ParseError)
+            end
         end
 
         it "should return the added #{data}" do
@@ -127,6 +154,13 @@ describe Puppet::Resource::TypeCollection do
             loader.find("namespace", "::foo::bar", :hostclass).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)
+        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")
diff --git a/spec/unit/transportable.rb b/spec/unit/transportable.rb
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/spec/unit/transportable.rb
diff --git a/spec/unit/type.rb b/spec/unit/type.rb
index 73f249faa..b2f4bcbd4 100755
--- a/spec/unit/type.rb
+++ b/spec/unit/type.rb
@@ -464,13 +464,13 @@ describe Puppet::Type::RelationshipMetaparam do
             @metaparam = Puppet::Type.metaparamclass(:require).new :resource => @resource
         end
 
-        it "should accept Puppet::Resource::Reference instances" do
-            ref = Puppet::Resource::Reference.new(:file, "/foo")
+        it "should accept Puppet::Resource instances" do
+            ref = Puppet::Resource.new(:file, "/foo")
             @metaparam.munge(ref)[0].should equal(ref)
         end
 
-        it "should turn any string into a Puppet::Resource::Reference" do
-            @metaparam.munge("File[/ref]")[0].should be_instance_of(Puppet::Resource::Reference)
+        it "should turn any string into a Puppet::Resource" do
+            @metaparam.munge("File[/ref]")[0].should be_instance_of(Puppet::Resource)
         end
     end
 
diff --git a/spec/unit/type/tidy.rb b/spec/unit/type/tidy.rb
index ccec9ed7c..9bee7d700 100755
--- a/spec/unit/type/tidy.rb
+++ b/spec/unit/type/tidy.rb
@@ -390,7 +390,7 @@ describe tidy do
                 "/what/ever/one/subone" => ["/what/ever/one/subone/ssone"]
             }.each do |parent, children|
                 children.each do |child|
-                    ref = Puppet::Resource::Reference.new(:file, child)
+                    ref = Puppet::Resource.new(:file, child)
                     result[parent][:require].find { |req| req.to_s == ref.to_s }.should_not be_nil
                 end
             end
diff --git a/test/language/functions.rb b/test/language/functions.rb
index af0732559..70605f8f6 100755
--- a/test/language/functions.rb
+++ b/test/language/functions.rb
@@ -289,16 +289,12 @@ class TestLangFunctions < Test::Unit::TestCase
 
         Puppet[:code] = %{file { "#{file}": content => template("#{template}") }}
         Puppet[:environment] = "yay"
-        interp = Puppet::Parser::Interpreter.new
         node = mknode
-        node.stubs(:environment).returns("yay")
+        node.stubs(:environment).returns Puppet::Node::Environment.new
 
         Puppet[:environment] = "yay"
 
-        catalog = nil
-        assert_nothing_raised {
-            catalog = interp.compile(node)
-        }
+        catalog = Puppet::Parser::Compiler.new(node).compile
 
         version = catalog.version
 
@@ -317,7 +313,7 @@ class TestLangFunctions < Test::Unit::TestCase
             f.puts "new text"
         end
 
-        newversion = interp.compile(node).version
+        newversion = Puppet::Parser::Compiler.new(node).compile.version
 
         assert(version != newversion, "Parse date did not change")
     end
@@ -385,100 +381,6 @@ class TestLangFunctions < Test::Unit::TestCase
             "Did not set function correctly")
     end
 
-    def test_realize
-        scope = mkscope
-        parser = scope.compiler.parser
-
-        realize = Puppet::Parser::Functions.function(:realize)
-
-        # Make a definition
-        parser.newdefine("mytype")
-
-        [%w{file /tmp/virtual}, %w{mytype yay}].each do |type, title|
-            # Make a virtual resource
-            virtual = mkresource(:type => type, :title => title,
-                :virtual => true, :params => {}, :scope => scope)
-
-            scope.compiler.add_resource(scope, virtual)
-
-            ref = Puppet::Parser::Resource::Reference.new(
-                :type => type, :title => title,
-                :scope => scope
-            )
-            # Now call the realize function
-            assert_nothing_raised do
-                scope.function_realize(ref)
-            end
-
-            # Make sure it created a collection
-            assert_equal(1, scope.compiler.collections.length,
-                "Did not set collection")
-
-            assert_nothing_raised do
-                scope.compiler.collections.each do |coll| coll.evaluate end
-            end
-            scope.compiler.collections.clear
-
-            # Now make sure the virtual resource is no longer virtual
-            assert(! virtual.virtual?, "Did not make virtual resource real")
-        end
-
-        # Make sure we puke on any resource that doesn't exist
-        none = Puppet::Parser::Resource::Reference.new(
-            :type => "file", :title => "/tmp/nosuchfile",
-            :scope => scope
-        )
-
-        # The function works
-        assert_nothing_raised do
-            scope.function_realize(none.to_s)
-        end
-
-        # Make sure it created a collection
-        assert_equal(1, scope.compiler.collections.length,
-            "Did not set collection")
-
-        # And the collection has our resource in it
-        assert_equal([none.to_s], scope.compiler.collections[0].resources,
-            "Did not set resources in collection")
-    end
-
-    def test_defined
-        scope = mkscope
-        parser = scope.compiler.parser
-
-        defined = Puppet::Parser::Functions.function(:defined)
-
-        parser.newclass("yayness")
-        parser.newdefine("rahness")
-
-        assert_nothing_raised do
-            assert(scope.function_defined("yayness"), "yayness class was not considered defined")
-            assert(scope.function_defined("rahness"), "rahness definition was not considered defined")
-            assert(scope.function_defined("service"), "service type was not considered defined")
-            assert(! scope.function_defined("fakness"), "fakeness was considered defined")
-        end
-
-        # Now make sure any match in a list will work
-        assert(scope.function_defined(["booness", "yayness", "fakeness"]),
-            "A single answer was not sufficient to return true")
-
-        # and make sure multiple falses are still false
-        assert(! scope.function_defined(%w{no otherno stillno}),
-            "Multiple falses were somehow true")
-
-        # Now make sure we can test resources
-        scope.compiler.add_resource(scope, mkresource(:type => "file", :title => "/tmp/rahness",
-            :scope => scope, :source => scope.source,
-            :params => {:owner => "root"}))
-
-        yep = Puppet::Parser::Resource::Reference.new(:type => "file", :title => "/tmp/rahness")
-        nope = Puppet::Parser::Resource::Reference.new(:type => "file", :title => "/tmp/fooness")
-
-        assert(scope.function_defined([yep]), "valid resource was not considered defined")
-        assert(! scope.function_defined([nope]), "invalid resource was considered defined")
-    end
-
     def test_search
         parser = mkparser
         scope = mkscope(:parser => parser)
@@ -503,7 +405,7 @@ class TestLangFunctions < Test::Unit::TestCase
 
     def test_include
         scope = mkscope
-        parser = scope.compiler.parser
+        parser = mkparser
 
         include = Puppet::Parser::Functions.function(:include)
 
@@ -569,7 +471,7 @@ class TestLangFunctions < Test::Unit::TestCase
         generate = Puppet::Parser::Functions.function(:generate)
 
         scope = mkscope
-        parser = scope.compiler.parser
+        parser = mkparser
 
         val = nil
         assert_nothing_raised("Could not call generator with no args") do
diff --git a/test/language/parser.rb b/test/language/parser.rb
index a3311f423..b721490c3 100755
--- a/test/language/parser.rb
+++ b/test/language/parser.rb
@@ -18,8 +18,14 @@ class TestParser < Test::Unit::TestCase
         #@lexer = Puppet::Parser::Lexer.new()
     end
 
+    def teardown
+        super
+        Puppet::Node::Environment.clear
+    end
+
     def test_each_file
         textfiles { |file|
+            Puppet::Node::Environment.clear
             parser = mkparser
             Puppet.debug("parsing %s" % file) if __FILE__ == $0
             assert_nothing_raised() {
@@ -379,9 +385,7 @@ file { "/tmp/yayness":
         assert_instance_of(Puppet::Parser::AST::IfStatement, ret)
         parser = mkparser
         str2 = %{if true { #{exec.call("true")} } else { #{exec.call("false")} }}
-        assert_nothing_raised {
-            ret = parser.parse(str2).hostclass("").code[0]
-        }
+        ret = parser.parse(str2).hostclass("").code[0]
         assert_instance_of(Puppet::Parser::AST::IfStatement, ret)
         assert_instance_of(Puppet::Parser::AST::Else, ret.else)
     end
@@ -410,7 +414,7 @@ file { "/tmp/yayness":
         }
         sub = parser.hostclass("container::one")
         assert(sub, "Could not find one")
-        assert_equal("container::deep::sub", sub.parentclass)
+        assert_equal("container::deep::sub", sub.parent)
 
         # Finally, try including a qualified class
         assert_nothing_raised("Could not include fully qualified class") {
@@ -435,7 +439,7 @@ file { "/tmp/yayness":
         assert_nothing_raised do
             out = parser.parse "Exec { path => '/usr/bin:/usr/sbin' }"
             assert_instance_of(Puppet::Resource::TypeCollection, out)
-            assert_equal("", parser.hostclass("").classname)
+            assert_equal("", parser.hostclass("").name)
             assert_equal("", parser.hostclass("").namespace)
         end
     end
@@ -520,6 +524,7 @@ file { "/tmp/yayness":
         end
 
         tests.each do |form|
+            Puppet::Node::Environment.clear
             parser = mkparser
 
             if form == :virtual
@@ -549,6 +554,7 @@ file { "/tmp/yayness":
 
     def test_collectionexpressions
         %w{== !=}.each do |oper|
+            Puppet::Node::Environment.clear
             str = "File <| title #{oper} '/tmp/testing' |>"
 
             parser = mkparser
@@ -616,30 +622,6 @@ file { "/tmp/yayness":
         end
     end
 
-    # We've had problems with files other than site.pp importing into main.
-    def test_importing_into_main
-        top = tempfile()
-        other = tempfile()
-        File.open(top, "w") do |f|
-            f.puts "import '#{other}'"
-        end
-
-        file = tempfile()
-        File.open(other, "w") do |f|
-            f.puts "file { '#{file}': ensure => present }"
-        end
-
-        Puppet[:manifest] = top
-        interp = Puppet::Parser::Interpreter.new
-
-        code = nil
-        assert_nothing_raised do
-            code = interp.compile(mknode).extract.flatten
-        end
-        assert(code.length == 1, "Did not get the file")
-        assert_instance_of(Puppet::TransObject, code[0])
-    end
-
     def test_fully_qualified_definitions
         parser = mkparser
 
@@ -803,196 +785,10 @@ file { "/tmp/yayness":
         end
         assert_instance_of(Puppet::Resource::TypeCollection, result, "Did not get a ASTSet back from parsing")
 
-        assert_instance_of(AST::HostClass, result.hostclass("yay"), "Did not create 'yay' class")
-        assert_instance_of(AST::HostClass, result.hostclass(""), "Did not create main class")
-        assert_instance_of(AST::Definition, result.definition("bar"), "Did not create 'bar' definition")
-        assert_instance_of(AST::Node, result.node("foo"), "Did not create 'foo' node")
-    end
-
-    # Make sure our node gets added to the node table.
-    def test_newnode
-        parser = mkparser
-
-        # First just try calling it directly
-        assert_nothing_raised {
-            parser.newnode("mynode", :code => :yay)
-        }
-
-        assert_equal(:yay, parser.node("mynode").code)
-
-        # Now make sure that trying to redefine it throws an error.
-        assert_raise(Puppet::ParseError) {
-            parser.newnode("mynode", {})
-        }
-
-        # Now try one with no code
-        assert_nothing_raised {
-            parser.newnode("simplenode", :parent => :foo)
-        }
-
-        # Now define the parent node
-        parser.newnode(:foo)
-
-        # And make sure we get things back correctly
-        assert_equal(:foo, parser.node("simplenode").parentclass)
-        assert_nil(parser.node("simplenode").code)
-
-        # Now make sure that trying to redefine it throws an error.
-        assert_raise(Puppet::ParseError) {
-            parser.newnode("mynode", {})
-        }
-
-        # Test multiple names
-        names = ["one", "two", "three"]
-        assert_nothing_raised {
-            parser.newnode(names, {:code => :yay, :parent => :foo})
-        }
-
-        names.each do |name|
-            assert_equal(:yay, parser.node(name).code)
-            assert_equal(:foo, parser.node(name).parentclass)
-            # Now make sure that trying to redefine it throws an error.
-            assert_raise(Puppet::ParseError) {
-                parser.newnode(name, {})
-            }
-        end
-    end
-
-    def test_newdefine
-        parser = mkparser
-
-        assert_nothing_raised {
-            parser.newdefine("mydefine", :code => :yay,
-                :arguments => ["a", stringobj("b")])
-        }
-
-        mydefine = parser.definition("mydefine")
-        assert(mydefine, "Could not find definition")
-        assert_equal("", mydefine.namespace)
-        assert_equal("mydefine", mydefine.classname)
-
-        assert_raise(Puppet::ParseError) do
-            parser.newdefine("mydefine", :code => :yay,
-                :arguments => ["a", stringobj("b")])
-        end
-
-        # Now define the same thing in a different scope
-        assert_nothing_raised {
-            parser.newdefine("other::mydefine", :code => :other,
-                :arguments => ["a", stringobj("b")])
-        }
-        other = parser.definition("other::mydefine")
-        assert(other, "Could not find definition")
-        assert(parser.definition("other::mydefine"),
-            "Could not find other::mydefine")
-        assert_equal(:other, other.code)
-        assert_equal("other", other.namespace)
-        assert_equal("other::mydefine", other.classname)
-    end
-
-    def test_newclass
-        scope = mkscope
-        parser = scope.compiler.parser
-
-        mkcode = proc do |ary|
-            classes = ary.collect do |string|
-                AST::FlatString.new(:value => string)
-            end
-            AST::ASTArray.new(:children => classes)
-        end
-
-
-        # First make sure that code is being appended
-        code = mkcode.call(%w{original code})
-
-        klass = nil
-        assert_nothing_raised {
-            klass = parser.newclass("myclass", :code => code)
-        }
-
-        assert(klass, "Did not return class")
-
-        assert(parser.hostclass("myclass"), "Could not find definition")
-        assert_equal("myclass", parser.hostclass("myclass").classname)
-        assert_equal(%w{original code},
-             parser.hostclass("myclass").code.evaluate(scope))
-
-        # Newclass behaves differently than the others -- it just appends
-        # the code to the existing class.
-        code = mkcode.call(%w{something new})
-        assert_nothing_raised do
-            klass = parser.newclass("myclass", :code => code)
-        end
-        assert(klass, "Did not return class when appending")
-        assert_equal(%w{original code something new},
-            parser.hostclass("myclass").code.evaluate(scope))
-
-        # Now create the same class name in a different scope
-        assert_nothing_raised {
-            klass = parser.newclass("other::myclass",
-                            :code => mkcode.call(%w{something diff}))
-        }
-        assert(klass, "Did not return class")
-        other = parser.hostclass("other::myclass")
-        assert(other, "Could not find class")
-        assert_equal("other::myclass", other.classname)
-        assert_equal("other::myclass", other.namespace)
-        assert_equal(%w{something diff},
-             other.code.evaluate(scope))
-
-        # Make sure newclass deals correctly with nodes with no code
-        klass = parser.newclass("nocode")
-        assert(klass, "Did not return class")
-
-        assert_nothing_raised do
-            klass = parser.newclass("nocode", :code => mkcode.call(%w{yay test}))
-        end
-        assert(klass, "Did not return class with no code")
-        assert_equal(%w{yay test},
-            parser.hostclass("nocode").code.evaluate(scope))
-
-        # Then try merging something into nothing
-        parser.newclass("nocode2", :code => mkcode.call(%w{foo test}))
-        assert(klass, "Did not return class with no code")
-
-        assert_nothing_raised do
-            klass = parser.newclass("nocode2")
-        end
-        assert(klass, "Did not return class with no code")
-        assert_equal(%w{foo test},
-            parser.hostclass("nocode2").code.evaluate(scope))
-
-        # And lastly, nothing and nothing
-        klass = parser.newclass("nocode3")
-        assert(klass, "Did not return class with no code")
-
-        assert_nothing_raised do
-            klass = parser.newclass("nocode3")
-        end
-        assert(klass, "Did not return class with no code")
-        assert_nil(parser.hostclass("nocode3").code)
-    end
-
-    # Make sure you can't have classes and defines with the same name in the
-    # same scope.
-    def test_classes_beat_defines
-        parser = mkparser
-
-        assert_nothing_raised {
-            parser.newclass("yay::funtest")
-        }
-
-        assert_raise(Puppet::ParseError) do
-            parser.newdefine("yay::funtest")
-        end
-
-        assert_nothing_raised {
-            parser.newdefine("yay::yaytest")
-        }
-
-        assert_raise(Puppet::ParseError) do
-            parser.newclass("yay::yaytest")
-        end
+        assert_instance_of(Puppet::Resource::Type, result.hostclass("yay"), "Did not create 'yay' class")
+        assert_instance_of(Puppet::Resource::Type, result.hostclass(""), "Did not create main class")
+        assert_instance_of(Puppet::Resource::Type, result.definition("bar"), "Did not create 'bar' definition")
+        assert_instance_of(Puppet::Resource::Type, result.node("foo"), "Did not create 'foo' node")
     end
 
     def test_namesplit
@@ -1009,50 +805,6 @@ file { "/tmp/yayness":
         end
     end
 
-    # Now make sure we get appropriate behaviour with parent class conflicts.
-    def test_newclass_parentage
-        parser = mkparser
-        parser.newclass("base1")
-        parser.newclass("one::two::three")
-
-        # First create it with no parentclass.
-        assert_nothing_raised {
-            parser.newclass("sub")
-        }
-        assert(parser.hostclass("sub"), "Could not find definition")
-        assert_nil(parser.hostclass("sub").parentclass)
-
-        # Make sure we can't set the parent class to ourself.
-        assert_raise(Puppet::ParseError) {
-            parser.newclass("sub", :parent => "sub")
-        }
-
-        # Now create another one, with a parentclass.
-        assert_nothing_raised {
-            parser.newclass("sub", :parent => "base1")
-        }
-
-        # Make sure we get the right parent class, and make sure it's not an object.
-        assert_equal("base1",
-                    parser.hostclass("sub").parentclass)
-
-        # Now make sure we get a failure if we try to conflict.
-        assert_raise(Puppet::ParseError) {
-            parser.newclass("sub", :parent => "one::two::three")
-        }
-
-        # Make sure that failure didn't screw us up in any way.
-        assert_equal("base1",
-                    parser.hostclass("sub").parentclass)
-        # But make sure we can create a class with a fq parent
-        assert_nothing_raised {
-            parser.newclass("another", :parent => "one::two::three")
-        }
-        assert_equal("one::two::three",
-                    parser.hostclass("another").parentclass)
-
-    end
-
     # Setup a module.
     def mk_module(name, files = {})
         mdir = File.join(@dir, name)
@@ -1095,22 +847,22 @@ file { "/tmp/yayness":
 
         # Try to load the module automatically now
         klass = parser.find_hostclass("", name)
-        assert_instance_of(AST::HostClass, klass, "Did not autoload class from module init file")
-        assert_equal(name, klass.classname, "Incorrect class was returned")
+        assert_instance_of(Puppet::Resource::Type, klass, "Did not autoload class from module init file")
+        assert_equal(name, klass.name, "Incorrect class was returned")
 
         # Try loading the simple module when we're in something other than the base namespace.
         parser = mkparser
         klass = parser.find_hostclass("something::else", name)
-        assert_instance_of(AST::HostClass, klass, "Did not autoload class from module init file")
-        assert_equal(name, klass.classname, "Incorrect class was returned")
+        assert_instance_of(Puppet::Resource::Type, klass, "Did not autoload class from module init file")
+        assert_equal(name, klass.name, "Incorrect class was returned")
 
         # Now try it with a definition as the base file
         name = "simpdef"
         mk_module(name, :define => true, :init => [name])
 
         klass = parser.find_definition("", name)
-        assert_instance_of(AST::Definition, klass, "Did not autoload class from module init file")
-        assert_equal(name, klass.classname, "Incorrect class was returned")
+        assert_instance_of(Puppet::Resource::Type, klass, "Did not autoload class from module init file")
+        assert_equal(name, klass.name, "Incorrect class was returned")
 
         # Now try it with namespace classes where both classes are in the init file
         parser = mkparser
@@ -1120,14 +872,14 @@ file { "/tmp/yayness":
 
         # First try it with a namespace
         klass = parser.find_hostclass("both", name)
-        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from module init file with a namespace")
-        assert_equal("both::sub", klass.classname, "Incorrect class was returned")
+        assert_instance_of(Puppet::Resource::Type, klass, "Did not autoload sub class from module init file with a namespace")
+        assert_equal("both::sub", klass.name, "Incorrect class was returned")
 
         # Now try it using the fully qualified name
         parser = mkparser
         klass = parser.find_hostclass("", "both::sub")
-        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from module init file with no namespace")
-        assert_equal("both::sub", klass.classname, "Incorrect class was returned")
+        assert_instance_of(Puppet::Resource::Type, klass, "Did not autoload sub class from module init file with no namespace")
+        assert_equal("both::sub", klass.name, "Incorrect class was returned")
 
 
         # Now try it with the class in a different file
@@ -1138,14 +890,14 @@ file { "/tmp/yayness":
 
         # First try it with a namespace
         klass = parser.find_hostclass("separate", name)
-        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from separate file with a namespace")
-        assert_equal("separate::sub", klass.classname, "Incorrect class was returned")
+        assert_instance_of(Puppet::Resource::Type, klass, "Did not autoload sub class from separate file with a namespace")
+        assert_equal("separate::sub", klass.name, "Incorrect class was returned")
 
         # Now try it using the fully qualified name
         parser = mkparser
         klass = parser.find_hostclass("", "separate::sub")
-        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from separate file with no namespace")
-        assert_equal("separate::sub", klass.classname, "Incorrect class was returned")
+        assert_instance_of(Puppet::Resource::Type, klass, "Did not autoload sub class from separate file with no namespace")
+        assert_equal("separate::sub", klass.name, "Incorrect class was returned")
 
         # Now make sure we don't get a failure when there's no module file
         parser = mkparser
@@ -1157,22 +909,22 @@ file { "/tmp/yayness":
         assert_nothing_raised("Could not autoload file when module file is missing") do
             klass = parser.find_hostclass("alone", name)
         end
-        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from alone file with a namespace")
-        assert_equal("alone::sub", klass.classname, "Incorrect class was returned")
+        assert_instance_of(Puppet::Resource::Type, klass, "Did not autoload sub class from alone file with a namespace")
+        assert_equal("alone::sub", klass.name, "Incorrect class was returned")
 
         # Now try it using the fully qualified name
         parser = mkparser
         klass = parser.find_hostclass("", "alone::sub")
-        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from alone file with no namespace")
-        assert_equal("alone::sub", klass.classname, "Incorrect class was returned")
+        assert_instance_of(Puppet::Resource::Type, klass, "Did not autoload sub class from alone file with no namespace")
+        assert_equal("alone::sub", klass.name, "Incorrect class was returned")
 
         # and with the definition in its own file
         name = "mymod"
         mk_module(name, :define => true, :mydefine => ["mymod::mydefine"])
 
         klass = parser.find_definition("", "mymod::mydefine")
-        assert_instance_of(AST::Definition, klass, "Did not autoload definition from its own file")
-        assert_equal("mymod::mydefine", klass.classname, "Incorrect definition was returned")
+        assert_instance_of(Puppet::Resource::Type, klass, "Did not autoload definition from its own file")
+        assert_equal("mymod::mydefine", klass.name, "Incorrect definition was returned")
     end
 
     # Make sure class, node, and define methods are case-insensitive
@@ -1191,25 +943,4 @@ file { "/tmp/yayness":
         assert_equal(result, parser.find_definition("", "fUntEst"),
             "%s was not matched" % "fUntEst")
     end
-
-    def test_manifests_with_multiple_environments
-        parser = mkparser :environment => "something"
-
-        # We use an exception to cut short the processing to simplify our stubbing
-        #Puppet::Module.expects(:find_manifests).with("test", {:cwd => ".", :environment => "something"}).raises(Puppet::ParseError)
-        Puppet::Parser::Files.expects(:find_manifests).with("test", {:cwd => ".", :environment => "something"}).returns([])
-
-        assert_raise(Puppet::ImportError) do
-            parser.import("test")
-        end
-    end
-
-    def test_watch_file_only_once
-        FileTest.stubs(:exists?).returns(true)
-        parser = mkparser
-        parser.watch_file("doh")
-        parser.watch_file("doh")
-        assert_equal(1, parser.files.select { |name, file| file.file == "doh" }.length, "Length of watched 'doh' files was not 1")
-    end
 end
-
diff --git a/test/language/resource.rb b/test/language/resource.rb
deleted file mode 100755
index c1d116f9e..000000000
--- a/test/language/resource.rb
+++ /dev/null
@@ -1,172 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../lib/puppettest'
-
-require 'puppettest'
-require 'puppettest/resourcetesting'
-
-class TestResource < PuppetTest::TestCase
-    include PuppetTest
-    include PuppetTest::ParserTesting
-    include PuppetTest::ResourceTesting
-    Parser = Puppet::Parser
-    AST = Parser::AST
-    Resource = Puppet::Parser::Resource
-    Reference = Puppet::Parser::Resource::Reference
-
-    def setup
-        super
-        Puppet[:trace] = false
-    end
-
-    def teardown
-        mocha_verify
-    end
-
-    # Make sure we paramcheck our params
-    def test_validate
-        res = mkresource
-        params = res.instance_variable_get("@params")
-        params[:one] = :two
-        params[:three] = :four
-        res.expects(:paramcheck).with(:one)
-        res.expects(:paramcheck).with(:three)
-        res.send(:validate)
-    end
-
-    def test_set_parameter
-        res = mkresource
-        params = res.instance_variable_get("@params")
-
-        # First test the simple case:  It's already a parameter
-        param = stub('param', :name => "pname")
-        param.expects(:is_a?).with(Resource::Param).returns(true)
-        res.send(:set_parameter, param)
-        assert_equal(param, params["pname"], "Parameter was not added to hash")
-
-        # Now the case where there's no value but it's not a param
-        param = mock('param')
-        param.expects(:is_a?).with(Resource::Param).returns(false)
-        assert_raise(ArgumentError, "Did not fail when a non-param was passed") do
-            res.send(:set_parameter, param)
-        end
-
-        # and the case where a value is passed in
-        param = stub :name => "pname", :value => "whatever"
-        Resource::Param.expects(:new).with(:name => "pname", :value => "myvalue", :source => res.source).returns(param)
-        res.send(:set_parameter, "pname", "myvalue")
-        assert_equal(param, params["pname"], "Did not put param in hash")
-    end
-
-    def test_paramcheck
-        # There are three cases here:
-
-        # It's a valid parameter
-        res = mkresource
-        ref = mock('ref')
-        res.instance_variable_set("@ref", ref)
-        klass = mock("class")
-        ref.expects(:typeclass).returns(klass).times(4)
-        klass.expects(:valid_parameter?).with("good").returns(true)
-        assert(res.send(:paramcheck, :good), "Did not allow valid param")
-
-        # It's name or title
-        klass.expects(:valid_parameter?).with("name").returns(false)
-        assert(res.send(:paramcheck, :name), "Did not allow name")
-        klass.expects(:valid_parameter?).with("title").returns(false)
-        assert(res.send(:paramcheck, :title), "Did not allow title")
-
-        # It's not actually allowed
-        klass.expects(:valid_parameter?).with("other").returns(false)
-        res.expects(:fail)
-        ref.expects(:type)
-        res.send(:paramcheck, :other)
-    end
-
-    def test_evaluate
-        # First try the most common case, we're not a builtin type.
-        res = mkresource
-        ref = res.instance_variable_get("@ref")
-        type = mock("type")
-        ref.expects(:definedtype).returns(type)
-        res.expects(:finish)
-        res.scope = mock("scope")
-
-        type.expects(:evaluate_code).with(res)
-
-        res.evaluate
-    end
-
-    def test_proxymethods
-        res = Parser::Resource.new :type => "evaltest", :title => "yay",
-            :source => mock("source"), :scope => mkscope
-
-        assert_equal("Evaltest", res.type)
-        assert_equal("yay", res.title)
-        assert_equal(false, res.builtin?)
-    end
-
-    # This is a bit of a weird one -- the user should not actually know
-    # that components exist, so we want references to act like they're not
-    # builtin
-    def test_components_are_not_builtin
-        ref = Parser::Resource::Reference.new(:type => "component", :title => "yay")
-
-        assert_nil(ref.builtintype, "Definition was considered builtin")
-    end
-
-    # The second part of #539 - make sure resources pass the arguments
-    # correctly.
-    def test_title_with_definitions
-        parser = mkparser
-        define = parser.newdefine "yayness",
-            :code => resourcedef("file", "/tmp",
-                "owner" => varref("name"), "mode" => varref("title"))
-
-
-        klass = parser.find_hostclass("", "")
-        should = {:name => :owner, :title => :mode}
-        [
-        {:name => "one", :title => "two"},
-        {:title => "three"},
-        ].each do |hash|
-            config = mkcompiler parser
-            args = {:type => "yayness", :title => hash[:title],
-                :source => klass, :scope => config.topscope}
-            if hash[:name]
-                args[:params] = {:name => hash[:name]}
-            else
-                args[:params] = {} # override the defaults
-            end
-
-            res = nil
-            assert_nothing_raised("Could not create res with %s" % hash.inspect) do
-                res = mkresource(args)
-            end
-            assert_nothing_raised("Could not eval res with %s" % hash.inspect) do
-                res.evaluate
-            end
-
-            made = config.topscope.findresource("File[/tmp]")
-            assert(made, "Did not create resource with %s" % hash.inspect)
-            should.each do |orig, param|
-                assert_equal(hash[orig] || hash[:title], made[param],
-                    "%s was not set correctly with %s" % [param, hash.inspect])
-            end
-        end
-    end
-
-    # part of #629 -- the undef keyword.  Make sure 'undef' params get skipped.
-    def test_undef_and_to_hash
-        res = mkresource :type => "file", :title => "/tmp/testing",
-            :source => mock("source"), :scope => mkscope,
-            :params => {:owner => :undef, :mode => "755"}
-
-        hash = nil
-        assert_nothing_raised("Could not convert resource with undef to hash") do
-            hash = res.to_hash
-        end
-
-        assert_nil(hash[:owner], "got a value for an undef parameter")
-    end
-end
diff --git a/test/language/scope.rb b/test/language/scope.rb
index 8819de66e..b1ba63de4 100755
--- a/test/language/scope.rb
+++ b/test/language/scope.rb
@@ -20,6 +20,11 @@ class TestScope < Test::Unit::TestCase
     include PuppetTest::ParserTesting
     include PuppetTest::ResourceTesting
 
+    def setup
+        Puppet::Node::Environment.clear
+        super
+    end
+
     def to_ary(hash)
         hash.collect { |key,value|
             [key,value]
@@ -102,60 +107,6 @@ class TestScope < Test::Unit::TestCase
         }
     end
 
-    def test_setdefaults
-        config = mkcompiler
-
-        scope = config.topscope
-
-        defaults = scope.instance_variable_get("@defaults")
-
-        # First the case where there are no defaults and we pass a single param
-        param = stub :name => "myparam", :file => "f", :line => "l"
-        scope.setdefaults(:mytype, param)
-        assert_equal({"myparam" => param}, defaults[:mytype], "Did not set default correctly")
-
-        # Now the case where we pass in multiple parameters
-        param1 = stub :name => "one", :file => "f", :line => "l"
-        param2 = stub :name => "two", :file => "f", :line => "l"
-        scope.setdefaults(:newtype, [param1, param2])
-        assert_equal({"one" => param1, "two" => param2}, defaults[:newtype], "Did not set multiple defaults correctly")
-
-        # And the case where there's actually a conflict.  Use the first default for this.
-        newparam = stub :name => "myparam", :file => "f", :line => "l"
-        assert_raise(Puppet::ParseError, "Allowed resetting of defaults") do
-            scope.setdefaults(:mytype, param)
-        end
-        assert_equal({"myparam" => param}, defaults[:mytype], "Replaced default even though there was a failure")
-    end
-
-    def test_lookupdefaults
-        config = mkcompiler
-        top = config.topscope
-
-        # Make a subscope
-        sub = config.newscope(top)
-
-        topdefs = top.instance_variable_get("@defaults")
-        subdefs = sub.instance_variable_get("@defaults")
-
-        # First add some defaults to our top scope
-        topdefs[:t1] = {:p1 => :p2, :p3 => :p4}
-        topdefs[:t2] = {:p5 => :p6}
-
-        # Then the sub scope
-        subdefs[:t1] = {:p1 => :p7, :p8 => :p9}
-        subdefs[:t2] = {:p5 => :p10, :p11 => :p12}
-
-        # Now make sure we get the correct list back
-        result = nil
-        assert_nothing_raised("Could not get defaults") do
-            result = sub.lookupdefaults(:t1)
-        end
-        assert_equal(:p9, result[:p8], "Did not get child defaults")
-        assert_equal(:p4, result[:p3], "Did not override parent defaults with child default")
-        assert_equal(:p7, result[:p1], "Did not get parent defaults")
-    end
-
     def test_parent
         config = mkcompiler
         top = config.topscope
@@ -167,86 +118,6 @@ class TestScope < Test::Unit::TestCase
         assert_equal(top, sub.parent, "Did not find parent scope on second call")
     end
 
-    def test_strinterp
-        # Make and evaluate our classes so the qualified lookups work
-        parser = mkparser
-        klass = parser.newclass("")
-        scope = mkscope(:parser => parser)
-        Puppet::Parser::Resource.new(:type => "class", :title => :main, :scope => scope, :source => mock('source')).evaluate
-
-        assert_nothing_raised {
-            scope.setvar("test","value")
-        }
-
-        scopes = {"" => scope}
-
-        %w{one one::two one::two::three}.each do |name|
-            klass = parser.newclass(name)
-            Puppet::Parser::Resource.new(:type => "class", :title => name, :scope => scope, :source => mock('source')).evaluate
-            scopes[name] = scope.compiler.class_scope(klass)
-            scopes[name].setvar("test", "value-%s" % name.sub(/.+::/,''))
-        end
-
-        assert_equal("value", scope.lookupvar("::test"), "did not look up qualified value correctly")
-        tests = {
-            "string ${test}" => "string value",
-            "string ${one::two::three::test}" => "string value-three",
-            "string $one::two::three::test" => "string value-three",
-            "string ${one::two::test}" => "string value-two",
-            "string $one::two::test" => "string value-two",
-            "string ${one::test}" => "string value-one",
-            "string $one::test" => "string value-one",
-            "string ${::test}" => "string value",
-            "string $::test" => "string value",
-            "string ${test} ${test} ${test}" => "string value value value",
-            "string $test ${test} $test" => "string value value value",
-            "string \\$test" => "string $test",
-            '\\$test string' => "$test string",
-            '$test string' => "value string",
-            'a testing $' => "a testing $",
-            'a testing \$' => "a testing $",
-            "an escaped \\\n carriage return" => "an escaped  carriage return",
-            '\$' => "$",
-            '\s' => "\s",
-            '\t' => "\t",
-            '\n' => "\n"
-        }
-
-        tests.each do |input, output|
-            assert_nothing_raised("Failed to scan %s" % input.inspect) do
-                assert_equal(output, scope.strinterp(input),
-                    'did not parserret %s correctly' % input.inspect)
-            end
-        end
-
-        logs = []
-        Puppet::Util::Log.close
-        Puppet::Util::Log.newdestination(logs)
-
-        # #523
-        %w{d f h l w z}.each do |l|
-            string = "\\" + l
-            assert_nothing_raised do
-                assert_equal(string, scope.strinterp(string),
-                    'did not parserret %s correctly' % string)
-            end
-
-            assert(logs.detect { |m| m.message =~ /Unrecognised escape/ },
-                "Did not get warning about escape sequence with %s" % string)
-            logs.clear
-        end
-    end
-
-    def test_tagfunction
-        Puppet::Parser::Functions.function(:tag)
-        scope = mkscope
-        resource = mock 'resource'
-        scope.resource = resource
-        resource.expects(:tag).with("yayness", "booness")
-
-        scope.function_tag(%w{yayness booness})
-    end
-
     def test_includefunction
         parser = mkparser
         scope = mkscope :parser => parser
@@ -270,7 +141,7 @@ class TestScope < Test::Unit::TestCase
 
         [myclass, otherclass].each do |klass|
             assert(scope.compiler.class_scope(klass),
-                "%s was not set" % klass.classname)
+                "%s was not set" % klass.name)
         end
     end
 
@@ -312,13 +183,14 @@ class TestScope < Test::Unit::TestCase
     # components.
     def test_virtual_definitions_do_not_get_evaluated
         config = mkcompiler
-        parser = config.parser
+        parser = mkparser
 
         # Create a default source
-        config.topscope.source = parser.newclass ""
+        parser.newclass("")
+        config.topscope.source = parser.known_resource_types.hostclass("")
 
         # And a scope resource
-        scope_res = stub 'scope_resource', :virtual? => true, :exported? => false, :tags => [], :builtin? => true, :type => "eh", :title => "bee"
+        scope_res = Puppet::Parser::Resource.new(:file, "/file", :scope => "scope", :source => "source")
         config.topscope.resource = scope_res
 
         args = AST::ASTArray.new(
@@ -374,20 +246,13 @@ include yay
 @@host { puppet: ip => \"192.168.0.3\" }
 Host <<||>>"
 
-        interp = nil
-        assert_nothing_raised {
-            interp = Puppet::Parser::Interpreter.new
-        }
-
         config = nil
         # We run it twice because we want to make sure there's no conflict
         # if we pull it up from the database.
         node = mknode
-        node.parameters = {"hostname" => node.name}
+        node.merge "hostname" => node.name
         2.times { |i|
-            assert_nothing_raised {
-                config = interp.compile(node)
-            }
+            config = Puppet::Parser::Compiler.new(node).compile
 
             flat = config.extract.flatten
 
@@ -418,54 +283,6 @@ Host <<||>>"
             "Did not add extra namespace correctly")
     end
 
-    def test_find_hostclass_and_find_definition
-        parser = mkparser
-
-        # Make sure our scope calls the parser find_hostclass method with
-        # the right namespaces
-        scope = mkscope :parser => parser
-
-        parser.metaclass.send(:attr_accessor, :last)
-
-        methods = [:find_hostclass, :find_definition]
-        methods.each do |m|
-            parser.meta_def(m) do |namespace, name|
-                @checked ||= []
-                @checked << [namespace, name]
-
-                # Only return a value on the last call.
-                if @last == namespace
-                    ret = @checked.dup
-                    @checked.clear
-                    return ret
-                else
-                    return nil
-                end
-            end
-        end
-
-        test = proc do |should|
-            parser.last = scope.namespaces[-1]
-            methods.each do |method|
-                result = scope.send(method, "testing")
-                assert_equal(should, result,
-                    "did not get correct value from %s with namespaces %s" %
-                    [method, scope.namespaces.inspect])
-            end
-        end
-
-        # Start with the empty namespace
-        assert_nothing_raised { test.call([["", "testing"]]) }
-
-        # Now add a namespace
-        scope.add_namespace("a")
-        assert_nothing_raised { test.call([["a", "testing"]]) }
-
-        # And another
-        scope.add_namespace("b")
-        assert_nothing_raised { test.call([["a", "testing"], ["b", "testing"]]) }
-    end
-
     # #629 - undef should be "" or :undef
     def test_lookupvar_with_undef
         scope = mkscope
diff --git a/test/lib/puppettest/parsertesting.rb b/test/lib/puppettest/parsertesting.rb
index dee38eb3a..44c78f2c3 100644
--- a/test/lib/puppettest/parsertesting.rb
+++ b/test/lib/puppettest/parsertesting.rb
@@ -47,9 +47,8 @@ module PuppetTest::ParserTesting
     end
 
     def mkcompiler(parser = nil)
-        parser ||= mkparser
         node = mknode
-        return Compiler.new(node, parser)
+        return Compiler.new(node)
     end
 
     def mknode(name = nil)
@@ -59,12 +58,9 @@ module PuppetTest::ParserTesting
         Puppet::Node.new(name)
     end
 
-    def mkinterp
-        Puppet::Parser::Interpreter.new
-    end
-
-    def mkparser(args = {})
-        Puppet::Parser::Parser.new(args)
+    def mkparser
+        Puppet::Node::Environment.clear
+        Puppet::Parser::Parser.new(Puppet::Node::Environment.new)
     end
 
     def mkscope(hash = {})
@@ -306,13 +302,10 @@ module PuppetTest::ParserTesting
         interp = nil
         oldmanifest = Puppet[:manifest]
         Puppet[:manifest] = manifest
-        assert_nothing_raised {
-            interp = Puppet::Parser::Interpreter.new
-        }
 
         trans = nil
         assert_nothing_raised {
-            trans = interp.compile(mknode)
+            trans = Puppet::Parser::Compiler.new(mknode).compile
         }
 
         config = nil
diff --git a/test/lib/puppettest/resourcetesting.rb b/test/lib/puppettest/resourcetesting.rb
index d4469a203..95fe5bcb7 100644
--- a/test/lib/puppettest/resourcetesting.rb
+++ b/test/lib/puppettest/resourcetesting.rb
@@ -15,9 +15,12 @@ module PuppetTest::ResourceTesting
         args[:source] ||= "source"
         args[:scope] ||= mkscope
 
-        {:type => "resource", :title => "testing",
-            :source => "source", :scope => "scope"}.each do |param, value|
-                args[param] ||= value
+        type = args[:type] || "resource"
+        title = args[:title] || "testing"
+        args.delete(:type)
+        args.delete(:title)
+        {:source => "source", :scope => "scope"}.each do |param, value|
+            args[param] ||= value
         end
 
         params = args[:params] || {:one => "yay", :three => "rah"}
@@ -27,7 +30,7 @@ module PuppetTest::ResourceTesting
             args[:params] = paramify args[:source], params
         end
 
-        Parser::Resource.new(args)
+        Parser::Resource.new(type, title, args)
     end
 
     def param(name, value, source)
diff --git a/test/other/relationships.rb b/test/other/relationships.rb
index b15ff5062..e9d3a9376 100755
--- a/test/other/relationships.rb
+++ b/test/other/relationships.rb
@@ -80,7 +80,7 @@ class TestRelationships < Test::Unit::TestCase
 
     # Testing #411.  It was a problem with builddepends.
     def test_missing_deps
-        file = Puppet::Type.type(:file).new :path => tempfile, :require => Puppet::Resource::Reference.new("file", "/no/such/file")
+        file = Puppet::Type.type(:file).new :path => tempfile, :require => Puppet::Resource.new("file", "/no/such/file")
 
         assert_raise(Puppet::Error) do
             file.builddepends
diff --git a/test/other/transactions.rb b/test/other/transactions.rb
index 94deeab26..6f4f5d913 100755
--- a/test/other/transactions.rb
+++ b/test/other/transactions.rb
@@ -125,12 +125,12 @@ class TestTransactions < Test::Unit::TestCase
         file = Puppet::Type.type(:file).new(:title => "file", :path => path, :content => "yayness")
         first = Puppet::Type.type(:exec).new(:title => "first",
                                      :command => "/bin/echo first > #{firstpath}",
-                                     :subscribe => Puppet::Resource::Reference.new(:file, path),
+                                     :subscribe => Puppet::Resource.new(:file, path),
                                      :refreshonly => true
         )
         second = Puppet::Type.type(:exec).new(:title => "second",
                                      :command => "/bin/echo second > #{secondpath}",
-                                     :subscribe => Puppet::Resource::Reference.new(:exec, "first"),
+                                     :subscribe => Puppet::Resource.new(:exec, "first"),
                                      :refreshonly => true
         )
 
@@ -218,7 +218,7 @@ class TestTransactions < Test::Unit::TestCase
         @@tmpfiles << execfile
 
         # 'subscribe' expects an array of arrays
-        exec[:subscribe] = Puppet::Resource::Reference.new(file.class.name,file.name)
+        exec[:subscribe] = Puppet::Resource.new(file.class.name,file.name)
         exec[:refreshonly] = true
 
         assert_nothing_raised() {
@@ -302,13 +302,13 @@ class TestTransactions < Test::Unit::TestCase
             :path => ENV["PATH"],
             :command => "touch %s" % file1,
             :refreshonly => true,
-            :subscribe => Puppet::Resource::Reference.new(:file, path)
+            :subscribe => Puppet::Resource.new(:file, path)
         )
         exec2 = Puppet::Type.type(:exec).new(
             :path => ENV["PATH"],
             :command => "touch %s" % file2,
             :refreshonly => true,
-            :subscribe => Puppet::Resource::Reference.new(:file, path)
+            :subscribe => Puppet::Resource.new(:file, path)
         )
 
         assert_apply(file, exec1, exec2)
@@ -361,7 +361,7 @@ class TestTransactions < Test::Unit::TestCase
             :name => "touch %s" % fname,
             :path => "/usr/bin:/bin",
             :schedule => "monthly",
-            :subscribe => Puppet::Resource::Reference.new("file", file.name)
+            :subscribe => Puppet::Resource.new("file", file.name)
         )
 
         config = mk_catalog(file, exec)
diff --git a/test/ral/type/exec.rb b/test/ral/type/exec.rb
index c533aff1c..27a3de4d1 100755
--- a/test/ral/type/exec.rb
+++ b/test/ral/type/exec.rb
@@ -181,7 +181,7 @@ class TestExec < Test::Unit::TestCase
 
         exec = Puppet::Type.type(:exec).new(
             :command => oexe,
-            :require => Puppet::Resource::Reference.new(:file, oexe)
+            :require => Puppet::Resource.new(:file, oexe)
         )
 
         comp = mk_catalog("Testing", file, exec)
@@ -404,7 +404,7 @@ class TestExec < Test::Unit::TestCase
                 :path => basedir,
                 :recurse => true,
                 :mode => "755",
-                :require => Puppet::Resource::Reference.new("exec", "mkdir")
+                :require => Puppet::Resource.new("exec", "mkdir")
             )
         }