diff --git a/lib/puppet/parser/ast/leaf.rb b/lib/puppet/parser/ast/leaf.rb
index 64a197492..3efb52f63 100644
--- a/lib/puppet/parser/ast/leaf.rb
+++ b/lib/puppet/parser/ast/leaf.rb
@@ -1,221 +1,222 @@
 class Puppet::Parser::AST
   # The base class for all of the leaves of the parse trees.  These
   # basically just have types and values.  Both of these parameters
   # are simple values, not AST objects.
   class Leaf < AST
     attr_accessor :value, :type
 
     # Return our value.
     def evaluate(scope)
       @value
     end
 
     def match(value)
       @value == value
     end
 
     def to_s
       @value.to_s unless @value.nil?
     end
   end
 
   # The boolean class.  True or false.  Converts the string it receives
   # to a Ruby boolean.
   class Boolean < AST::Leaf
 
     # Use the parent method, but then convert to a real boolean.
     def initialize(hash)
       super
 
       unless @value == true or @value == false
         raise Puppet::DevError,
           "'#{@value}' is not a boolean"
       end
       @value
     end
 
     def to_s
       @value ? "true" : "false"
     end
   end
 
   # The base string class.
   class String < AST::Leaf
     def evaluate(scope)
       @value.dup
     end
 
     def to_s
       "\"#{@value}\""
     end
   end
 
   # An uninterpreted string.
   class FlatString < AST::Leaf
     def evaluate(scope)
       @value
     end
 
     def to_s
       "\"#{@value}\""
     end
   end
 
   class Concat < AST::Leaf
     def evaluate(scope)
       @value.collect { |x| x.evaluate(scope) }.collect{ |x| x == :undef ? '' : x }.join
     end
 
     def to_s
       "#{@value.map { |s| s.to_s.gsub(/^"(.*)"$/, '\1') }.join}"
     end
   end
 
   # The 'default' option on case statements and selectors.
   class Default < AST::Leaf; end
 
   # Capitalized words; used mostly for type-defaults, but also
   # get returned by the lexer any other time an unquoted capitalized
   # word is found.
   class Type < AST::Leaf; end
 
   # Lower-case words.
   class Name < AST::Leaf; end
 
   # double-colon separated class names
   class ClassName < AST::Leaf; end
 
   # undef values; equiv to nil
   class Undef < AST::Leaf; end
 
   # Host names, either fully qualified or just the short name, or even a regex
   class HostName < AST::Leaf
     def initialize(hash)
       super
 
       # Note that this is an AST::Regex, not a Regexp
       @value = @value.to_s.downcase unless @value.is_a?(Regex)
       if @value =~ /[^-\w.]/
         raise Puppet::DevError,
           "'#{@value}' is not a valid hostname"
       end
     end
 
     # implementing eql? and hash so that when an HostName is stored
     # in a hash it has the same hashing properties as the underlying value
     def eql?(value)
       value = value.value if value.is_a?(HostName)
       @value.eql?(value)
     end
 
     def hash
       @value.hash
     end
 
     def to_s
       @value.to_s
     end
   end
 
   # A simple variable.  This object is only used during interpolation;
   # the VarDef class is used for assignment.
   class Variable < Name
     # Looks up the value of the object in the scope tree (does
     # not include syntactical constructs, like '$' and '{}').
     def evaluate(scope)
       parsewrap do
-        if (var = scope[@value, {:file => file, :line => line}]) == :undefined
-          var = :undef
+        if ! scope.include?(@value)
+          :undef
+        else
+          scope[@value, {:file => file, :line => line}]
         end
-        var
       end
     end
 
     def to_s
       "\$#{value}"
     end
   end
 
   class HashOrArrayAccess < AST::Leaf
     attr_accessor :variable, :key
 
     def evaluate_container(scope)
       container = variable.respond_to?(:evaluate) ? variable.safeevaluate(scope) : variable
       (container.is_a?(Hash) or container.is_a?(Array)) ? container : scope[container, {:file => file, :line => line}]
     end
 
     def evaluate_key(scope)
       key.respond_to?(:evaluate) ? key.safeevaluate(scope) : key
     end
 
     def array_index_or_key(object, key)
       if object.is_a?(Array)
         raise Puppet::ParserError, "#{key} is not an integer, but is used as an index of an array" unless key = Puppet::Parser::Scope.number?(key)
       end
       key
     end
 
     def evaluate(scope)
       object = evaluate_container(scope)
       accesskey = evaluate_key(scope)
 
       raise Puppet::ParseError, "#{variable} is not an hash or array when accessing it with #{accesskey}" unless object.is_a?(Hash) or object.is_a?(Array)
 
       object[array_index_or_key(object, accesskey)]
     end
 
     # Assign value to this hashkey or array index
     def assign(scope, value)
       object = evaluate_container(scope)
       accesskey = evaluate_key(scope)
 
       if object.is_a?(Hash) and object.include?(accesskey)
         raise Puppet::ParseError, "Assigning to the hash '#{variable}' with an existing key '#{accesskey}' is forbidden"
       end
 
       # assign to hash or array
       object[array_index_or_key(object, accesskey)] = value
     end
 
     def to_s
       "\$#{variable.to_s}[#{key.to_s}]"
     end
   end
 
   class Regex < AST::Leaf
     def initialize(hash)
       super
       @value = Regexp.new(@value) unless @value.is_a?(Regexp)
     end
 
     # we're returning self here to wrap the regexp and to be used in places
     # where a string would have been used, without modifying any client code.
     # For instance, in many places we have the following code snippet:
     #  val = @val.safeevaluate(@scope)
     #  if val.match(otherval)
     #      ...
     #  end
     # this way, we don't have to modify this test specifically for handling
     # regexes.
     def evaluate(scope)
       self
     end
 
     def evaluate_match(value, scope, options = {})
       value = value.is_a?(String) ? value : value.to_s
 
       if matched = @value.match(value)
         scope.ephemeral_from(matched, options[:file], options[:line])
       end
       matched
     end
 
     def match(value)
       @value.match(value)
     end
 
     def to_s
       "/#{@value.source}/"
     end
   end
 end
