puppet 2.7.26 → 3.0.0.rc4

data/lib/puppet/parser/parser_support.rb

@@ -1,6 +1,10 @@
 # I pulled this into a separate file, because I got
 # tired of rebuilding the parser.rb file all the time.
+require 'forwardable'
+
 class Puppet::Parser::Parser
+  extend Forwardable
+
   require 'puppet/parser/functions'
   require 'puppet/parser/files'
   require 'puppet/resource/type_collection'
@@ -70,9 +74,7 @@ class Puppet::Parser::Parser
     raise except
   end
 
-  def file
-    @lexer.file
-  end
+  def_delegators :@lexer, :file, :string=
 
   def file=(file)
     unless FileTest.exist?(file)
@@ -86,31 +88,12 @@ class Puppet::Parser::Parser
     @lexer.file = file
   end
 
-  [:hostclass, :definition, :node, :nodes?].each do |method|
-    define_method(method) do |*args|
-      known_resource_types.send(method, *args)
-    end
-  end
-
-  def find_hostclass(namespace, name)
-    known_resource_types.find_hostclass(namespace, name)
-  end
-
-  def find_definition(namespace, name)
-    known_resource_types.find_definition(namespace, name)
-  end
+  def_delegators :known_resource_types, :hostclass, :definition, :node, :nodes?
+  def_delegators :known_resource_types, :find_hostclass, :find_definition
+  def_delegators :known_resource_types, :watch_file, :version
 
   def import(file)
-    if @lexer.file
-      # use a path relative to the file doing the importing
-      dir = File.dirname(@lexer.file)
-    else
-      # otherwise assume that everything needs to be from where the user is
-      # executing this command. Normally, this would be in a "puppet apply -e"
-      dir = Dir.pwd
-    end
-
-    known_resource_types.loader.import(file, dir)
+    known_resource_types.loader.import(file, @lexer.file)
   end
 
   def initialize(env)
@@ -160,31 +143,12 @@ class Puppet::Parser::Parser
       begin
         @yydebug = false
         main = yyparse(@lexer,:scan)
-      rescue Racc::ParseError => except
-        error = Puppet::ParseError.new(except)
-        error.line = @lexer.line
-        error.file = @lexer.file
-        error.set_backtrace except.backtrace
-        raise error
       rescue Puppet::ParseError => except
         except.line ||= @lexer.line
         except.file ||= @lexer.file
         raise except
-      rescue Puppet::Error => except
-        # and this is a framework error
-        except.line ||= @lexer.line
-        except.file ||= @lexer.file
-        raise except
-      rescue Puppet::DevError => except
-        except.line ||= @lexer.line
-        except.file ||= @lexer.file
-        raise except
       rescue => except
-        error = Puppet::DevError.new(except.message)
-        error.line = @lexer.line
-        error.file = @lexer.file
-        error.set_backtrace except.backtrace
-        raise error
+        raise Puppet::ParseError.new(except.message, @lexer.file, @lexer.line, except)
       end
     end
     # Store the results as the top-level class.
@@ -202,19 +166,4 @@ class Puppet::Parser::Parser
     # Then extract any types that were created.
     Puppet::Parser::AST::ASTArray.new :children => main_object.instance_eval { @__created_ast_objects__ }
   end
-
-  def string=(string)
-    @lexer.string = string
-  end
-
-  def version
-    known_resource_types.version
-  end
-
-  # Add a new file to be checked when we're checking to see if we should be
-  # reparsed.  This is basically only used by the TemplateWrapper to let the
-  # parser know about templates that should be parsed.
-  def watch_file(filename)
-    known_resource_types.watch_file(filename)
-  end
 end

data/lib/puppet/parser/relationship.rb

@@ -54,9 +54,7 @@ class Puppet::Parser::Relationship
       raise ArgumentError, "Could not find resource '#{target}' for relationship from '#{source}'"
     end
     Puppet.debug "Adding relationship from #{source} to #{target} with '#{param_name}'"
