diff --git a/lib/puppet/parser/ast/leaf.rb b/lib/puppet/parser/ast/leaf.rb
index 77617e992..b61634d6c 100644
--- a/lib/puppet/parser/ast/leaf.rb
+++ b/lib/puppet/parser/ast/leaf.rb
@@ -1,221 +1,221 @@
 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.lookupvar(@value, false)) == :undefined
+        if (var = scope.lookupvar(@value)) == :undefined
           var = :undef
         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.lookupvar(container)
     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/functions/extlookup.rb b/lib/puppet/parser/functions/extlookup.rb
index b5688d644..5fbf26cec 100644
--- a/lib/puppet/parser/functions/extlookup.rb
+++ b/lib/puppet/parser/functions/extlookup.rb
@@ -1,152 +1,152 @@
 require 'csv'
 
 module Puppet::Parser::Functions
   newfunction(:extlookup,
   :type => :rvalue,
   :doc => "This is a parser function to read data from external files, this version
 uses CSV files but the concept can easily be adjust for databases, yaml
 or any other queryable data source.
 
 The object of this is to make it obvious when it's being used, rather than
 magically loading data in when an module is loaded I prefer to look at the code
 and see statements like:
 
     $snmp_contact = extlookup(\"snmp_contact\")
 
 The above snippet will load the snmp_contact value from CSV files, this in its
 own is useful but a common construct in puppet manifests is something like this:
 
     case $domain {
       \"myclient.com\": { $snmp_contact = \"John Doe <john@myclient.com>\" }
       default:        { $snmp_contact = \"My Support <support@my.com>\" }
     }
 
 Over time there will be a lot of this kind of thing spread all over your manifests
 and adding an additional client involves grepping through manifests to find all the
 places where you have constructs like this.
 
 This is a data problem and shouldn't be handled in code, a using this function you
 can do just that.
 
 First you configure it in site.pp:
 
     $extlookup_datadir = \"/etc/puppet/manifests/extdata\"
     $extlookup_precedence = [\"%{fqdn}\", \"domain_%{domain}\", \"common\"]
 
 The array tells the code how to resolve values, first it will try to find it in
 web1.myclient.com.csv then in domain_myclient.com.csv and finally in common.csv
 
 Now create the following data files in /etc/puppet/manifests/extdata:
 
     domain_myclient.com.csv:
       snmp_contact,John Doe <john@myclient.com>
       root_contact,support@%{domain}
       client_trusted_ips,192.168.1.130,192.168.10.0/24
 
     common.csv:
       snmp_contact,My Support <support@my.com>
       root_contact,support@my.com
 
 Now you can replace the case statement with the simple single line to achieve
 the exact same outcome:
 
    $snmp_contact = extlookup(\"snmp_contact\")
 
 The above code shows some other features, you can use any fact or variable that
 is in scope by simply using %{varname} in your data files, you can return arrays
 by just having multiple values in the csv after the initial variable name.
 
 In the event that a variable is nowhere to be found a critical error will be raised
 that will prevent your manifest from compiling, this is to avoid accidentally putting
 in empty values etc.  You can however specify a default value:
 
    $ntp_servers = extlookup(\"ntp_servers\", \"1.${country}.pool.ntp.org\")
 
 In this case it will default to \"1.${country}.pool.ntp.org\" if nothing is defined in
 any data file.
 
 You can also specify an additional data file to search first before any others at use
 time, for example:
 
     $version = extlookup(\"rsyslog_version\", \"present\", \"packages\")
     package{\"rsyslog\": ensure => $version }
 
 This will look for a version configured in packages.csv and then in the rest as configured
 by $extlookup_precedence if it's not found anywhere it will default to `present`, this kind
 of use case makes puppet a lot nicer for managing large amounts of packages since you do not
 need to edit a load of manifests to do simple things like adjust a desired version number.
 
 Precedence values can have variables embedded in them in the form %{fqdn}, you could for example do:
 
     $extlookup_precedence = [\"hosts/%{fqdn}\", \"common\"]
 
 This will result in /path/to/extdata/hosts/your.box.com.csv being searched.
 
 This is for back compatibility to interpolate variables with %. % interpolation is a workaround for a problem that has been fixed: Puppet variable interpolation at top scope used to only happen on each run.") do |args|
 
   key = args[0]
 
   default  = args[1]
   datafile = args[2]
 
   raise Puppet::ParseError, ("extlookup(): wrong number of arguments (#{args.length}; must be <= 3)") if args.length > 3
 
-  extlookup_datadir = lookupvar('::extlookup_datadir')
+  extlookup_datadir = undef_as('',lookupvar('::extlookup_datadir'))
 
-  extlookup_precedence = lookupvar('::extlookup_precedence').collect { |var| var.gsub(/%\{(.+?)\}/) { lookupvar("::#{$1}") } }
+  extlookup_precedence = undef_as([],lookupvar('::extlookup_precedence')).collect { |var| var.gsub(/%\{(.+?)\}/) { lookupvar("::#{$1}") } }
 
   datafiles = Array.new
 
   # if we got a custom data file, put it first in the array of search files
   if datafile != ""
     datafiles << extlookup_datadir + "/#{datafile}.csv" if File.exists?(extlookup_datadir + "/#{datafile}.csv")
   end
 
   extlookup_precedence.each do |d|
     datafiles << extlookup_datadir + "/#{d}.csv"
   end
 
   desired = nil
 
   datafiles.each do |file|
     if desired.nil?
       if File.exists?(file)
         result = CSV.read(file).find_all do |r|
           r[0] == key
         end
 
         # return just the single result if theres just one,
         # else take all the fields in the csv and build an array
         if result.length > 0
           if result[0].length == 2
             val = result[0][1].to_s
 
             # parse %{}'s in the CSV into local variables using lookupvar()
             while val =~ /%\{(.+?)\}/
               val.gsub!(/%\{#{$1}\}/, lookupvar($1))
             end
 
             desired = val
           elsif result[0].length > 1
             length = result[0].length
             cells = result[0][1,length]
 
             # Individual cells in a CSV result are a weird data type and throws
             # puppets yaml parsing, so just map it all to plain old strings
             desired = cells.map do |c|
               # parse %{}'s in the CSV into local variables using lookupvar()
               while c =~ /%\{(.+?)\}/
                 c.gsub!(/%\{#{$1}\}/, lookupvar($1))
               end
 
               c.to_s
             end
           end
         end
       end
     end
   end
 
   desired || default or raise Puppet::ParseError, "No match found for '#{key}' in any data file during extlookup()"
   end
 end
diff --git a/lib/puppet/parser/resource.rb b/lib/puppet/parser/resource.rb
index c007d4dbe..ace01bb4b 100644
--- a/lib/puppet/parser/resource.rb
+++ b/lib/puppet/parser/resource.rb
@@ -1,326 +1,326 @@
 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
 
   # Retrieve the associated definition and evaluate it.
   def evaluate
     return if evaluated?
     @evaluated = true
     if klass = resource_type and ! builtin_type?
       finish
       return klass.evaluate_code(self)
     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, "Must pass a parameter or all necessary values"
     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.lookupvar(name.to_s, false) and val != :undefined
+    return unless val = scope.lookupvar(name.to_s) and val != :undefined
 
     # 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 07347552b..df307915e 100644
--- a/lib/puppet/parser/scope.rb
+++ b/lib/puppet/parser/scope.rb
@@ -1,511 +1,507 @@
 # 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
   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
 
   # A demeterific shortcut to the catalog.
   def catalog
     compiler.catalog
   end
 
   def environment
     compiler.environment
   end
 
   # Proxy accessors
   def host
     @compiler.node.name
   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.environment
   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 lookup_qualified_var(name, usestring)
+  def undef_as(x,v)
+    (v == :undefined) ? x : (v == :undef) ? x : v
+  end
+
+  def lookup_qualified_var(name)
     parts = name.split(/::/)
     shortname = parts.pop
     klassname = parts.join("::")
     klass = find_hostclass(klassname)
     unless klass
       warning "Could not look up qualified variable '#{name}'; class #{klassname} could not be found"
-      return usestring ? "" : :undefined
+      return :undefined
     end
     unless kscope = class_scope(klass)
       warning "Could not look up qualified variable '#{name}'; class #{klassname} has not been evaluated"
-      return usestring ? "" : :undefined
+      return :undefined
     end
-    kscope.lookupvar(shortname, usestring)
+    kscope.lookupvar(shortname)
   end
 
   private :lookup_qualified_var
 
-  # Look up a variable.  The simplest value search we do.  Default to returning
-  # an empty string for missing values, but support returning a constant.
-  def lookupvar(name, usestring = true)
+  # Look up a variable.  The simplest value search we do.  
+  def lookupvar(name)
     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 =~ /::/
-      return lookup_qualified_var(name, usestring)
-    end
-    # We can't use "if table[name]" here because the value might be false
-    if ephemeral_include?(name) or table.include?(name)
-      if usestring and table[name] == :undef
-        return ""
-      else
-        return table[name]
-      end
-    elsif self.parent
-      return parent.lookupvar(name, usestring)
-    elsif usestring
-      return ""
+      lookup_qualified_var(name)
+    elsif ephemeral_include?(name) or table.include?(name)
+      # We can't use "if table[name]" here because the value might be false
+      table[name]
+    elsif parent
+      parent.lookupvar(name)
     else
-      return :undefined
+      :undefined
     end
   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.
   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] = lookupvar(name)
+      table[name] = undef_as('',lookupvar(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 an interpolated string.
   def strinterp(string, file = nil, line = nil)
     # Most strings won't have variables in them.
     ss = StringScanner.new(string)
     out = ""
     while not ss.eos?
       if ss.scan(/^\$\{((\w*::)*\w+|[0-9]+)\}|^\$([0-9])|^\$((\w*::)*\w+)/)
         # If it matches the backslash, then just retun the dollar sign.
         if ss.matched == '\\$'
           out << '$'
         else # look the variable up
           # make sure $0-$9 are lookupable only if ephemeral
           var = ss[1] || ss[3] || ss[4]
           if var and var =~ /^[0-9]+$/ and not ephemeral_include?(var)
             next
           end
-          out << lookupvar(var).to_s || ""
+          out << undef_as('',lookupvar(var)).to_s
         end
       elsif ss.scan(/^\\(.)/)
         # Puppet.debug("Got escape: pos:%d; m:%s" % [ss.pos, ss.matched])
         case ss[1]
         when 'n'
           out << "\n"
         when 't'
           out << "\t"
         when 's'
           out << " "
         when '\\'
           out << '\\'
         when '$'
           out << '$'
         else
           str = "Unrecognised escape sequence '#{ss.matched}'"
           str += " in file #{file}" if file
           str += " at line #{line}" if line
           Puppet.warning str
           out << ss.matched
         end
       elsif ss.scan(/^\$/)
         out << '$'
       elsif ss.scan(/^\\\n/) # an escaped carriage return
         next
       else
         tmp = ss.scan(/[^\\$]+/)
         # Puppet.debug("Got other: pos:%d; m:%s" % [ss.pos, tmp])
         unless tmp
           error = Puppet::ParseError.new("Could not parse string #{string.inspect}")
           {:file= => file, :line= => line}.each do |m,v|
             error.send(m, v) if v
           end
           raise error
         end
         out << tmp
       end
     end
 
     out
   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(compiler ? environment : nil)
   end
 end
diff --git a/lib/puppet/parser/templatewrapper.rb b/lib/puppet/parser/templatewrapper.rb
index 6864aa1a9..73fcb8aac 100644
--- a/lib/puppet/parser/templatewrapper.rb
+++ b/lib/puppet/parser/templatewrapper.rb
@@ -1,115 +1,109 @@
 # 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
 
   # Should return true if a variable is defined, false if it is not
   def has_variable?(name)
-    if scope.lookupvar(name.to_s, false) != :undefined
-      true
-    else
-      false
-    end
+    scope.lookupvar(name.to_s) != :undefined
   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)
-    # We have to tell lookupvar to return :undefined to us when
-    # appropriate; otherwise it converts to "".
-    value = scope.lookupvar(name.to_s, false)
+    value = scope.lookupvar(name.to_s)
     if value != :undefined
       return value
     else
       # Just throw an error immediately, instead of searching for
       # other missingmethod things or whatever.
       raise Puppet::ParseError, "Could not find value for '#{name}'"
     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, "-")
       result = template.result(binding)
     end
 
     result
   end
 
   def to_s
     "template[#{(file ? file : "inline")}]"
   end
 end
diff --git a/spec/unit/parser/ast/arithmetic_operator_spec.rb b/spec/unit/parser/ast/arithmetic_operator_spec.rb
index 6f57fd9b6..0aab6f080 100755
--- a/spec/unit/parser/ast/arithmetic_operator_spec.rb
+++ b/spec/unit/parser/ast/arithmetic_operator_spec.rb
@@ -1,73 +1,73 @@
 #!/usr/bin/env ruby
 
 require 'spec_helper'
 
 describe Puppet::Parser::AST::ArithmeticOperator do
 
   ast = Puppet::Parser::AST
 
   before :each do
     @scope = Puppet::Parser::Scope.new
     @one = stub 'lval', :safeevaluate => 1
     @two = stub 'rval', :safeevaluate => 2
   end
 
   it "should evaluate both branches" do
     lval = stub "lval"
     lval.expects(:safeevaluate).with(@scope).returns(1)
     rval = stub "rval"
     rval.expects(:safeevaluate).with(@scope).returns(2)
 
     operator = ast::ArithmeticOperator.new :rval => rval, :operator => "+", :lval => lval
     operator.evaluate(@scope)
   end
 
   it "should fail for an unknown operator" do
     lambda { operator = ast::ArithmeticOperator.new :lval => @one, :operator => "%", :rval => @two }.should raise_error
   end
 
   it "should call Puppet::Parser::Scope.number?" do
     Puppet::Parser::Scope.expects(:number?).with(1).returns(1)
     Puppet::Parser::Scope.expects(:number?).with(2).returns(2)
 
     ast::ArithmeticOperator.new(:lval => @one, :operator => "+", :rval => @two).evaluate(@scope)
   end
 
 
   %w{ + - * / << >>}.each do |op|
     it "should call ruby Numeric '#{op}'" do
       one = stub 'one'
       two = stub 'two'
       operator = ast::ArithmeticOperator.new :lval => @one, :operator => op, :rval => @two
       Puppet::Parser::Scope.stubs(:number?).with(1).returns(one)
       Puppet::Parser::Scope.stubs(:number?).with(2).returns(two)
       one.expects(:send).with(op,two)
       operator.evaluate(@scope)
     end
   end
 
   it "should work even with numbers embedded in strings" do
     two = stub 'two', :safeevaluate => "2"
     one = stub 'one', :safeevaluate => "1"
     operator = ast::ArithmeticOperator.new :lval => two, :operator => "+", :rval => one
     operator.evaluate(@scope).should == 3
   end
 
   it "should work even with floats" do
     two = stub 'two', :safeevaluate => 2.53
     one = stub 'one', :safeevaluate => 1.80
     operator = ast::ArithmeticOperator.new :lval => two, :operator => "+", :rval => one
     operator.evaluate(@scope).should == 4.33
   end
 
   it "should work for variables too" do
-    @scope.expects(:lookupvar).with("one", false).returns(1)
-    @scope.expects(:lookupvar).with("two", false).returns(2)
+    @scope.expects(:lookupvar).with("one").returns(1)
+    @scope.expects(:lookupvar).with("two").returns(2)
     one = ast::Variable.new( :value => "one" )
     two = ast::Variable.new( :value => "two" )
 
     operator = ast::ArithmeticOperator.new :lval => one, :operator => "+", :rval => two
     operator.evaluate(@scope).should == 3
   end
 
 end
diff --git a/spec/unit/parser/ast/comparison_operator_spec.rb b/spec/unit/parser/ast/comparison_operator_spec.rb
index 169d92d0a..3efe28bb6 100755
--- a/spec/unit/parser/ast/comparison_operator_spec.rb
+++ b/spec/unit/parser/ast/comparison_operator_spec.rb
@@ -1,116 +1,116 @@
 #!/usr/bin/env ruby
 
 require 'spec_helper'
 
 describe Puppet::Parser::AST::ComparisonOperator do
   before :each do
     @scope = Puppet::Parser::Scope.new
     @one = Puppet::Parser::AST::Leaf.new(:value => "1")
     @two = Puppet::Parser::AST::Leaf.new(:value => "2")
 
     @lval = Puppet::Parser::AST::Leaf.new(:value => "one")
     @rval = Puppet::Parser::AST::Leaf.new(:value => "two")
   end
 
   it "should evaluate both values" do
     @lval.expects(:safeevaluate).with(@scope)
     @rval.expects(:safeevaluate).with(@scope)
 
     operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @lval, :operator => "==", :rval => @rval
     operator.evaluate(@scope)
   end
 
   it "should convert the arguments to numbers if they are numbers in string" do
     Puppet::Parser::Scope.expects(:number?).with("1").returns(1)
     Puppet::Parser::Scope.expects(:number?).with("2").returns(2)
 
     operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => "==", :rval => @two
     operator.evaluate(@scope)
   end
 
   %w{< > <= >=}.each do |oper|
     it "should use string comparison #{oper} if operands are strings" do
       operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @lval, :operator => oper, :rval => @rval
       operator.evaluate(@scope).should == "one".send(oper,"two")
     end
   end
 
   describe "with string comparison" do
     it "should use matching" do
       @rval.expects(:evaluate_match).with("one", @scope)
 
       operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @lval, :operator => "==", :rval => @rval
       operator.evaluate(@scope)
     end
 
     it "should return true for :undef to '' equality" do
       astundef = Puppet::Parser::AST::Leaf.new(:value => :undef)
       empty = Puppet::Parser::AST::Leaf.new(:value => '')
 
       operator = Puppet::Parser::AST::ComparisonOperator.new :lval => astundef, :operator => "==", :rval => empty
       operator.evaluate(@scope).should be_true
     end
 
     [true, false].each do |result|
       it "should return #{(result).inspect} with '==' when matching return #{result.inspect}" do
         @rval.expects(:evaluate_match).with("one", @scope).returns result
 
         operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @lval, :operator => "==", :rval => @rval
         operator.evaluate(@scope).should == result
       end
 
       it "should return #{(!result).inspect} with '!=' when matching return #{result.inspect}" do
         @rval.expects(:evaluate_match).with("one", @scope).returns result
 
         operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @lval, :operator => "!=", :rval => @rval
         operator.evaluate(@scope).should == !result
       end
     end
   end
 
   it "should fail with arguments of different types" do
     operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => ">", :rval => @rval
     lambda { operator.evaluate(@scope) }.should raise_error(ArgumentError)
   end
 
   it "should fail for an unknown operator" do
     lambda { operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => "or", :rval => @two }.should raise_error
   end
 
   %w{< > <= >= ==}.each do |oper|
     it "should return the result of using '#{oper}' to compare the left and right sides" do
       operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => oper, :rval => @two
 
       operator.evaluate(@scope).should == 1.send(oper,2)
     end
   end
 
   it "should return the result of using '!=' to compare the left and right sides" do
     operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => '!=', :rval => @two
 
     operator.evaluate(@scope).should == true
   end
 
   it "should work for variables too" do
     one = Puppet::Parser::AST::Variable.new( :value => "one" )
     two = Puppet::Parser::AST::Variable.new( :value => "two" )
 
-    @scope.expects(:lookupvar).with("one", false).returns(1)
-    @scope.expects(:lookupvar).with("two", false).returns(2)
+    @scope.expects(:lookupvar).with("one").returns(1)
+    @scope.expects(:lookupvar).with("two").returns(2)
 
     operator = Puppet::Parser::AST::ComparisonOperator.new :lval => one, :operator => "<", :rval => two
     operator.evaluate(@scope).should == true
   end
 
   # see ticket #1759
   %w{< > <= >=}.each do |oper|
     it "should return the correct result of using '#{oper}' to compare 10 and 9" do
       ten = Puppet::Parser::AST::Leaf.new(:value => "10")
       nine = Puppet::Parser::AST::Leaf.new(:value => "9")
       operator = Puppet::Parser::AST::ComparisonOperator.new :lval => ten, :operator => oper, :rval => nine
 
       operator.evaluate(@scope).should == 10.send(oper,9)
     end
   end
 
 end
diff --git a/spec/unit/parser/ast/leaf_spec.rb b/spec/unit/parser/ast/leaf_spec.rb
index 3b8c14efa..97c996b40 100755
--- a/spec/unit/parser/ast/leaf_spec.rb
+++ b/spec/unit/parser/ast/leaf_spec.rb
@@ -1,408 +1,408 @@
 #!/usr/bin/env ruby
 
 require 'spec_helper'
 
 describe Puppet::Parser::AST::Leaf do
   before :each do
     @scope = stub 'scope'
     @value = stub 'value'
     @leaf = Puppet::Parser::AST::Leaf.new(:value => @value)
   end
 
   it "should have a evaluate_match method" do
     Puppet::Parser::AST::Leaf.new(:value => "value").should respond_to(:evaluate_match)
   end
 
   describe "when converting to string" do
     it "should transform its value to string" do
       value = stub 'value', :is_a? => true
       value.expects(:to_s)
       Puppet::Parser::AST::Leaf.new( :value => value ).to_s
     end
   end
 
   it "should have a match method" do
     @leaf.should respond_to(:match)
   end
 
   it "should delegate match to ==" do
     @value.expects(:==).with("value")
 
     @leaf.match("value")
   end
 end
 
 describe Puppet::Parser::AST::FlatString do
   describe "when converting to string" do
     it "should transform its value to a quoted string" do
       value = stub 'value', :is_a? => true, :to_s => "ab"
       Puppet::Parser::AST::FlatString.new( :value => value ).to_s.should == "\"ab\""
     end
   end
 end
 
 describe Puppet::Parser::AST::String do
   describe "when converting to string" do
     it "should transform its value to a quoted string" do
       value = stub 'value', :is_a? => true, :to_s => "ab"
       Puppet::Parser::AST::String.new( :value => value ).to_s.should == "\"ab\""
     end
     it "should return a dup of its value" do
       value = ""
       Puppet::Parser::AST::String.new( :value => value ).evaluate(stub('scope')).should_not be_equal(value)
     end
   end
 end
 
 describe Puppet::Parser::AST::Concat do
   describe "when evaluating" do
     before :each do
       @scope = stub_everything 'scope'
     end
     it "should interpolate variables and concatenate their values" do
       one = Puppet::Parser::AST::String.new(:value => "one")
       one.stubs(:evaluate).returns("one ")
       two = Puppet::Parser::AST::String.new(:value => "two")
       two.stubs(:evaluate).returns(" two ")
       three = Puppet::Parser::AST::String.new(:value => "three")
       three.stubs(:evaluate).returns(" three")
       var = Puppet::Parser::AST::Variable.new(:value => "myvar")
       var.stubs(:evaluate).returns("foo")
       array = Puppet::Parser::AST::Variable.new(:value => "array")
       array.stubs(:evaluate).returns(["bar","baz"])
       concat = Puppet::Parser::AST::Concat.new(:value => [one,var,two,array,three])
 
       concat.evaluate(@scope).should == 'one foo two barbaz three'
     end
 
     it "should transform undef variables to empty string" do
       var = Puppet::Parser::AST::Variable.new(:value => "myvar")
       var.stubs(:evaluate).returns(:undef)
       concat = Puppet::Parser::AST::Concat.new(:value => [var])
 
       concat.evaluate(@scope).should == ''
     end
   end
 end
 
 describe Puppet::Parser::AST::Undef do
   before :each do
     @scope = stub 'scope'
     @undef = Puppet::Parser::AST::Undef.new(:value => :undef)
   end
 
   it "should match undef with undef" do
     @undef.evaluate_match(:undef, @scope).should be_true
   end
 
   it "should not match undef with an empty string" do
     @undef.evaluate_match("", @scope).should be_false
   end
 end
 
 describe Puppet::Parser::AST::HashOrArrayAccess do
   before :each do
     @scope = stub 'scope'
   end
 
   describe "when evaluating" do
     it "should evaluate the variable part if necessary" do
       @scope.stubs(:lookupvar).with("a").returns(["b"])
 
       variable = stub 'variable', :evaluate => "a"
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => variable, :key => 0 )
 
       variable.expects(:safeevaluate).with(@scope).returns("a")
 
       access.evaluate(@scope).should == "b"
     end
 
     it "should evaluate the access key part if necessary" do
       @scope.stubs(:lookupvar).with("a").returns(["b"])
 
       index = stub 'index', :evaluate => 0
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => index )
 
       index.expects(:safeevaluate).with(@scope).returns(0)
 
       access.evaluate(@scope).should == "b"
     end
 
     it "should be able to return an array member" do
       @scope.stubs(:lookupvar).with("a").returns(["val1", "val2", "val3"])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => 1 )
 
       access.evaluate(@scope).should == "val2"
     end
 
     it "should be able to return an array member when index is a stringified number" do
       @scope.stubs(:lookupvar).with("a").returns(["val1", "val2", "val3"])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "1" )
 
       access.evaluate(@scope).should == "val2"
     end
 
     it "should raise an error when accessing an array with a key" do
       @scope.stubs(:lookupvar).with("a").returns(["val1", "val2", "val3"])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "get_me_the_second_element_please" )
 
       lambda { access.evaluate(@scope) }.should raise_error
     end
 
     it "should be able to return an hash value" do
       @scope.stubs(:lookupvar).with("a").returns({ "key1" => "val1", "key2" => "val2", "key3" => "val3" })
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
 
       access.evaluate(@scope).should == "val2"
     end
 
     it "should be able to return an hash value with a numerical key" do
       @scope.stubs(:lookupvar).with("a").returns({ "key1" => "val1", "key2" => "val2", "45" => "45", "key3" => "val3" })
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "45" )
 
       access.evaluate(@scope).should == "45"
     end
 
     it "should raise an error if the variable lookup didn't return an hash or an array" do
       @scope.stubs(:lookupvar).with("a").returns("I'm a string")
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
 
       lambda { access.evaluate(@scope) }.should raise_error
     end
 
     it "should raise an error if the variable wasn't in the scope" do
       @scope.stubs(:lookupvar).with("a").returns(nil)
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
 
       lambda { access.evaluate(@scope) }.should raise_error
     end
 
     it "should return a correct string representation" do
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
       access.to_s.should == '$a[key2]'
     end
 
     it "should work with recursive hash access" do
       @scope.stubs(:lookupvar).with("a").returns({ "key" => { "subkey" => "b" }})
 
       access1 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
       access2 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => access1, :key => "subkey")
 
       access2.evaluate(@scope).should == 'b'
     end
 
     it "should work with interleaved array and hash access" do
       @scope.stubs(:lookupvar).with("a").returns({ "key" => [ "a" , "b" ]})
 
       access1 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
       access2 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => access1, :key => 1)
 
       access2.evaluate(@scope).should == 'b'
     end
   end
 
   describe "when assigning" do
     it "should add a new key and value" do
       scope = Puppet::Parser::Scope.new
       scope.setvar("a", { 'a' => 'b' })
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "b")
       access.assign(scope, "c" )
 
       scope.lookupvar("a").should be_include("b")
     end
 
     it "should raise an error when assigning an array element with a key" do
       @scope.stubs(:lookupvar).with("a").returns([])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "get_me_the_second_element_please" )
 
       lambda { access.assign(@scope, "test") }.should raise_error
     end
 
     it "should be able to return an array member when index is a stringified number" do
       scope = Puppet::Parser::Scope.new
       scope.setvar("a", [])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "0" )
 
       access.assign(scope, "val2")
       scope.lookupvar("a").should == ["val2"]
     end
 
     it "should raise an error when trying to overwrite an hash value" do
       @scope.stubs(:lookupvar).with("a").returns({ "key" => [ "a" , "b" ]})
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
 
       lambda { access.assign(@scope, "test") }.should raise_error
     end
   end
 end
 
 describe Puppet::Parser::AST::Regex do
   before :each do
     @scope = stub 'scope'
   end
 
   describe "when initializing" do
     it "should create a Regexp with its content when value is not a Regexp" do
       Regexp.expects(:new).with("/ab/")
 
       Puppet::Parser::AST::Regex.new :value => "/ab/"
     end
 
     it "should not create a Regexp with its content when value is a Regexp" do
       value = Regexp.new("/ab/")
       Regexp.expects(:new).with("/ab/").never
 
       Puppet::Parser::AST::Regex.new :value => value
     end
   end
 
   describe "when evaluating" do
     it "should return self" do
       val = Puppet::Parser::AST::Regex.new :value => "/ab/"
 
       val.evaluate(@scope).should === val
     end
   end
 
   describe "when evaluate_match" do
     before :each do
       @value = stub 'regex'
       @value.stubs(:match).with("value").returns(true)
       Regexp.stubs(:new).returns(@value)
       @regex = Puppet::Parser::AST::Regex.new :value => "/ab/"
     end
 
     it "should issue the regexp match" do
       @value.expects(:match).with("value")
 
       @regex.evaluate_match("value", @scope)
     end
 
     it "should not downcase the paramater value" do
       @value.expects(:match).with("VaLuE")
 
       @regex.evaluate_match("VaLuE", @scope)
     end
 
     it "should set ephemeral scope vars if there is a match" do
       @scope.expects(:ephemeral_from).with(true, nil, nil)
 
       @regex.evaluate_match("value", @scope)
     end
 
     it "should return the match to the caller" do
       @value.stubs(:match).with("value").returns(:match)
       @scope.stubs(:ephemeral_from)
 
       @regex.evaluate_match("value", @scope)
     end
   end
 
   it "should return the regex source with to_s" do
     regex = stub 'regex'
     Regexp.stubs(:new).returns(regex)
 
     val = Puppet::Parser::AST::Regex.new :value => "/ab/"
 
     regex.expects(:source)
 
     val.to_s
   end
 
   it "should delegate match to the underlying regexp match method" do
     regex = Regexp.new("/ab/")
     val = Puppet::Parser::AST::Regex.new :value => regex
 
     regex.expects(:match).with("value")
 
     val.match("value")
   end
 end
 
 describe Puppet::Parser::AST::Variable do
   before :each do
     @scope = stub 'scope'
     @var = Puppet::Parser::AST::Variable.new(:value => "myvar")
   end
 
   it "should lookup the variable in scope" do
-    @scope.expects(:lookupvar).with("myvar", false).returns(:myvalue)
+    @scope.expects(:lookupvar).with("myvar").returns(:myvalue)
     @var.safeevaluate(@scope).should == :myvalue
   end
 
   it "should return undef if the variable wasn't set" do
-    @scope.expects(:lookupvar).with("myvar", false).returns(:undefined)
+    @scope.expects(:lookupvar).with("myvar").returns(:undefined)
     @var.safeevaluate(@scope).should == :undef
   end
 
   describe "when converting to string" do
     it "should transform its value to a variable" do
       value = stub 'value', :is_a? => true, :to_s => "myvar"
       Puppet::Parser::AST::Variable.new( :value => value ).to_s.should == "\$myvar"
     end
   end
 end
 
 describe Puppet::Parser::AST::HostName do
   before :each do
     @scope = stub 'scope'
     @value = stub 'value', :=~ => false
     @value.stubs(:to_s).returns(@value)
     @value.stubs(:downcase).returns(@value)
     @host = Puppet::Parser::AST::HostName.new( :value => @value)
   end
 
   it "should raise an error if hostname is not valid" do
     lambda { Puppet::Parser::AST::HostName.new( :value => "not an hostname!" ) }.should raise_error
   end
 
   it "should not raise an error if hostname is a regex" do
     lambda { Puppet::Parser::AST::HostName.new( :value => Puppet::Parser::AST::Regex.new(:value => "/test/") ) }.should_not raise_error
   end
 
   it "should stringify the value" do
     value = stub 'value', :=~ => false
 
     value.expects(:to_s).returns("test")
 
     Puppet::Parser::AST::HostName.new(:value => value)
   end
 
   it "should downcase the value" do
     value = stub 'value', :=~ => false
     value.stubs(:to_s).returns("UPCASED")
     host = Puppet::Parser::AST::HostName.new(:value => value)
 
     host.value == "upcased"
   end
 
   it "should evaluate to its value" do
     @host.evaluate(@scope).should == @value
   end
 
   it "should delegate eql? to the underlying value if it is an HostName" do
     @value.expects(:eql?).with("value")
     @host.eql?("value")
   end
 
   it "should delegate eql? to the underlying value if it is not an HostName" do
     value = stub 'compared', :is_a? => true, :value => "value"
     @value.expects(:eql?).with("value")
     @host.eql?(value)
   end
 
   it "should delegate hash to the underlying value" do
     @value.expects(:hash)
     @host.hash
   end
 end
diff --git a/spec/unit/parser/scope_spec.rb b/spec/unit/parser/scope_spec.rb
index 44e255956..b37cb4add 100755
--- a/spec/unit/parser/scope_spec.rb
+++ b/spec/unit/parser/scope_spec.rb
@@ -1,628 +1,620 @@
 #!/usr/bin/env ruby
 
 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 = stub 'environment'
     compiler = stub 'compiler', :environment => env
     scope = Puppet::Parser::Scope.new :compiler => compiler
     scope.environment.should equal(env)
   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")
       compiler = stub 'compiler', :environment => env
       mod      = Module.new
       root_mod = Module.new
       Puppet::Parser::Functions.expects(:environment_module).with(Puppet::Node::Environment.root).returns root_mod
       Puppet::Parser::Functions.expects(:environment_module).with(env).returns mod
 
       Puppet::Parser::Scope.new(:compiler => compiler).singleton_class.ancestors.should be_include(mod)
     end
 
     it "should extend itself with the default Functions module if it has no environment" do
       mod = Module.new
       Puppet::Parser::Functions.expects(:environment_module).with(Puppet::Node::Environment.root).returns(mod)
 
       Puppet::Parser::Functions.expects(:environment_module).with(nil).returns mod
 
       Puppet::Parser::Scope.new.singleton_class.ancestors.should be_include(mod)
     end
   end
 
   describe "when looking up a variable" do
-    it "should default to an empty string" do
-      @scope.lookupvar("var").should == ""
-    end
-
-    it "should return an string when asked for a string" do
-      @scope.lookupvar("var", true).should == ""
-    end
-
-    it "should return ':undefined' for unset variables when asked not to return a string" do
-      @scope.lookupvar("var", false).should == :undefined
+    it "should return ':undefined' for unset variables" do
+      @scope.lookupvar("var").should == :undefined
     end
 
     it "should be able to look up values" do
       @scope.setvar("var", "yep")
       @scope.lookupvar("var").should == "yep"
     end
 
     it "should be able to look up hashes" do
       @scope.setvar("var", {"a" => "b"})
       @scope.lookupvar("var").should == {"a" => "b"}
     end
 
     it "should be able to look up variables in parent scopes" do
       @topscope.setvar("var", "parentval")
       @scope.lookupvar("var").should == "parentval"
     end
 
     it "should prefer its own values to parent values" do
       @topscope.setvar("var", "parentval")
       @scope.setvar("var", "childval")
       @scope.lookupvar("var").should == "childval"
     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)
         Puppet::Parser::Resource.new("class", name, :scope => @scope, :source => mock('source')).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.setvar("othervar", "otherval")
 
         @scope.lookupvar("::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.setvar("var", "otherval")
 
         @scope.lookupvar("::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.setvar("var", "otherval")
 
         @scope.lookupvar("other::deep::klass::var").should == "otherval"
       end
 
-      it "should return an empty string for qualified variables that cannot be found in other classes" do
+      it "should return ':undefined' for qualified variables that cannot be found in other classes" do
         other_scope = create_class_scope("other::deep::klass")
 
-        @scope.lookupvar("other::deep::klass::var").should == ""
+        @scope.lookupvar("other::deep::klass::var").should == :undefined
       end
 
-      it "should warn and return an empty string for qualified variables whose classes have not been evaluated" do
+      it "should warn and return ':undefined' for qualified variables whose classes have not been evaluated" do
         klass = newclass("other::deep::klass")
         @scope.expects(:warning)
-        @scope.lookupvar("other::deep::klass::var").should == ""
+        @scope.lookupvar("other::deep::klass::var").should == :undefined
       end
 
-      it "should warn and return an empty string for qualified variables whose classes do not exist" do
+      it "should warn and return ':undefined' for qualified variables whose classes do not exist" do
         @scope.expects(:warning)
-        @scope.lookupvar("other::deep::klass::var").should == ""
+        @scope.lookupvar("other::deep::klass::var").should == :undefined
       end
 
       it "should return ':undefined' when asked for a non-string qualified variable from a class that does not exist" do
         @scope.stubs(:warning)
-        @scope.lookupvar("other::deep::klass::var", false).should == :undefined
+        @scope.lookupvar("other::deep::klass::var").should == :undefined
       end
 
       it "should return ':undefined' 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.lookupvar("other::deep::klass::var", false).should == :undefined
+        @scope.lookupvar("other::deep::klass::var").should == :undefined
       end
     end
   end
 
   describe "when setvar is called with append=true" do
     it "should raise 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(:lookupvar).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.lookupvar("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.lookupvar("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.lookupvar("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.lookupvar("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.lookupvar("1", false).should == :undefined
+      @scope.lookupvar("1").should == :undefined
     end
 
     it "should not remove classic variables when unset_ephemeral_var is called" do
       @scope.setvar("myvar", :value1)
       @scope.setvar("1", :value2, :ephemeral => true)
       @scope.stubs(:parent).returns(nil)
 
       @scope.unset_ephemeral_var
 
-      @scope.lookupvar("myvar", false).should == :value1
+      @scope.lookupvar("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.lookupvar("0", false).should == :latest
+        @scope.lookupvar("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.lookupvar("1", false).should == :value1
+        @scope.lookupvar("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.lookupvar("1", false).should == :undefined
+          @scope.lookupvar("1").should == :undefined
         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.lookupvar("1", false).should == :value2
+          @scope.lookupvar("1").should == :value2
         end
       end
     end
   end
 
   describe "when interpolating string" do
     (0..9).each do |n|
       it "should allow $#{n} to match" do
         @scope.setvar(n.to_s, "value", :ephemeral => true)
 
         @scope.strinterp("$#{n}").should == "value"
       end
     end
 
     (0..9).each do |n|
       it "should not allow $#{n} to match if not ephemeral" do
         @scope.setvar(n.to_s, "value", :ephemeral => false)
 
         @scope.strinterp("$#{n}").should_not == "value"
       end
     end
 
     it "should not allow $10 to match" do
       @scope.setvar("10", "value", :ephemeral => true)
 
       @scope.strinterp('==$10==').should_not == "==value=="
     end
 
     it "should not allow ${10} to match" do
       @scope.setvar("10", "value", :ephemeral => true)
 
       @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.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.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.class_scope(klass)
       scopes[name].setvar("test", "value-#{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 #{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 #{string}")
       logs.clear
     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.setvar("foo", "bar")
       @scope.unsetvar("foo")
-      @scope.lookupvar("foo").should == ""
+      @scope.lookupvar("foo").should == :undefined
     end
 
     it "should be able to unset ephemeral variables" do
       @scope.setvar("0", "bar", :ephemeral => true)
       @scope.unsetvar("0")
-      @scope.lookupvar("0").should == ""
+      @scope.lookupvar("0").should == :undefined
     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.lookupvar("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/spec/unit/parser/templatewrapper_spec.rb b/spec/unit/parser/templatewrapper_spec.rb
index afb0032fd..4a713b8a8 100755
--- a/spec/unit/parser/templatewrapper_spec.rb
+++ b/spec/unit/parser/templatewrapper_spec.rb
@@ -1,145 +1,145 @@
 #!/usr/bin/env ruby
 
 require 'spec_helper'
 require 'puppet/parser/templatewrapper'
 
 describe Puppet::Parser::TemplateWrapper do
   before(:each) do
     @known_resource_types = Puppet::Resource::TypeCollection.new("env")
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
     @compiler.environment.stubs(:known_resource_types).returns @known_resource_types
     @scope = Puppet::Parser::Scope.new :compiler => @compiler
 
     @file = "fake_template"
     Puppet::Parser::Files.stubs(:find_template).returns("/tmp/fake_template")
     FileTest.stubs(:exists?).returns("true")
     File.stubs(:read).with("/tmp/fake_template").returns("template content")
     @tw = Puppet::Parser::TemplateWrapper.new(@scope)
   end
 
   it "should create a new object TemplateWrapper from a scope" do
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
 
     tw.should be_a_kind_of(Puppet::Parser::TemplateWrapper)
   end
 
   it "should check template file existance and read its content" do
     Puppet::Parser::Files.expects(:find_template).with("fake_template", @scope.environment.to_s).returns("/tmp/fake_template")
     File.expects(:read).with("/tmp/fake_template").returns("template content")
 
     @tw.file = @file
   end
 
   it "should mark the file for watching" do
     Puppet::Parser::Files.expects(:find_template).returns("/tmp/fake_template")
     File.stubs(:read)
 
     @known_resource_types.expects(:watch_file).with("/tmp/fake_template")
     @tw.file = @file
   end
 
   it "should fail if a template cannot be found" do
     Puppet::Parser::Files.expects(:find_template).returns nil
 
     lambda { @tw.file = @file }.should raise_error(Puppet::ParseError)
   end
 
   it "should turn into a string like template[name] for file based template" do
     @tw.file = @file
     @tw.to_s.should eql("template[/tmp/fake_template]")
   end
 
   it "should turn into a string like template[inline] for string-based template" do
     @tw.to_s.should eql("template[inline]")
   end
 
   it "should return the processed template contents with a call to result" do
     template_mock = mock("template", :result => "woot!")
     File.expects(:read).with("/tmp/fake_template").returns("template contents")
     ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
 
     @tw.file = @file
     @tw.result.should eql("woot!")
   end
 
   it "should return the processed template contents with a call to result and a string" do
     template_mock = mock("template", :result => "woot!")
     ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
 
     @tw.result("template contents").should eql("woot!")
   end
 
   it "should return the contents of a variable if called via method_missing" do
-    @scope.expects(:lookupvar).with("chicken", false).returns("is good")
+    @scope.expects(:lookupvar).with("chicken").returns("is good")
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.chicken.should eql("is good")
   end
 
   it "should throw an exception if a variable is called via method_missing and it does not exist" do
-    @scope.expects(:lookupvar).with("chicken", false).returns(:undefined)
+    @scope.expects(:lookupvar).with("chicken").returns(:undefined)
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     lambda { tw.chicken }.should raise_error(Puppet::ParseError)
   end
 
   it "should allow you to check whether a variable is defined with has_variable?" do
-    @scope.expects(:lookupvar).with("chicken", false).returns("is good")
+    @scope.expects(:lookupvar).with("chicken").returns("is good")
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.has_variable?("chicken").should eql(true)
   end
 
   it "should allow you to check whether a variable is not defined with has_variable?" do
-    @scope.expects(:lookupvar).with("chicken", false).returns(:undefined)
+    @scope.expects(:lookupvar).with("chicken").returns(:undefined)
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.has_variable?("chicken").should eql(false)
   end
 
   it "should allow you to retrieve the defined classes with classes" do
     catalog = mock 'catalog', :classes => ["class1", "class2"]
     @scope.expects(:catalog).returns( catalog )
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.classes.should == ["class1", "class2"]
   end
 
   it "should allow you to retrieve all the tags with all_tags" do
     catalog = mock 'catalog', :tags => ["tag1", "tag2"]
     @scope.expects(:catalog).returns( catalog )
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.all_tags.should == ["tag1","tag2"]
   end
 
   it "should allow you to retrieve the tags defined in the current scope" do
     @scope.expects(:tags).returns( ["tag1", "tag2"] )
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.tags.should == ["tag1","tag2"]
   end
 
   it "should set all of the scope's variables as instance variables" do
     template_mock = mock("template", :result => "woot!")
     ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
 
     @scope.expects(:to_hash).returns("one" => "foo")
     @tw.result("template contents")
 
     @tw.instance_variable_get("@one").should == "foo"
   end
 
   it "should not error out if one of the variables is a symbol" do
     template_mock = mock("template", :result => "woot!")
     ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
 
     @scope.expects(:to_hash).returns(:_timestamp => "1234")
     @tw.result("template contents")
   end
 
   %w{! . ; :}.each do |badchar|
     it "should translate #{badchar} to _ when setting the instance variables" do
     template_mock = mock("template", :result => "woot!")
     ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
 
     @scope.expects(:to_hash).returns("one#{badchar}" => "foo")
     @tw.result("template contents")
 
     @tw.instance_variable_get("@one_").should == "foo"
   end
   end
 end
diff --git a/test/language/functions.rb b/test/language/functions.rb
index e882b68f3..84b1b3861 100755
--- a/test/language/functions.rb
+++ b/test/language/functions.rb
@@ -1,543 +1,541 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../lib/puppettest')
 
 require 'puppet'
 require 'puppet/parser/parser'
 require 'puppet/network/client'
 require 'puppettest'
 require 'puppettest/resourcetesting'
 
 class TestLangFunctions < Test::Unit::TestCase
   include PuppetTest::ParserTesting
   include PuppetTest::ResourceTesting
   def test_functions
     Puppet::Node::Environment.stubs(:current).returns nil
     assert_nothing_raised do
 
       Puppet::Parser::AST::Function.new(
 
         :name => "fakefunction",
 
         :arguments => AST::ASTArray.new(
           :children => [nameobj("avalue")]
         )
       )
     end
 
     assert_raise(Puppet::ParseError) do
 
       func = Puppet::Parser::AST::Function.new(
 
         :name => "fakefunction",
 
         :arguments => AST::ASTArray.new(
           :children => [nameobj("avalue")]
         )
       )
       func.evaluate(mkscope)
     end
 
     assert_nothing_raised do
       Puppet::Parser::Functions.newfunction(:fakefunction, :type => :rvalue) do |input|
         return "output #{input[0]}"
       end
     end
 
     func = nil
     assert_nothing_raised do
 
       func = Puppet::Parser::AST::Function.new(
 
         :name => "fakefunction",
         :ftype => :rvalue,
 
         :arguments => AST::ASTArray.new(
           :children => [nameobj("avalue")]
         )
       )
     end
 
     scope = mkscope
     val = nil
     assert_nothing_raised do
       val = func.evaluate(scope)
     end
 
     assert_equal("output avalue", val)
   end
 
   def test_taggedfunction
     scope = mkscope
     scope.resource.tag("yayness")
 
     # Make sure the ast stuff does what it's supposed to
     {"yayness" => true, "booness" => false}.each do |tag, retval|
       func = taggedobj(tag, :rvalue)
 
       val = nil
       assert_nothing_raised do
         val = func.evaluate(scope)
       end
 
       assert_equal(retval, val, "'tagged' returned #{val} for #{tag}")
     end
 
     # Now make sure we correctly get tags.
     scope.resource.tag("resourcetag")
     assert(scope.function_tagged("resourcetag"), "tagged function did not catch resource tags")
     scope.compiler.catalog.tag("configtag")
     assert(scope.function_tagged("configtag"), "tagged function did not catch catalog tags")
   end
 
   def test_failfunction
     func = nil
     assert_nothing_raised do
 
       func = Puppet::Parser::AST::Function.new(
 
         :name => "fail",
         :ftype => :statement,
 
         :arguments => AST::ASTArray.new(
           :children => [stringobj("this is a failure"), stringobj("and another")]
         )
       )
     end
 
     scope = mkscope
     val = nil
     assert_raise(Puppet::ParseError) do
       val = func.evaluate(scope)
     end
   end
 
   def test_multipletemplates
     Dir.mkdir(Puppet[:templatedir])
     onep = File.join(Puppet[:templatedir], "one")
     twop = File.join(Puppet[:templatedir], "two")
 
     File.open(onep, "w") do |f|
       f.puts "<%- if @one.nil? then raise '@one undefined' end -%>template <%= @one %>"
     end
 
     File.open(twop, "w") do |f|
       f.puts "template <%= @two %>"
     end
     func = nil
     assert_nothing_raised do
 
       func = Puppet::Parser::AST::Function.new(
 
         :name => "template",
         :ftype => :rvalue,
 
         :arguments => AST::ASTArray.new(
           :children => [stringobj("one"), stringobj("two")]
         )
       )
     end
     ast = varobj("output", func)
 
     scope = mkscope
 
     # Test that our manual exception throw fails the parse
     assert_raise(Puppet::ParseError) do
       ast.evaluate(scope)
     end
 
     # Test that our use of an undefined instance variable does not throw
     # an exception, but only safely continues.
     scope.setvar("one", "One")
     assert_nothing_raised do
       ast.evaluate(scope)
     end
 
     # Ensure that we got the output we expected from that evaluation.
     assert_equal("template One\ntemplate \n", scope.lookupvar("output"), "Undefined template variables do not raise exceptions")
 
     # Now, fill in the last variable and make sure the whole thing
     # evaluates correctly.
     scope.setvar("two", "Two")
     scope.unsetvar("output")
     assert_nothing_raised do
       ast.evaluate(scope)
     end
 
 
       assert_equal(
         "template One\ntemplate Two\n", scope.lookupvar("output"),
 
       "Templates were not handled correctly")
   end
 
   # Now make sure we can fully qualify files, and specify just one
   def test_singletemplates
     template = tempfile
 
     File.open(template, "w") do |f|
       f.puts "template <%= @yay.nil?() ? raise('yay undefined') : @yay %>"
     end
 
     func = nil
     assert_nothing_raised do
 
       func = Puppet::Parser::AST::Function.new(
 
         :name => "template",
         :ftype => :rvalue,
 
         :arguments => AST::ASTArray.new(
           :children => [stringobj(template)]
         )
       )
     end
     ast = varobj("output", func)
 
     scope = mkscope
     assert_raise(Puppet::ParseError) do
       ast.evaluate(scope)
     end
 
     scope.setvar("yay", "this is yay")
 
     assert_nothing_raised do
       ast.evaluate(scope)
     end
 
 
       assert_equal(
         "template this is yay\n", scope.lookupvar("output"),
 
       "Templates were not handled correctly")
 
   end
 
   # Make sure that legacy template variable access works as expected.
   def test_legacyvariables
     template = tempfile
 
     File.open(template, "w") do |f|
       f.puts "template <%= deprecated %>"
     end
 
     func = nil
     assert_nothing_raised do
 
       func = Puppet::Parser::AST::Function.new(
 
         :name => "template",
         :ftype => :rvalue,
 
         :arguments => AST::ASTArray.new(
           :children => [stringobj(template)]
         )
       )
     end
     ast = varobj("output", func)
 
     # Verify that we get an exception using old-style accessors.
     scope = mkscope
     assert_raise(Puppet::ParseError) do
       ast.evaluate(scope)
     end
 
     # Verify that we evaluate and return their value correctly.
     scope.setvar("deprecated", "deprecated value")
     assert_nothing_raised do
       ast.evaluate(scope)
     end
 
 
       assert_equal(
         "template deprecated value\n", scope.lookupvar("output"),
 
           "Deprecated template variables were not handled correctly")
   end
 
   # Make sure that problems with kernel method visibility still exist.
   def test_kernel_module_shadows_deprecated_var_lookup
     template = tempfile
     File.open(template, "w").puts("<%= binding %>")
 
     func = nil
     assert_nothing_raised do
 
       func = Puppet::Parser::AST::Function.new(
 
         :name => "template",
         :ftype => :rvalue,
 
         :arguments => AST::ASTArray.new(
           :children => [stringobj(template)]
         )
       )
     end
     ast = varobj("output", func)
 
     # Verify that Kernel methods still shadow deprecated variable lookups.
     scope = mkscope
     assert_nothing_raised("No exception for Kernel shadowed variable names") do
       ast.evaluate(scope)
     end
   end
 
   def test_tempatefunction_cannot_see_scopes
     template = tempfile
 
     File.open(template, "w") do |f|
       f.puts "<%= lookupvar('myvar') %>"
     end
 
     func = nil
     assert_nothing_raised do
 
       func = Puppet::Parser::AST::Function.new(
 
         :name => "template",
         :ftype => :rvalue,
 
         :arguments => AST::ASTArray.new(
           :children => [stringobj(template)]
         )
       )
     end
     ast = varobj("output", func)
 
     scope = mkscope
     scope.setvar("myvar", "this is yayness")
     assert_raise(Puppet::ParseError) do
       ast.evaluate(scope)
     end
   end
 
   def test_template_reparses
     template = tempfile
 
     File.open(template, "w") do |f|
       f.puts "original text"
     end
 
     file = tempfile
 
     Puppet[:code] = %{file { "#{file}": content => template("#{template}") }}
     Puppet[:environment] = "yay"
     node = mknode
     node.stubs(:environment).returns Puppet::Node::Environment.new
 
     Puppet[:environment] = "yay"
 
     catalog = Puppet::Parser::Compiler.new(node).compile
 
     version = catalog.version
 
     fileobj = catalog.vertices.find { |r| r.title == file }
     assert(fileobj, "File was not in catalog")
 
 
       assert_equal(
         "original text\n", fileobj["content"],
 
       "Template did not work")
 
     Puppet[:filetimeout] = -5
     # Have to sleep because one second is the fs's time granularity.
     sleep(1)
 
     # Now modify the template
     File.open(template, "w") do |f|
       f.puts "new text"
     end
 
     newversion = Puppet::Parser::Compiler.new(node).compile.version
 
     assert(version != newversion, "Parse date did not change")
   end
 
   def test_template_defined_vars
     template = tempfile
 
     File.open(template, "w") do |f|
       f.puts "template <%= @yayness %>"
     end
 
     func = nil
     assert_nothing_raised do
 
       func = Puppet::Parser::AST::Function.new(
 
         :name => "template",
         :ftype => :rvalue,
 
         :arguments => AST::ASTArray.new(
           :children => [stringobj(template)]
         )
       )
     end
     ast = varobj("output", func)
 
     {
       "" => "",
       false => "false",
     }.each do |string, value|
       scope = mkscope
       scope.setvar("yayness", string)
-      assert_equal(string, scope.lookupvar("yayness", false))
+      assert_equal(string, scope.lookupvar("yayness"))
 
       assert_nothing_raised("An empty string was not a valid variable value") do
         ast.evaluate(scope)
       end
 
-
-        assert_equal(
-          "template #{value}\n", scope.lookupvar("output"),
-
-            "#{string.inspect} did not get evaluated correctly")
+      assert_equal(
+        "template #{value}\n", scope.lookupvar("output"),
+        "#{string.inspect} did not get evaluated correctly")
     end
   end
 
   def test_autoloading_functions
     #assert_equal(false, Puppet::Parser::Functions.function(:autofunc),
     #    "Got told autofunc already exists")
 
     dir = tempfile
     $LOAD_PATH << dir
     newpath = File.join(dir, "puppet", "parser", "functions")
     FileUtils.mkdir_p(newpath)
 
     File.open(File.join(newpath, "autofunc.rb"), "w") { |f|
       f.puts %{
         Puppet::Parser::Functions.newfunction(:autofunc, :type => :rvalue) do |vals|
           Puppet.wanring vals.inspect
         end
       }
     }
     Puppet::Node::Environment.stubs(:current).returns nil
     obj = nil
     assert_nothing_raised {
       obj = Puppet::Parser::Functions.function(:autofunc)
     }
 
     assert(obj, "Did not autoload function")
     assert(Puppet::Parser::Functions.environment_module.method_defined?(:function_autofunc), "Did not set function correctly")
   end
 
   def test_search
     scope = mkscope
 
     fun = scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yay::ness")
     foo = scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "foo::bar")
 
     search = Puppet::Parser::Functions.function(:search)
     scope.function_search(["foo", "yay"])
 
     ffun = ffoo = nil
     assert_nothing_raised("Search path change did not work") do
       ffun = scope.find_definition("ness")
       ffoo = scope.find_definition('bar')
     end
 
     assert(ffun, "Could not find definition in 'fun' namespace")
     assert(ffoo, "Could not find definition in 'foo' namespace")
   end
 
   def test_include
     scope = mkscope
     parser = mkparser
 
     include = Puppet::Parser::Functions.function(:include)
 
     assert_raise(Puppet::Error, "did not throw error on missing class") do
       scope.function_include("nosuchclass")
     end
 
     scope.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "myclass", {})
 
     scope.compiler.expects(:evaluate_classes).with(%w{myclass otherclass}, scope, false).returns(%w{myclass otherclass})
 
     assert_nothing_raised do
       scope.function_include(["myclass", "otherclass"])
     end
   end
 
   def test_file
     parser = mkparser
     scope = mkscope(:parser => parser)
 
     file = Puppet::Parser::Functions.function(:file)
 
     file1 = tempfile
     file2 = tempfile
     file3 = tempfile
 
     File.open(file2, "w") { |f| f.puts "yaytest" }
 
     val = nil
     assert_nothing_raised("Failed to call file with one arg") do
       val = scope.function_file([file2])
     end
 
     assert_equal("yaytest\n", val, "file() failed")
 
     assert_nothing_raised("Failed to call file with two args") do
       val = scope.function_file([file1, file2])
     end
 
     assert_equal("yaytest\n", val, "file() failed")
 
     assert_raise(Puppet::ParseError, "did not fail when files are missing") do
       val = scope.function_file([file1, file3])
     end
   end
 
   def test_generate
     command = tempfile
     sh = %x{which sh}
     File.open(command, "w") do |f|
       f.puts %{#!#{sh}
       if [ -n "$1" ]; then
         echo "yay-$1"
       else
         echo yay
       fi
       }
     end
     File.chmod(0755, command)
     assert_equal("yay\n", %x{#{command}}, "command did not work")
     assert_equal("yay-foo\n", %x{#{command} foo}, "command did not work")
 
     Puppet::Node::Environment.stubs(:current).returns nil
     generate = Puppet::Parser::Functions.function(:generate)
 
     scope = mkscope
     parser = mkparser
 
     val = nil
     assert_nothing_raised("Could not call generator with no args") do
       val = scope.function_generate([command])
     end
     assert_equal("yay\n", val, "generator returned wrong results")
 
     assert_nothing_raised("Could not call generator with args") do
       val = scope.function_generate([command, "foo"])
     end
     assert_equal("yay-foo\n", val, "generator returned wrong results")
 
     assert_raise(Puppet::ParseError, "Did not fail with an unqualified path") do
       val = scope.function_generate([File.basename(command), "foo"])
     end
 
     assert_raise(Puppet::ParseError, "Did not fail when command failed") do
       val = scope.function_generate([%x{which touch}.chomp, "/this/dir/does/not/exist"])
     end
 
     fake = File.join(File.dirname(command), "..")
     dir = File.dirname(command)
     dirname = File.basename(dir)
     bad = File.join(dir, "..", dirname, File.basename(command))
     assert_raise(Puppet::ParseError, "Did not fail when command failed") do
       val = scope.function_generate([bad])
     end
   end
 end
 
diff --git a/test/language/scope.rb b/test/language/scope.rb
index c4154dc27..ccc359651 100755
--- a/test/language/scope.rb
+++ b/test/language/scope.rb
@@ -1,277 +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.setvar("first", "topval")
     scopes.each do |name, scope|
-      assert_equal("topval", scope.lookupvar("first", false), "Could not find var in #{name}")
+      assert_equal("topval", scope.lookupvar("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.setvar("second", "midval")
-    assert_equal(:undefined, scopes[:top].lookupvar("second", false), "Found child var in top scope")
+    assert_equal(:undefined, scopes[:top].lookupvar("second"), "Found child var in top scope")
     [:mid, :bot].each do |name|
-      assert_equal("midval", scopes[name].lookupvar("second", false), "Could not find var in #{name}")
+      assert_equal("midval", scopes[name].lookupvar("second"), "Could not find var in #{name}")
     end
 
     # And set something in the bottom, and make sure we only find it there.
     botscope.setvar("third", "botval")
     [:top, :mid].each do |name|
-      assert_equal(:undefined, scopes[name].lookupvar("third", false), "Found child var in top scope")
+      assert_equal(:undefined, scopes[name].lookupvar("third"), "Found child var in top scope")
     end
-    assert_equal("botval", scopes[:bot].lookupvar("third", false), "Could not find var in bottom scope")
+    assert_equal("botval", scopes[:bot].lookupvar("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.setvar("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.setvar("test","value")
     }
     assert_raise(Puppet::ParseError) {
       top.setvar("test","other")
     }
     assert_nothing_raised {
       sub.setvar("test","later")
     }
     assert_raise(Puppet::ParseError) {
       top.setvar("test","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.setvar("testing", :undef)
-
-
-      assert_equal(
-        :undef, scope.lookupvar("testing", false),
-
-      "undef was not returned as :undef when not string")
-
-
-        assert_equal(
-          "", scope.lookupvar("testing", true),
-
-      "undef was not returned as '' when string")
+    assert_equal(:undef, scope.lookupvar("testing"), "undef was not returned as :undef")
   end
 end