diff --git a/lib/puppet/parser/resource.rb b/lib/puppet/parser/resource.rb
index 6b072bd90..56887c357 100644
--- a/lib/puppet/parser/resource.rb
+++ b/lib/puppet/parser/resource.rb
@@ -1,343 +1,344 @@
 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/util/tagging'
   require 'puppet/file_collection/lookup'
   require 'puppet/parser/yaml_trimmer'
   require 'puppet/resource/type_collection_helper'
 
   include Puppet::FileCollection::Lookup
   include Puppet::Resource::TypeCollectionHelper
 
   include Puppet::Util
   include Puppet::Util::MethodHelper
   include Puppet::Util::Errors
   include Puppet::Util::Logging
   include Puppet::Util::Tagging
   include Puppet::Parser::YamlTrimmer
 
   attr_accessor :source, :scope, :rails_id
   attr_accessor :virtual, :override, :translated, :catalog, :evaluated
 
   attr_reader :exported, :parameters
 
   # Determine whether the provided parameter name is a relationship parameter.
   def self.relationship_parameter?(name)
     @relationship_names ||= Puppet::Type.relationship_params.collect { |p| p.name }
     @relationship_names.include?(name)
   end
 
   # Set up some boolean test methods
   def translated?; !!@translated; end
   def override?;   !!@override;   end
   def evaluated?;  !!@evaluated;  end
 
   def [](param)
     param = symbolize(param)
     if param == :title
       return self.title
     end
     if @parameters.has_key?(param)
       @parameters[param].value
     else
       nil
     end
   end
 
   def []=(param, value)
     set_parameter(param, value)
   end
 
   def eachparam
     @parameters.each do |name, param|
       yield param
     end
   end
 
   def environment
     scope.environment
   end
 
   # Process the  stage metaparameter for a class.   A containment edge
   # is drawn from  the class to the stage.   The stage for containment
   # defaults to main, if none is specified.
   def add_edge_to_stage
     return unless self.type.to_s.downcase == "class"
 
     unless stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
       raise ArgumentError, "Could not find stage #{self[:stage] || :main} specified by #{self}"
     end
 
     self[:stage] ||= stage.title unless stage.title == :main
     catalog.add_edge(stage, self)
   end
 
   # Retrieve the associated definition and evaluate it.
   def evaluate
     return if evaluated?
     @evaluated = true
     if klass = resource_type and ! builtin_type?
       finish
       evaluated_code = klass.evaluate_code(self)
       add_edge_to_stage
 
       return evaluated_code
     elsif builtin?
       devfail "Cannot evaluate a builtin type (#{type})"
     else
       self.fail "Cannot find definition #{type}"
     end
   end
 
   # Mark this resource as both exported and virtual,
   # or remove the exported mark.
   def exported=(value)
     if value
       @virtual = true
       @exported = value
     else
       @exported = value
     end
   end
 
   # Do any finishing work on this object, called before evaluation or
   # before storage/translation.
   def finish
     return if finished?
     @finished = true
     add_defaults
     add_metaparams
     add_scope_tags
     validate
   end
 
   # Has this resource already been finished?
   def finished?
     @finished
   end
 
   def initialize(*args)
     raise ArgumentError, "Resources require a scope" unless args.last[:scope]
     super
 
     @source ||= scope.source
   end
 
   # Is this resource modeling an isomorphic resource type?
   def isomorphic?
     if builtin_type?
       return resource_type.isomorphic?
     else
       return true
     end
   end
 
   # Merge an override resource in.  This will throw exceptions if
   # any overrides aren't allowed.
   def merge(resource)
     # Test the resource scope, to make sure the resource is even allowed
     # to override.
     unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
       raise Puppet::ParseError.new("Only subclasses can override parameters", resource.line, resource.file)
     end
     # Some of these might fail, but they'll fail in the way we want.
     resource.parameters.each do |name, param|
       override_parameter(param)
     end
   end
 
   # Unless we're running >= 0.25, we're in compat mode.
   def metaparam_compatibility_mode?
     ! (catalog and ver = (catalog.client_version||'0.0.0').split(".") and (ver[0] > "0" or ver[1].to_i >= 25))
   end
 
   def name
     self[:name] || self.title
   end
 
   # A temporary occasion, until I get paths in the scopes figured out.
   def path
     to_s
   end
 
   # Define a parameter in our resource.
   # if we ever receive a parameter named 'tag', set
   # the resource tags with its value.
   def set_parameter(param, value = nil)
     if ! value.nil?
       param = Puppet::Parser::Resource::Param.new(
         :name => param, :value => value, :source => self.source
       )
     elsif ! param.is_a?(Puppet::Parser::Resource::Param)
       raise ArgumentError, "Received incomplete information - no value provided for parameter #{param}"
     end
 
     tag(*param.value) if param.name == :tag
 
     # And store it in our parameter hash.
     @parameters[param.name] = param
   end
 
   def to_hash
     @parameters.inject({}) do |hash, ary|
       param = ary[1]
       # Skip "undef" values.
       hash[param.name] = param.value if param.value != :undef
       hash
     end
   end
 
 
   # Create a Puppet::Resource instance from this parser resource.
   # We plan, at some point, on not needing to do this conversion, but
   # it's sufficient for now.
   def to_resource
     result = Puppet::Resource.new(type, title)
 
     to_hash.each do |p, v|
       if v.is_a?(Puppet::Resource)
         v = Puppet::Resource.new(v.type, v.title)
       elsif v.is_a?(Array)
         # flatten resource references arrays
         v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
         v = v.collect do |av|
           av = Puppet::Resource.new(av.type, av.title) if av.is_a?(Puppet::Resource)
           av
         end
       end
 
       # If the value is an array with only one value, then
       # convert it to a single value.  This is largely so that
       # the database interaction doesn't have to worry about
       # whether it returns an array or a string.
       result[p] = if v.is_a?(Array) and v.length == 1
         v[0]
           else
             v
               end
     end
 
     result.file = self.file
     result.line = self.line
     result.exported = self.exported
     result.virtual = self.virtual
     result.tag(*self.tags)
 
     result
   end
 
   # Translate our object to a transportable object.
   def to_trans
     return nil if virtual?
 
     to_resource.to_trans
   end
 
   # Convert this resource to a RAL resource.  We hackishly go via the
   # transportable stuff.
   def to_ral
     to_resource.to_ral
   end
 
   private
 
   # Add default values from our definition.
   def add_defaults
     scope.lookupdefaults(self.type).each do |name, param|
       unless @parameters.include?(name)
         self.debug "Adding default for #{name}"
 
         @parameters[name] = param.dup
       end
     end
   end
 
   def add_backward_compatible_relationship_param(name)
     # Skip metaparams for which we get no value.
-    return unless val = scope[name.to_s] and val != :undefined
+    return unless scope.include?(name.to_s)
+    val = scope[name.to_s]
 
     # The default case: just set the value
     set_parameter(name, val) and return unless @parameters[name]
 
     # For relationship params, though, join the values (a la #446).
     @parameters[name].value = [@parameters[name].value, val].flatten
   end
 
   # Add any metaparams defined in our scope. This actually adds any metaparams
   # from any parent scope, and there's currently no way to turn that off.
   def add_metaparams
     compat_mode = metaparam_compatibility_mode?
 
     Puppet::Type.eachmetaparam do |name|
       next unless self.class.relationship_parameter?(name)
       add_backward_compatible_relationship_param(name) if compat_mode
     end
   end
 
   def add_scope_tags
     if scope_resource = scope.resource
       tag(*scope_resource.tags)
     end
   end
 
   # Accept a parameter from an override.
   def override_parameter(param)
     # This can happen if the override is defining a new parameter, rather
     # than replacing an existing one.
     (set_parameter(param) and return) unless current = @parameters[param.name]
 
     # The parameter is already set.  Fail if they're not allowed to override it.
     unless param.source.child_of?(current.source)
       puts caller if Puppet[:trace]
       msg = "Parameter '#{param.name}' is already set on #{self}"
       msg += " by #{current.source}" if current.source.to_s != ""
       if current.file or current.line
         fields = []
         fields << current.file if current.file
         fields << current.line.to_s if current.line
         msg += " at #{fields.join(":")}"
       end
       msg += "; cannot redefine"
       raise Puppet::ParseError.new(msg, param.line, param.file)
     end
 
     # If we've gotten this far, we're allowed to override.
 
     # Merge with previous value, if the parameter was generated with the +>
     # syntax.  It's important that we use a copy of the new param instance
     # here, not the old one, and not the original new one, so that the source
     # is registered correctly for later overrides but the values aren't
     # implcitly shared when multiple resources are overrriden at once (see
     # ticket #3556).
     if param.add
       param = param.dup
       param.value = [current.value, param.value].flatten
     end
 
     set_parameter(param)
   end
 
   # Make sure the resource's parameters are all valid for the type.
   def validate
     @parameters.each do |name, param|
       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
       self.fail Puppet::ParseError, "Duplicate parameter '#{param.name}' for on #{self}" if @parameters[param.name]
 
       set_parameter(param)
     end
   end
 end