-    if source_resource[param_name].class != Array
-      source_resource[param_name] = [source_resource[param_name]].compact
-    end
+    source_resource[param_name] ||= []
     source_resource[param_name] << target
   end
 end

data/lib/puppet/parser/resource.rb

@@ -1,9 +1,12 @@
+require 'forwardable'
 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
+  extend Forwardable
+
   require 'puppet/parser/resource/param'
   require 'puppet/util/tagging'
   require 'puppet/parser/yaml_trimmer'
@@ -47,25 +50,19 @@ class Puppet::Parser::Resource < Puppet::Resource
     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
+  def_delegator :scope, :environment
 
   # Process the  stage metaparameter for a class.   A containment edge
   # is drawn from  the class to the stage.   The stage for containment
   # defaults to main, if none is specified.
   def add_edge_to_stage
-    return unless self.type.to_s.downcase == "class"
+    return unless self.class?
 
     unless stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
       raise ArgumentError, "Could not find stage #{self[:stage] || :main} specified by #{self}"
@@ -108,7 +105,6 @@ class Puppet::Parser::Resource < Puppet::Resource
     return if finished?
     @finished = true
     add_defaults
-    add_metaparams
     add_scope_tags
     validate
   end
@@ -119,6 +115,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   end
 
   def initialize(*args)
+    raise ArgumentError, "Resources require a hash as last argument" unless args.last.is_a? Hash
     raise ArgumentError, "Resources require a scope" unless args.last[:scope]
     super
 
@@ -148,9 +145,12 @@ class Puppet::Parser::Resource < Puppet::Resource
     end
   end
 
-  # Unless we're running >= 0.25, we're in compat mode.
+  # This only mattered for clients < 0.25, which we don't support any longer.
+  # ...but, since this hasn't been deprecated, and at least some functions
+  # used it, deprecate now rather than just eliminate. --daniel 2012-07-15
   def metaparam_compatibility_mode?
-    ! (catalog and ver = (catalog.client_version||'0.0.0').split(".") and (ver[0] > "0" or ver[1].to_i >= 25))
+    Puppet.deprecation_warning "metaparam_compatibility_mode? is obsolete since < 0.25 clients are really, really not supported any more"
+    false
   end
 
   def name
@@ -158,9 +158,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   end
 
   # A temporary occasion, until I get paths in the scopes figured out.
-  def path
-    to_s
-  end
+  alias path to_s
 
   # Define a parameter in our resource.
   # if we ever receive a parameter named 'tag', set
@@ -171,7 +169,7 @@ class Puppet::Parser::Resource < Puppet::Resource
         :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"
+      raise ArgumentError, "Received incomplete information - no value provided for parameter #{param}"
     end
 
     tag(*param.value) if param.name == :tag
@@ -179,6 +177,7 @@ class Puppet::Parser::Resource < Puppet::Resource
     # And store it in our parameter hash.
     @parameters[param.name] = param
   end
+  alias []= set_parameter
 
   def to_hash
     @parameters.inject({}) do |hash, ary|
@@ -213,10 +212,10 @@ class Puppet::Parser::Resource < Puppet::Resource
       # 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
+                    v[0]
+                  else
+                    v
+                  end
     end
 
     result.file = self.file
@@ -228,18 +227,8 @@ class Puppet::Parser::Resource < Puppet::Resource
     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
+  # Convert this resource to a RAL resource.
+  def_delegator :to_resource, :to_ral
 
   private
 
@@ -254,28 +243,6 @@ class Puppet::Parser::Resource < Puppet::Resource
     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) 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)
@@ -290,7 +257,6 @@ class Puppet::Parser::Resource < Puppet::Resource
 
     # 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
@@ -300,6 +266,7 @@ class Puppet::Parser::Resource < Puppet::Resource
         msg += " at #{fields.join(":")}"
       end
       msg += "; cannot redefine"
+      Puppet.log_exception(ArgumentError.new(), msg)
       raise Puppet::ParseError.new(msg, param.line, param.file)
     end
 
@@ -328,8 +295,6 @@ class Puppet::Parser::Resource < Puppet::Resource
     fail Puppet::ParseError, detail.to_s
   end
 