diff --git a/lib/puppet/parser/scope.rb b/lib/puppet/parser/scope.rb
index 3a87f964b..9d84c7e65 100644
--- a/lib/puppet/parser/scope.rb
+++ b/lib/puppet/parser/scope.rb
@@ -1,463 +1,467 @@
 # The scope class, which handles storing and retrieving variables and types and
 # such.
 
 require 'puppet/parser/parser'
 require 'puppet/parser/templatewrapper'
 require 'puppet/transportable'
 require 'strscan'
 
 require 'puppet/resource/type_collection_helper'
 
 class Puppet::Parser::Scope
   include Puppet::Resource::TypeCollectionHelper
   require 'puppet/parser/resource'
 
   AST = Puppet::Parser::AST
 
   Puppet::Util.logmethods(self)
 
   include Enumerable
   include Puppet::Util::Errors
   attr_accessor :source, :resource
   attr_accessor :base, :keyword
   attr_accessor :top, :translated, :compiler
   attr_accessor :parent, :dynamic
   attr_reader :namespaces
 
   # thin wrapper around an ephemeral
   # symbol table.
   # when a symbol
   class Ephemeral
     def initialize(parent=nil)
       @symbols = {}
       @parent = parent
     end
 
     [:include?, :delete, :[]=].each do |m|
       define_method(m) do |*args|
         @symbols.send(m, *args)
       end
     end
 
     def [](name)
       unless @symbols.include?(name) or @parent.nil?
         @parent[name]
       else
         @symbols[name]
       end
     end
   end
 
   def [](name, options = {})
     table = ephemeral?(name) ? @ephemeral.last : @symtable
     # If the variable is qualified, then find the specified scope and look the variable up there instead.
     if name =~ /^(.*)::(.+)$/
       begin
         qualified_scope($1)[$2,options]
       rescue RuntimeError => e
         location = (options[:file] && options[:line]) ? " at #{options[:file]}:#{options[:line]}" : ''
         warning "Could not look up qualified variable '#{name}'; #{e.message}#{location}"
-        :undefined
+        nil
       end
     elsif ephemeral_include?(name) or table.include?(name)
       # We can't use "if table[name]" here because the value might be false
       if options[:dynamic] and self != compiler.topscope
         location = (options[:file] && options[:line]) ? " at #{options[:file]}:#{options[:line]}" : ''
         Puppet.deprecation_warning "Dynamic lookup of $#{name}#{location} is deprecated.  Support will be removed in Puppet 2.8.  Use a fully-qualified variable name (e.g., $classname::variable) or parameterized classes."
       end
       table[name]
     elsif parent
       parent[name,options.merge(:dynamic => (dynamic || options[:dynamic]))]
     else
-      :undefined
+      nil
     end
   end
 
   def []=(var, value)
     setvar(var, value)
   end
 
   # A demeterific shortcut to the catalog.
   def catalog
     compiler.catalog
   end
 
   def each
     to_hash.each { |name, value| yield(name, value) }
   end
 
   # Proxy accessors
   def host
     @compiler.node.name
   end
 
   def include?(name)
-    self[name] != :undefined
+    ! self[name].nil?
   end
 
   # Is the value true?  This allows us to control the definition of truth
   # in one place.
   def self.true?(value)
     (value != false and value != "" and value != :undef)
   end
 
   # Is the value a number?, return the correct object or nil if not a number
   def self.number?(value)
     return nil unless value.is_a?(Fixnum) or value.is_a?(Bignum) or value.is_a?(Float) or value.is_a?(String)
 
     if value.is_a?(String)
       if value =~ /^-?\d+(:?\.\d+|(:?\.\d+)?e\d+)$/
         return value.to_f
       elsif value =~ /^0x[0-9a-f]+$/i
         return value.to_i(16)
       elsif value =~ /^0[0-7]+$/
         return value.to_i(8)
       elsif value =~ /^-?\d+$/
         return value.to_i
       else
         return nil
       end
     end
     # it is one of Fixnum,Bignum or Float
     value
   end
 
   # Add to our list of namespaces.
   def add_namespace(ns)
     return false if @namespaces.include?(ns)
     if @namespaces == [""]
       @namespaces = [ns]
     else
       @namespaces << ns
     end
   end
 
   # Remove this when rebasing
   def environment
     compiler ? compiler.environment : Puppet::Node::Environment.new
   end
 
   def find_hostclass(name)
     known_resource_types.find_hostclass(namespaces, name)
   end
 
   def find_definition(name)
     known_resource_types.find_definition(namespaces, name)
   end
 
   def findresource(string, name = nil)
     compiler.findresource(string, name)
   end
 
   # Initialize our new scope.  Defaults to having no parent.
   def initialize(hash = {})
     if hash.include?(:namespace)
       if n = hash[:namespace]
         @namespaces = [n]
       end
       hash.delete(:namespace)
     else
       @namespaces = [""]
     end
     hash.each { |name, val|
       method = name.to_s + "="
       if self.respond_to? method
         self.send(method, val)
       else
         raise Puppet::DevError, "Invalid scope argument #{name}"
       end
     }
 
     extend_with_functions_module
 
     @tags = []
 
     # The symbol table for this scope.  This is where we store variables.
     @symtable = {}
 
     # the ephemeral symbol tables
     # those should not persist long, and are used for the moment only
     # for $0..$xy capture variables of regexes
     # this is actually implemented as a stack, with each ephemeral scope
     # shadowing the previous one
     @ephemeral = [ Ephemeral.new ]
 
     # All of the defaults set for types.  It's a hash of hashes,
     # with the first key being the type, then the second key being
     # the parameter.
     @defaults = Hash.new { |dhash,type|
       dhash[type] = {}
     }
 
     # The table for storing class singletons.  This will only actually
     # be used by top scopes and node scopes.
     @class_scopes = {}
   end
 
   # Store the fact that we've evaluated a class, and store a reference to
   # the scope in which it was evaluated, so that we can look it up later.
   def class_set(name, scope)
     return parent.class_set(name,scope) if parent
     @class_scopes[name] = scope
   end
 
   # Return the scope associated with a class.  This is just here so
   # that subclasses can set their parent scopes to be the scope of
   # their parent class, and it's also used when looking up qualified
   # variables.
   def class_scope(klass)
     # They might pass in either the class or class name
     k = klass.respond_to?(:name) ? klass.name : klass
     @class_scopes[k] || (parent && parent.class_scope(k))
   end
 
   # Collect all of the defaults set at any higher scopes.
   # This is a different type of lookup because it's additive --
   # it collects all of the defaults, with defaults in closer scopes
   # overriding those in later scopes.
   def lookupdefaults(type)
     values = {}
 
     # first collect the values from the parents
     unless parent.nil?
       parent.lookupdefaults(type).each { |var,value|
         values[var] = value
       }
     end
 
     # then override them with any current values
     # this should probably be done differently
     if @defaults.include?(type)
       @defaults[type].each { |var,value|
         values[var] = value
       }
     end
 
     #Puppet.debug "Got defaults for %s: %s" %
     #    [type,values.inspect]
     values
   end
 
   # Look up a defined type.
   def lookuptype(name)
     find_definition(name) || find_hostclass(name)
   end
 
   def undef_as(x,v)
-    (v == :undefined) ? x : (v == :undef) ? x : v
+    if v.nil? or v == :undef
+      x
+    else
+      v
+    end
   end
 
   def qualified_scope(classname)
     raise "class #{classname} could not be found"     unless klass = find_hostclass(classname)
     raise "class #{classname} has not been evaluated" unless kscope = class_scope(klass)
     kscope
   end
 
   private :qualified_scope
 
   # Look up a variable.  The simplest value search we do.
   # This method is effectively deprecated - use self[] instead.
   def lookupvar(name, options = {})
     self[name, options]
   end
 
   # Return a hash containing our variables and their values, optionally (and
   # by default) including the values defined in our parent.  Local values
   # shadow parent values.
   def to_hash(recursive = true)
     target = parent.to_hash(recursive) if recursive and parent
     target ||= Hash.new
     @symtable.keys.each { |name|
       value = @symtable[name]
       if value == :undef
         target.delete(name)
       else
         target[name] = value
       end
     }
     target
   end
 
   def namespaces
     @namespaces.dup
   end
 
   # Create a new scope and set these options.
   def newscope(options = {})
     compiler.newscope(self, options)
   end
 
   def parent_module_name
     return nil unless @parent
     return nil unless @parent.source
     @parent.source.module_name
   end
 
   # Return the list of scopes up to the top scope, ordered with our own first.
   # This is used for looking up variables and defaults.
   def scope_path
     if parent
       [self, parent.scope_path].flatten.compact
     else
       [self]
     end
   end
 
   # Set defaults for a type.  The typename should already be downcased,
   # so that the syntax is isolated.  We don't do any kind of type-checking
   # here; instead we let the resource do it when the defaults are used.
   def setdefaults(type, params)
     table = @defaults[type]
 
     # if we got a single param, it'll be in its own array
     params = [params] unless params.is_a?(Array)
 
     params.each { |param|
       #Puppet.debug "Default for %s is %s => %s" %
       #    [type,ary[0].inspect,ary[1].inspect]
       if table.include?(param.name)
         raise Puppet::ParseError.new("Default already defined for #{type} { #{param.name} }; cannot redefine", param.line, param.file)
       end
       table[param.name] = param
     }
   end
 
   # Set a variable in the current scope.  This will override settings
   # in scopes above, but will not allow variables in the current scope
   # to be reassigned.
   #   It's preferred that you use self[]= instead of this; only use this
   # when you need to set options.
   def setvar(name,value, options = {})
     table = options[:ephemeral] ? @ephemeral.last : @symtable
     if table.include?(name)
       unless options[:append]
         error = Puppet::ParseError.new("Cannot reassign variable #{name}")
       else
         error = Puppet::ParseError.new("Cannot append, variable #{name} is defined in this scope")
       end
       error.file = options[:file] if options[:file]
       error.line = options[:line] if options[:line]
       raise error
     end
 
     unless options[:append]
       table[name] = value
     else # append case
       # lookup the value in the scope if it exists and insert the var
       table[name] = undef_as('',self[name])
       # concatenate if string, append if array, nothing for other types
       case value
       when Array
         table[name] += value
       when Hash
         raise ArgumentError, "Trying to append to a hash with something which is not a hash is unsupported" unless value.is_a?(Hash)
         table[name].merge!(value)
       else
         table[name] << value
       end
     end
   end
 
   # Return the tags associated with this scope.  It's basically
   # just our parents' tags, plus our type.  We don't cache this value
   # because our parent tags might change between calls.
   def tags
     resource.tags
   end
 
   # Used mainly for logging
   def to_s
     "Scope(#{@resource})"
   end
 
   # Undefine a variable; only used for testing.
   def unsetvar(var)
     table = ephemeral?(var) ? @ephemeral.last : @symtable
     table.delete(var) if table.include?(var)
   end
 
   # remove ephemeral scope up to level
   def unset_ephemeral_var(level=:all)
     if level == :all
       @ephemeral = [ Ephemeral.new ]
     else
       (@ephemeral.size - level).times do
         @ephemeral.pop
       end
     end
   end
 
   # check if name exists in one of the ephemeral scope.
   def ephemeral_include?(name)
     @ephemeral.reverse.each do |eph|
       return true if eph.include?(name)
     end
     false
   end
 
   # is name an ephemeral variable?
   def ephemeral?(name)
     name =~ /^\d+$/
   end
 
   def ephemeral_level
     @ephemeral.size
   end
 
   def new_ephemeral
     @ephemeral.push(Ephemeral.new(@ephemeral.last))
   end
 
   def ephemeral_from(match, file = nil, line = nil)
     raise(ArgumentError,"Invalid regex match data") unless match.is_a?(MatchData)
 
     new_ephemeral
 
     setvar("0", match[0], :file => file, :line => line, :ephemeral => true)
     match.captures.each_with_index do |m,i|
       setvar("#{i+1}", m, :file => file, :line => line, :ephemeral => true)
     end
   end
 
   def find_resource_type(type)
     # It still works fine without the type == 'class' short-cut, but it is a lot slower.
     return nil if ["class", "node"].include? type.to_s.downcase
     find_builtin_resource_type(type) || find_defined_resource_type(type)
   end
 
   def find_builtin_resource_type(type)
     Puppet::Type.type(type.to_s.downcase.to_sym)
   end
 
   def find_defined_resource_type(type)
     environment.known_resource_types.find_definition(namespaces, type.to_s.downcase)
   end
 
   def resolve_type_and_titles(type, titles)
     raise ArgumentError, "titles must be an array" unless titles.is_a?(Array)
 
     case type.downcase
     when "class"
       # resolve the titles
       titles = titles.collect do |a_title|
         hostclass = find_hostclass(a_title)
         hostclass ?  hostclass.name : a_title
       end
     when "node"
       # no-op
     else
       # resolve the type
       resource_type = find_resource_type(type)
       type = resource_type.name if resource_type
     end
 
     return [type, titles]
   end
 
   private
 
   def extend_with_functions_module
     extend Puppet::Parser::Functions.environment_module(Puppet::Node::Environment.root)
     extend Puppet::Parser::Functions.environment_module(environment) if environment != Puppet::Node::Environment.root
   end
 end