-  private
-
   def extract_parameters(params)
     params.each do |param|
       # Don't set the same parameter twice

data/lib/puppet/parser/scope.rb

@@ -1,14 +1,17 @@
 # The scope class, which handles storing and retrieving variables and types and
 # such.
+require 'forwardable'
 
 require 'puppet/parser/parser'
 require 'puppet/parser/templatewrapper'
-require 'puppet/transportable'
-require 'strscan'
 
 require 'puppet/resource/type_collection_helper'
+require 'puppet/util/methodhelper'
 
 class Puppet::Parser::Scope
+  extend Forwardable
+  include Puppet::Util::MethodHelper
+
   include Puppet::Resource::TypeCollectionHelper
   require 'puppet/parser/resource'
 
@@ -24,69 +27,90 @@ class Puppet::Parser::Scope
   attr_accessor :parent
   attr_reader :namespaces
 
+  # Add some alias methods that forward to the compiler, since we reference
+  # them frequently enough to justify the extra method call.
+  def_delegators :compiler, :catalog, :environment
+
   # thin wrapper around an ephemeral
   # symbol table.
   # when a symbol
   class Ephemeral
+    extend Forwardable
+
     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_delegators :@symbols, :include?, :delete, :[]=
 
     def [](name)
-      unless @symbols.include?(name) or @parent.nil?
-        @parent[name]
-      else
+      if @symbols.include?(name) or @parent.nil?
         @symbols[name]
+      else
+        @parent[name]
       end
     end
   end
 
-  # A demeterific shortcut to the catalog.
-  def catalog
-    compiler.catalog
+  # Initialize a new scope suitable for parser function testing.  This method
+  # should be considered a public API for external modules.  A shared spec
+  # helper should consume this API method.
+  def self.new_for_test_harness(node_name)
+    node = Puppet::Node.new(node_name)
+    compiler = Puppet::Parser::Compiler.new(node)
+    scope = new(compiler)
+    scope.source = Puppet::Resource::Type.new(:node, node_name)
+    scope.parent = compiler.topscope
+    scope
   end
 
-  def environment
-    compiler.environment
+  def each
+    to_hash.each { |name, value| yield(name, value) }
   end
 
   # Proxy accessors
   def host
-    @compiler.node.name
+    compiler.node.name
+  end
+
+  def facts
+    compiler.node.facts
+  end
+
+  def include?(name)
+    ! self[name].nil?
   end
 
   # Is the value true?  This allows us to control the definition of truth
   # in one place.
   def self.true?(value)
-    (value != false and value != "" and value != :undef)
+    case value
+    when ''
+      false
+    when :undef
+      false
+    else
+      !!value
+    end
   end
 
-  # Is the value a number?, return the correct object or nil if not a number
+  # Coerce value to a number, or return `nil` if it isn't one.
   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
+    case value
+    when Numeric
+      value
+    when /^-?\d+(:?\.\d+|(:?\.\d+)?e\d+)$/
+      value.to_f
+    when /^0x[0-9a-f]+$/i
+      value.to_i(16)
+    when /^0[0-7]+$/
+      value.to_i(8)
+    when /^-?\d+$/
+      value.to_i
+    else
+      nil
     end
-    # it is one of Fixnum,Bignum or Float
-    value
   end
 
   # Add to our list of namespaces.
@@ -99,41 +123,33 @@ class Puppet::Parser::Scope
     end
   end
 
-  # Remove this when rebasing
-  def environment
-    compiler ? compiler.environment : nil
-  end
-
-  def find_hostclass(name)
-    known_resource_types.find_hostclass(namespaces, name)
+  def find_hostclass(name, options = {})
+    known_resource_types.find_hostclass(namespaces, name, options)
   end
 
   def find_definition(name)
     known_resource_types.find_definition(namespaces, name)
   end
 
-  def findresource(string, name = nil)
-    compiler.findresource(string, name)
-  end
+  # This just delegates directly.
+  def_delegator :compiler, :findresource
 
   # 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)