diff --git a/lib/puppet/parser/templatewrapper.rb b/lib/puppet/parser/templatewrapper.rb
index 83d18cc3f..9336e704d 100644
--- a/lib/puppet/parser/templatewrapper.rb
+++ b/lib/puppet/parser/templatewrapper.rb
@@ -1,115 +1,114 @@
 # A simple wrapper for templates, so they don't have full access to
 # the scope objects.
 require 'puppet/parser/files'
 require 'erb'
 
 class Puppet::Parser::TemplateWrapper
   attr_writer :scope
   attr_reader :file
   attr_accessor :string
   include Puppet::Util
   Puppet::Util.logmethods(self)
 
   def initialize(scope)
     @__scope__ = scope
   end
 
   def scope
     @__scope__
   end
 
   def script_line
     # find which line in the template (if any) we were called from
     (caller.find { |l| l =~ /#{file}:/ }||"")[/:(\d+):/,1]
   end
 
   # Should return true if a variable is defined, false if it is not
   def has_variable?(name)
-    scope[name.to_s, {:file => file, :line => script_line}] != :undefined
+    scope.include?(name.to_s)
   end
 
   # Allow templates to access the defined classes
   def classes
     scope.catalog.classes
   end
 
   # Allow templates to access the tags defined in the current scope
   def tags
     scope.tags
   end
 
   # Allow templates to access the all the defined tags
   def all_tags
     scope.catalog.tags
   end
 
   # Ruby treats variables like methods, so we used to expose variables
   # within scope to the ERB code via method_missing.  As per RedMine #1427,
   # though, this means that conflicts between methods in our inheritance
   # tree (Kernel#fork) and variable names (fork => "yes/no") could arise.
   #
   # Worse, /new/ conflicts could pop up when a new kernel or object method
   # was added to Ruby, causing templates to suddenly fail mysteriously when
   # Ruby was upgraded.
   #
   # To ensure that legacy templates using unqualified names work we retain
   # the missing_method definition here until we declare the syntax finally
   # dead.
   def method_missing(name, *args)
-    value = scope[name.to_s, {:file => file,:line => script_line}]
-    if value != :undefined
-      return value
+    if scope.include?(name.to_s)
+      return scope[name.to_s, {:file => file,:line => script_line}]
     else
       # Just throw an error immediately, instead of searching for
       # other missingmethod things or whatever.
       raise Puppet::ParseError.new("Could not find value for '#{name}'",@file,script_line)
     end
   end
 
   def file=(filename)
     unless @file = Puppet::Parser::Files.find_template(filename, scope.compiler.environment.to_s)
       raise Puppet::ParseError, "Could not find template '#{filename}'"
     end
 
     # We'll only ever not have a parser in testing, but, eh.
     scope.known_resource_types.watch_file(file)
 
     @string = File.read(file)
   end
 
   def result(string = nil)
     if string
       self.string = string
       template_source = "inline template"
     else
       template_source = file
     end
 
     # Expose all the variables in our scope as instance variables of the
     # current object, making it possible to access them without conflict
     # to the regular methods.
     benchmark(:debug, "Bound template variables for #{template_source}") do
       scope.to_hash.each { |name, value|
         if name.kind_of?(String)
           realname = name.gsub(/[^\w]/, "_")
         else
           realname = name
         end
         instance_variable_set("@#{realname}", value)
       }
     end
 
     result = nil
     benchmark(:debug, "Interpolated template #{template_source}") do
       template = ERB.new(self.string, 0, "-")
       template.filename = file
       result = template.result(binding)
     end
 
     result
   end
 
   def to_s
     "template[#{(file ? file : "inline")}]"
   end
 end
diff --git a/spec/unit/parser/scope_spec.rb b/spec/unit/parser/scope_spec.rb
index d3ea8dfa8..3c0d15cd7 100755
--- a/spec/unit/parser/scope_spec.rb
+++ b/spec/unit/parser/scope_spec.rb
@@ -1,514 +1,514 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Parser::Scope do
   before :each do
     @topscope = Puppet::Parser::Scope.new
     # 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
 
   it "should be able to store references to class scopes" do
     lambda { @scope.class_set "myname", "myscope" }.should_not raise_error
   end
 
   it "should be able to retrieve class scopes by name" do
     @scope.class_set "myname", "myscope"
     @scope.class_scope("myname").should == "myscope"
   end
 
   it "should be able to retrieve class scopes by object" do
     klass = mock 'ast_class'
     klass.expects(:name).returns("myname")
     @scope.class_set "myname", "myscope"
     @scope.class_scope(klass).should == "myscope"
   end
 
   it "should be able to retrieve its parent module name from the source of its parent type" do
     @topscope.source = Puppet::Resource::Type.new(:hostclass, :foo, :module_name => "foo")
 
     @scope.parent_module_name.should == "foo"
   end
 
   it "should return a nil parent module name if it has no parent" do
     @topscope.parent_module_name.should be_nil
   end
 
   it "should return a nil parent module name if its parent has no source" do
     @scope.parent_module_name.should be_nil
   end
 
   it "should get its environment from its compiler" do
     env = Puppet::Node::Environment.new
     compiler = stub 'compiler', :environment => env
     scope = Puppet::Parser::Scope.new :compiler => compiler
     scope.environment.should equal(env)
   end
 
   it "should use the default environment if none is available" do
     Puppet::Parser::Scope.new.environment.should equal(Puppet::Node::Environment.new)
   end
 
   it "should use the resource type collection helper to find its known resource types" do
     Puppet::Parser::Scope.ancestors.should include(Puppet::Resource::TypeCollectionHelper)
   end
 
   describe "when initializing" do
     it "should extend itself with its environment's Functions module as well as the default" do
       env = Puppet::Node::Environment.new("myenv")
       root = Puppet::Node::Environment.root
       compiler = stub 'compiler', :environment => env
 
       scope = Puppet::Parser::Scope.new(:compiler => compiler)
       scope.singleton_class.ancestors.should be_include(Puppet::Parser::Functions.environment_module(env))
       scope.singleton_class.ancestors.should be_include(Puppet::Parser::Functions.environment_module(root))
     end
 
     it "should extend itself with the default Functions module if its environment is the default" do
       root = Puppet::Node::Environment.root
       scope = Puppet::Parser::Scope.new
       scope.singleton_class.ancestors.should be_include(Puppet::Parser::Functions.environment_module(root))
     end
 
     it "should remember if it is dynamic" do
       (!!Puppet::Parser::Scope.new(:dynamic => true).dynamic).should == true
     end
 
     it "should assume it is not dynamic" do
       (!Puppet::Parser::Scope.new.dynamic).should == true
     end
   end
 
   describe "when looking up a variable" do
     it "should support :lookupvar and :setvar for backward compatibility" do
       @scope.setvar("var", "yep")
       @scope.lookupvar("var").should == "yep"
     end
 
-    it "should return ':undefined' for unset variables" do
-      @scope["var"].should == :undefined
+    it "should return nil for unset variables" do
+      @scope["var"].should be_nil
     end
 
     it "should be able to look up values" do
       @scope["var"] = "yep"
       @scope["var"].should == "yep"
     end
 
     it "should be able to look up hashes" do
       @scope["var"] = {"a" => "b"}
       @scope["var"].should == {"a" => "b"}
     end
 
     it "should be able to look up variables in parent scopes" do
       @topscope["var"] = "parentval"
       @scope["var"].should == "parentval"
     end
 
     it "should prefer its own values to parent values" do
       @topscope["var"] = "parentval"
       @scope["var"] = "childval"
       @scope["var"].should == "childval"
     end
 
     it "should be able to detect when variables are set" do
       @scope["var"] = "childval"
       @scope.should be_include("var")
     end
 
     it "should be able to detect when variables are not set" do
       @scope.should_not be_include("var")
     end
 
     it "should support iteration over its variables" do
       @scope["one"] = "two"
       @scope["three"] = "four"
       hash = {}
       @scope.each { |name, value| hash[name] = value }
       hash.should == {"one" => "two", "three" => "four" }
     end
 
     it "should include Enumerable" do
       @scope.singleton_class.ancestors.should be_include(Enumerable)
     end
 
     describe "and the variable is qualified" do
       before do
         @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foonode"))
         @scope.compiler = @compiler
         @known_resource_types = @scope.known_resource_types
       end
 
       def newclass(name)
         @known_resource_types.add Puppet::Resource::Type.new(:hostclass, name)
       end
 
       def create_class_scope(name)
         klass = newclass(name)
 
         catalog = Puppet::Resource::Catalog.new
         catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => Puppet::Parser::Scope.new))
 
         Puppet::Parser::Resource.new("class", name, :scope => @scope, :source => mock('source'), :catalog => catalog).evaluate
 
         @scope.class_scope(klass)
       end
 
       it "should be able to look up explicitly fully qualified variables from main" do
         other_scope = create_class_scope("")
 
         other_scope["othervar"] = "otherval"
 
         @scope["::othervar"].should == "otherval"
       end
 
       it "should be able to look up explicitly fully qualified variables from other scopes" do
         other_scope = create_class_scope("other")
 
         other_scope["var"] = "otherval"
 
         @scope["::other::var"].should == "otherval"
       end
 
       it "should be able to look up deeply qualified variables" do
         other_scope = create_class_scope("other::deep::klass")
 
         other_scope["var"] = "otherval"
 
         @scope["other::deep::klass::var"].should == "otherval"
       end
 