+  def initialize(compiler, options = {})
+    if compiler.is_a? Puppet::Parser::Compiler
+      self.compiler = compiler
+    else
+      raise Puppet::DevError, "you must pass a compiler instance to a new scope object"
+    end
+
+    if n = options.delete(:namespace)
+      @namespaces = [n]
     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
-    }
+
+    raise Puppet::DevError, "compiler passed in options" if options.include? :compiler
+    set_options(options)
 
     extend_with_functions_module
 
@@ -164,8 +180,11 @@ class Puppet::Parser::Scope
   # 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
+    if parent
+      parent.class_set(name, scope)
+    else
+      @class_scopes[name] = scope
+    end
   end
 
   # Return the scope associated with a class.  This is just here so
@@ -186,7 +205,7 @@ class Puppet::Parser::Scope
     values = {}
 
     # first collect the values from the parents
-    unless parent.nil?
+    if parent
       parent.lookupdefaults(type).each { |var,value|
         values[var] = value
       }
@@ -200,8 +219,6 @@ class Puppet::Parser::Scope
       }
     end
 
-    #Puppet.debug "Got defaults for %s: %s" %
-    #    [type,values.inspect]
     values
   end
 
@@ -211,93 +228,64 @@ class Puppet::Parser::Scope
   end
 
   def undef_as(x,v)
-    (v == :undefined) ? x : (v == :undef) ? x : v
-  end
-
-  def qualified_scope(classname)
-    raise "class #{classname} could not be found"     unless klass = find_hostclass(classname)
-    raise "class #{classname} has not been evaluated" unless kscope = class_scope(klass)
-    kscope
-  end
-
-  private :qualified_scope
-
-  # Look up a variable with traditional scoping and then with new scoping. If
-  # the answers differ then print a deprecation warning.
-  def lookupvar(name, options = {})
-    dynamic_value = dynamic_lookupvar(name,options)
-    twoscope_value = twoscope_lookupvar(name,options)
-    if dynamic_value != twoscope_value
-      location = (options[:file] && options[:line]) ? " at #{options[:file]}:#{options[:line]}" : ''
-      Puppet.deprecation_warning("Dynamic lookup of $#{name}#{location} is deprecated. For more information, see http://docs.puppetlabs.com/guides/scope_and_puppet.html. To see the change in behavior, use the --debug flag.")
-      Puppet.debug("Currently $#{name} is #{dynamic_value.inspect}")
-      Puppet.debug("In the future $#{name} will be #{twoscope_value == :undefined ? "undefined" : twoscope_value.inspect}")
+    if v.nil? or v == :undef
+      x
+    else
+      v
     end
-    dynamic_value
   end
 
-  # Look up a variable.  The simplest value search we do.
-  def twoscope_lookupvar(name, options = {})
+  def lookupvar(name, options = {})
     # Save the originating scope for the request
     options[:origin] = self unless options[:origin]
     table = ephemeral?(name) ? @ephemeral.last : @symtable
 
     if name =~ /^(.*)::(.+)$/
       begin
-        qualified_scope($1).twoscope_lookupvar($2, options.merge({:origin => nil}))
+        qualified_scope($1).lookupvar($2, options.merge({:origin => nil}))
       rescue RuntimeError => e
-        location = (options[:file] && options[:line]) ? " at #{options[:file]}:#{options[:line]}" : ''
+        location = (options[:file] && (options[:line] || options[:lineproc])) ? " at #{options[:file]}:#{options[:line]|| options[:lineproc].call}" : ''
         warning "Could not look up qualified variable '#{name}'; #{e.message}#{location}"
-        :undefined
+        nil
       end
     # If the value is present and either we are top/node scope or originating scope...
     elsif (ephemeral_include?(name) or table.include?(name)) and (compiler and self == compiler.topscope or (resource and resource.type == "Node") or self == options[:origin])
       table[name]
     elsif resource and resource.type == "Class" and parent_type = resource.resource_type.parent
-      qualified_scope(parent_type).twoscope_lookupvar(name,options.merge({:origin => nil}))
+      qualified_scope(parent_type).lookupvar(name, options.merge({:origin => nil}))
     elsif parent