-      it "should return ':undefined' for qualified variables that cannot be found in other classes" do
+      it "should return nil for qualified variables that cannot be found in other classes" do
         other_scope = create_class_scope("other::deep::klass")
 
-        @scope["other::deep::klass::var"].should == :undefined
+        @scope["other::deep::klass::var"].should be_nil
       end
 
-      it "should warn and return ':undefined' for qualified variables whose classes have not been evaluated" do
+      it "should warn and return nil for qualified variables whose classes have not been evaluated" do
         klass = newclass("other::deep::klass")
         @scope.expects(:warning)
-        @scope["other::deep::klass::var"].should == :undefined
+        @scope["other::deep::klass::var"].should be_nil
       end
 
-      it "should warn and return ':undefined' for qualified variables whose classes do not exist" do
+      it "should warn and return nil for qualified variables whose classes do not exist" do
         @scope.expects(:warning)
-        @scope["other::deep::klass::var"].should == :undefined
+        @scope["other::deep::klass::var"].should be_nil
       end
 
-      it "should return ':undefined' when asked for a non-string qualified variable from a class that does not exist" do
+      it "should return nil when asked for a non-string qualified variable from a class that does not exist" do
         @scope.stubs(:warning)
-        @scope["other::deep::klass::var"].should == :undefined
+        @scope["other::deep::klass::var"].should be_nil
       end
 
-      it "should return ':undefined' when asked for a non-string qualified variable from a class that has not been evaluated" do
+      it "should return nil when asked for a non-string qualified variable from a class that has not been evaluated" do
         @scope.stubs(:warning)
         klass = newclass("other::deep::klass")
-        @scope["other::deep::klass::var"].should == :undefined
+        @scope["other::deep::klass::var"].should be_nil
       end
     end
   end
 
   describe "when variables are set with append=true" do
     it "should raise an error if the variable is already defined in this scope" do
       @scope.setvar("var","1", :append => false)
       lambda { @scope.setvar("var","1", :append => true) }.should raise_error(Puppet::ParseError)
     end
 
     it "should lookup current variable value" do
       @scope.expects(:[]).with("var").returns("2")
       @scope.setvar("var","1", :append => true)
     end
 
     it "should store the concatenated string '42'" do
       @topscope.setvar("var","4", :append => false)
       @scope.setvar("var","2", :append => true)
       @scope["var"].should == "42"
     end
 
     it "should store the concatenated array [4,2]" do
       @topscope.setvar("var",[4], :append => false)
       @scope.setvar("var",[2], :append => true)
       @scope["var"].should == [4,2]
     end
 
     it "should store the merged hash {a => b, c => d}" do
       @topscope.setvar("var",{"a" => "b"}, :append => false)
       @scope.setvar("var",{"c" => "d"}, :append => true)
       @scope["var"].should == {"a" => "b", "c" => "d"}
     end
 
     it "should raise an error when appending a hash with something other than another hash" do
       @topscope.setvar("var",{"a" => "b"}, :append => false)
       lambda { @scope.setvar("var","not a hash", :append => true) }.should raise_error
     end
   end
 
   describe "when calling number?" do
     it "should return nil if called with anything not a number" do
       Puppet::Parser::Scope.number?([2]).should be_nil
     end
 
     it "should return a Fixnum for a Fixnum" do
       Puppet::Parser::Scope.number?(2).should be_an_instance_of(Fixnum)
     end
 
     it "should return a Float for a Float" do
       Puppet::Parser::Scope.number?(2.34).should be_an_instance_of(Float)
     end
 
     it "should return 234 for '234'" do
       Puppet::Parser::Scope.number?("234").should == 234
     end
 
     it "should return nil for 'not a number'" do
       Puppet::Parser::Scope.number?("not a number").should be_nil
     end
 
     it "should return 23.4 for '23.4'" do
       Puppet::Parser::Scope.number?("23.4").should == 23.4
     end
 
     it "should return 23.4e13 for '23.4e13'" do
       Puppet::Parser::Scope.number?("23.4e13").should == 23.4e13
     end
 
     it "should understand negative numbers" do
       Puppet::Parser::Scope.number?("-234").should == -234
     end
 
     it "should know how to convert exponential float numbers ala '23e13'" do
       Puppet::Parser::Scope.number?("23e13").should == 23e13
     end
 
     it "should understand hexadecimal numbers" do
       Puppet::Parser::Scope.number?("0x234").should == 0x234
     end
 
     it "should understand octal numbers" do
       Puppet::Parser::Scope.number?("0755").should == 0755
     end
 
     it "should return nil on malformed integers" do
       Puppet::Parser::Scope.number?("0.24.5").should be_nil
     end
 
     it "should convert strings with leading 0 to integer if they are not octal" do
       Puppet::Parser::Scope.number?("0788").should == 788
     end
 
     it "should convert strings of negative integers" do
       Puppet::Parser::Scope.number?("-0788").should == -788
     end
 
     it "should return nil on malformed hexadecimal numbers" do
       Puppet::Parser::Scope.number?("0x89g").should be_nil
     end
   end
 
   describe "when using ephemeral variables" do
     it "should store the variable value" do
       @scope.setvar("1", :value, :ephemeral => true)
 
       @scope["1"].should == :value
     end
 
     it "should remove the variable value when unset_ephemeral_var is called" do
       @scope.setvar("1", :value, :ephemeral => true)
       @scope.stubs(:parent).returns(nil)
 
       @scope.unset_ephemeral_var
 
-      @scope["1"].should == :undefined
+      @scope["1"].should be_nil
     end
 
     it "should not remove classic variables when unset_ephemeral_var is called" do
       @scope['myvar'] = :value1
       @scope.setvar("1", :value2, :ephemeral => true)
       @scope.stubs(:parent).returns(nil)
 
       @scope.unset_ephemeral_var
 
       @scope["myvar"].should == :value1
     end
 
     it "should raise an error when setting it again" do
       @scope.setvar("1", :value2, :ephemeral => true)
       lambda { @scope.setvar("1", :value3, :ephemeral => true) }.should raise_error
     end
 
     it "should declare ephemeral number only variable names" do
       @scope.ephemeral?("0").should be_true
     end
 
     it "should not declare ephemeral other variable names" do
       @scope.ephemeral?("abc0").should be_nil
     end
 
     describe "with more than one level" do
       it "should prefer latest ephemeral scopes" do
         @scope.setvar("0", :earliest, :ephemeral => true)
         @scope.new_ephemeral
         @scope.setvar("0", :latest, :ephemeral => true)
         @scope["0"].should == :latest
       end
 
       it "should be able to report the current level" do
         @scope.ephemeral_level.should == 1
         @scope.new_ephemeral
         @scope.ephemeral_level.should == 2
       end
 
       it "should check presence of an ephemeral variable accross multiple levels" do
         @scope.new_ephemeral
         @scope.setvar("1", :value1, :ephemeral => true)
         @scope.new_ephemeral
         @scope.setvar("0", :value2, :ephemeral => true)
         @scope.new_ephemeral
         @scope.ephemeral_include?("1").should be_true
       end
 
       it "should return false when an ephemeral variable doesn't exist in any ephemeral scope" do
         @scope.new_ephemeral
         @scope.setvar("1", :value1, :ephemeral => true)
         @scope.new_ephemeral
         @scope.setvar("0", :value2, :ephemeral => true)
         @scope.new_ephemeral
         @scope.ephemeral_include?("2").should be_false
       end
 
       it "should get ephemeral values from earlier scope when not in later" do
         @scope.setvar("1", :value1, :ephemeral => true)
         @scope.new_ephemeral
         @scope.setvar("0", :value2, :ephemeral => true)
         @scope["1"].should == :value1
       end
 
       describe "when calling unset_ephemeral_var without a level" do
         it "should remove all the variables values"  do
           @scope.setvar("1", :value1, :ephemeral => true)
           @scope.new_ephemeral
           @scope.setvar("1", :value2, :ephemeral => true)
 
           @scope.unset_ephemeral_var
 
-          @scope["1"].should == :undefined
+          @scope["1"].should be_nil
         end
       end
 
       describe "when calling unset_ephemeral_var with a level" do
         it "should remove ephemeral scopes up to this level" do
           @scope.setvar("1", :value1, :ephemeral => true)
           @scope.new_ephemeral
           @scope.setvar("1", :value2, :ephemeral => true)
           @scope.new_ephemeral
           @scope.setvar("1", :value3, :ephemeral => true)
 
           @scope.unset_ephemeral_var(2)
 
           @scope["1"].should == :value2
         end
       end
     end
   end
 
   describe "when setting ephemeral vars from matches" do
     before :each do
       @match = stub 'match', :is_a? => true
       @match.stubs(:[]).with(0).returns("this is a string")
       @match.stubs(:captures).returns([])
       @scope.stubs(:setvar)
     end
 
     it "should accept only MatchData" do
       lambda { @scope.ephemeral_from("match") }.should raise_error
     end
 
     it "should set $0 with the full match" do
       @scope.expects(:setvar).with { |*arg| arg[0] == "0" and arg[1] == "this is a string" and arg[2][:ephemeral] }
 
       @scope.ephemeral_from(@match)
     end
 
     it "should set every capture as ephemeral var" do
       @match.stubs(:captures).returns([:capture1,:capture2])
       @scope.expects(:setvar).with { |*arg| arg[0] == "1" and arg[1] == :capture1 and arg[2][:ephemeral] }
       @scope.expects(:setvar).with { |*arg| arg[0] == "2" and arg[1] == :capture2 and arg[2][:ephemeral] }
 
       @scope.ephemeral_from(@match)
     end
 
     it "should create a new ephemeral level" do
       @scope.expects(:new_ephemeral)
       @scope.ephemeral_from(@match)
     end
   end
 
   describe "when unsetting variables" do
     it "should be able to unset normal variables" do
       @scope["foo"] = "bar"
       @scope.unsetvar("foo")
-      @scope["foo"].should == :undefined
+      @scope["foo"].should be_nil
     end
 
     it "should be able to unset ephemeral variables" do
       @scope.setvar("0", "bar", :ephemeral => true)
       @scope.unsetvar("0")
-      @scope["0"].should == :undefined
+      @scope["0"].should be_nil
     end
 
     it "should not unset ephemeral variables in previous ephemeral scope" do
       @scope.setvar("0", "bar", :ephemeral => true)
       @scope.new_ephemeral
       @scope.unsetvar("0")
       @scope["0"].should == "bar"
     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/test/language/scope.rb b/test/language/scope.rb
index 57824d887..c80178e7b 100755
--- a/test/language/scope.rb
+++ b/test/language/scope.rb
@@ -1,266 +1,266 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../lib/puppettest')
 
 require 'mocha'
 require 'puppettest'
 require 'puppettest/parsertesting'
 require 'puppettest/resourcetesting'
 
 # so, what kind of things do we want to test?
 
 # we don't need to test function, since we're confident in the
 # library tests.  We do, however, need to test how things are actually
 # working in the language.
 
 # so really, we want to do things like test that our ast is correct
 # and test whether we've got things in the right scopes
 
 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]
     }
   end
 
   def test_variables
     config = mkcompiler
     topscope = config.topscope
     midscope = config.newscope(topscope)
     botscope = config.newscope(midscope)
 
     scopes = {:top => topscope, :mid => midscope, :bot => botscope}
 
     # Set a variable in the top and make sure all three can get it
     topscope['first'] = 'topval'
     scopes.each do |name, scope|
       assert_equal("topval", scope['first'], "Could not find var in #{name}")
     end
 
     # Now set a var in the midscope and make sure the mid and bottom can see it but not the top
     midscope['second'] = "midval"