-      parent.twoscope_lookupvar(name, options)
+      parent.lookupvar(name, options)
     else
-      :undefined
+      nil
     end
   end
+  alias [] lookupvar
 
-  # Look up a variable.  The simplest value search we do.
-  def dynamic_lookupvar(name, options = {})
-    table = ephemeral?(name) ? @ephemeral.last : @symtable
-    # If the variable is qualified, then find the specified scope and look the variable up there instead.
-    if name =~ /^(.*)::(.+)$/
-      begin
-        qualified_scope($1).dynamic_lookupvar($2,options)
-      rescue RuntimeError => e
-        location = (options[:file] && options[:line]) ? " at #{options[:file]}:#{options[:line]}" : ''
-        warning "Could not look up qualified variable '#{name}'; #{e.message}#{location}"
-        :undefined
-      end
-    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.dynamic_lookupvar(name,options)
-    else
-      :undefined
-    end
+  def qualified_scope(classname)
+    raise "class #{classname} could not be found"     unless klass = find_hostclass(classname)
+    raise "class #{classname} has not been evaluated" unless kscope = class_scope(klass)
+    kscope
   end
+  private :qualified_scope
 
   # 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 recursive and parent
+      target = parent.to_hash(recursive)
+    else
+      target = Hash.new
+    end
+
+    @symtable.each do |name, value|
       if value == :undef
         target.delete(name)
       else
         target[name] = value
       end
-    }
+    end
+
     target
   end
 
@@ -316,28 +304,16 @@ class Puppet::Parser::Scope
     @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)
+  def define_settings(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
@@ -348,60 +324,60 @@ class Puppet::Parser::Scope
   # 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 = {})
+  #   It's preferred that you use self[]= instead of this; only use this
+  # when you need to set options.
+  def setvar(name, value, options = {})
     table = options[:ephemeral] ? @ephemeral.last : @symtable
     if table.include?(name)
-      unless options[:append]
-        error = Puppet::ParseError.new("Cannot reassign variable #{name}")
-      else
+      if options[:append]
         error = Puppet::ParseError.new("Cannot append, variable #{name} is defined in this scope")
+      else
+        error = Puppet::ParseError.new("Cannot reassign variable #{name}")
       end
       error.file = options[:file] if options[:file]
       error.line = options[:line] if options[:line]
       raise error
     end
 
-    unless options[:append]
+    if options[:append]
+      table[name] = append_value(undef_as('', self[name]), value)
+    else 
       table[name] = value
-    else # append case
-      # lookup the value in the scope if it exists and insert the var
-      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
+  alias []= setvar
 
-  # 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
+  def append_value(bound_value, new_value)
+    case new_value
+    when Array
+      bound_value + new_value
+    when Hash
+      bound_value.merge(new_value)
+    else
+      if bound_value.is_a?(Hash)
+        raise ArgumentError, "Trying to append to a hash with something which is not a hash is unsupported" 
+      end
+      bound_value + new_value
+    end
   end
+  private :append_value
+
+  # Return the tags associated with this scope.
+  def_delegator :resource, :tags
 
   # 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
+      # If we ever drop 1.8.6 and lower, this should be replaced by a single
+      # pop-with-a-count - or if someone more ambitious wants to monkey-patch
+      # that feature into older rubies. --daniel 2012-07-16
       (@ephemeral.size - level).times do
         @ephemeral.pop
       end
@@ -410,10 +386,7 @@ class Puppet::Parser::Scope
 
   # 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
+    @ephemeral.any? {|eph| eph.include?(name) }
   end
 
   # is name an ephemeral variable?
@@ -492,6 +465,6 @@ class Puppet::Parser::Scope
 
   def extend_with_functions_module
     extend Puppet::Parser::Functions.environment_module(Puppet::Node::Environment.root)
-    extend Puppet::Parser::Functions.environment_module(environment)
+    extend Puppet::Parser::Functions.environment_module(environment) if environment != Puppet::Node::Environment.root
   end
 end