-    assert_equal(:undefined, scopes[:top]['second'], "Found child var in top scope")
+    assert_nil(scopes[:top]['second'], "Found child var in top scope")
     [:mid, :bot].each do |name|
       assert_equal("midval", scopes[name]['second'], "Could not find var in #{name}")
     end
 
     # And set something in the bottom, and make sure we only find it there.
     botscope['third'] = "botval"
     [:top, :mid].each do |name|
-      assert_equal(:undefined, scopes[name]['third'], "Found child var in top scope")
+      assert_nil(scopes[name]['third'], "Found child var in top scope")
     end
     assert_equal("botval", scopes[:bot]['third'], "Could not find var in bottom scope")
 
 
     # Test that the scopes convert to hash structures correctly.
     # For topscope recursive vs non-recursive should be identical
     assert_equal(topscope.to_hash(false), topscope.to_hash(true),
       "Recursive and non-recursive hash is identical for topscope")
 
     # Check the variable we expect is present.
     assert_equal({"first" => "topval"}, topscope.to_hash, "topscope returns the expected hash of variables")
 
     # Now, check that midscope does the right thing in all cases.
 
       assert_equal(
         {"second" => "midval"},
           midscope.to_hash(false),
 
           "midscope non-recursive hash contains only midscope variable")
 
           assert_equal(
             {"first" => "topval", "second" => "midval"},
           midscope.to_hash(true),
 
           "midscope recursive hash contains topscope variable also")
 
     # Finally, check the ability to shadow symbols by adding a shadow to
     # bottomscope, then checking that we see the right stuff.
     botscope['first'] = "shadowval"
 
       assert_equal(
         {"third" => "botval", "first" => "shadowval"},
           botscope.to_hash(false),
 
           "botscope has the right non-recursive hash")
 
           assert_equal(
             {"third" => "botval", "first" => "shadowval", "second" => "midval"},
           botscope.to_hash(true),
 
           "botscope values shadow parent scope values")
   end
 
   def test_declarative
     # set to declarative
     top = mkscope
     sub = mkscope(:parent => top)
 
     assert_nothing_raised {
       top['test'] = "value"
     }
     assert_raise(Puppet::ParseError) {
       top['test'] = 'other'
     }
     assert_nothing_raised {
       top['other'] = 'later'
     }
     assert_raise(Puppet::ParseError) {
       top['other'] = 'yeehaw'
     }
   end
 
   def test_parent
     config = mkcompiler
     top = config.topscope
 
     # Make a subscope
     sub = config.newscope(top)
 
     assert_equal(top, sub.parent, "Did not find parent scope correctly")
     assert_equal(top, sub.parent, "Did not find parent scope on second call")
   end
 
   # Make sure we know what we consider to be truth.
   def test_truth
 
     assert_equal(
       true, Puppet::Parser::Scope.true?("a string"),
 
       "Strings not considered true")
 
         assert_equal(
           true, Puppet::Parser::Scope.true?(true),
 
       "True considered true")
 
         assert_equal(
           false, Puppet::Parser::Scope.true?(""),
 
       "Empty strings considered true")
 
         assert_equal(
           false, Puppet::Parser::Scope.true?(false),
 
       "false considered true")
 
         assert_equal(
           false, Puppet::Parser::Scope.true?(:undef),
 
       "undef considered true")
   end
 
   def test_virtual_definitions_do_not_get_evaluated
     parser = mkparser
     config = mkcompiler
 
     # Create a default source
     parser.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "")
     config.topscope.source = parser.known_resource_types.hostclass("")
 
     # And a scope resource
     scope_res = Puppet::Parser::Resource.new(:file, "/file", :scope => config.topscope)
     config.topscope.resource = scope_res
 
     args = AST::ASTArray.new(
       :children => [nameobj("arg")]
     )
 
     # Create a top-level define
     parser.known_resource_types.add Puppet::Resource::Type.new(:definition, "one", :arguments => [%w{arg}],
       :code => AST::ASTArray.new(
         :children => [
           resourcedef("file", "/tmp", {"owner" => varref("arg")})
         ]
       ))
 
     # create a resource that calls our third define
     obj = resourcedef("one", "boo", {"arg" => "parentfoo"})
 
     # And mark it as virtual
     obj.virtual = true
 
     # And then evaluate it
     obj.evaluate config.topscope
 
     # And run the loop.
     config.send(:evaluate_generators)
 
     %w{File}.each do |type|
       objects = config.resources.find_all { |r| r.type == type and r.virtual }
 
       assert(objects.empty?, "Virtual define got evaluated")
     end
   end
 
   if defined? ::ActiveRecord
   # Verify that we can both store and collect an object in the same
   # run, whether it's in the same scope as a collection or a different
   # scope.
   def test_storeandcollect
     catalog_cache_class = Puppet::Resource::Catalog.indirection.cache_class
     facts_cache_class = Puppet::Node::Facts.indirection.cache_class
     node_cache_class = Puppet::Node.indirection.cache_class
     Puppet[:storeconfigs] = true
     Puppet::Rails.init
     sleep 1
     children = []
     Puppet[:code] = "
 class yay {
   @@host { myhost: ip => \"192.168.0.2\" }
 }
 include yay
 @@host { puppet: ip => \"192.168.0.3\" }
 Host <<||>>"
 
   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.merge "hostname" => node.name
   2.times { |i|
     catalog = Puppet::Parser::Compiler.new(node).compile
     assert_instance_of(Puppet::Parser::Resource, catalog.resource(:host, "puppet"))
     assert_instance_of(Puppet::Parser::Resource, catalog.resource(:host, "myhost"))
     }
   ensure
     Puppet[:storeconfigs] = false
     Puppet::Resource::Catalog.indirection.cache_class =  catalog_cache_class
     Puppet::Node::Facts.indirection.cache_class = facts_cache_class
     Puppet::Node.indirection.cache_class = node_cache_class
   end
   else
     $stderr.puts "No ActiveRecord -- skipping collection tests"
   end
 
   def test_namespaces
     scope = mkscope
 
 
       assert_equal(
         [""], scope.namespaces,
 
       "Started out with incorrect namespaces")
     assert_nothing_raised { scope.add_namespace("fun::test") }
     assert_equal(["fun::test"], scope.namespaces, "Did not add namespace correctly")
     assert_nothing_raised { scope.add_namespace("yay::test") }
     assert_equal(["fun::test", "yay::test"], scope.namespaces, "Did not add extra namespace correctly")
   end
 
   # #629 - undef should be "" or :undef
   def test_lookupvar_with_undef
     scope = mkscope
 
     scope['testing'] = :undef
     assert_equal(:undef, scope['testing'], "undef was not returned as :undef")
   end
 end