puppet 3.4.3 → 3.5.0.rc1

data/lib/puppet/parser/parser_factory.rb

@@ -11,7 +11,11 @@ module Puppet::Parser
     def self.parser(environment)
       case Puppet[:parser]
       when 'future'
-        eparser(environment)
+        if Puppet[:evaluator] == 'future'
+          evaluating_parser(environment)
+        else
+          eparser(environment)
+        end
       else
         classic_parser(environment)
       end
@@ -21,9 +25,21 @@ module Puppet::Parser
     #
     def self.classic_parser(environment)
       require 'puppet/parser'
+
       Puppet::Parser::Parser.new(environment)
     end
 
+    # Returns an instance of an EvaluatingParser
+    def self.evaluating_parser(file_watcher)
+      # Since RGen is optional, test that it is installed
+      @@asserted ||= false
+      assert_rgen_installed() unless @@asserted
+      @@asserted = true
+      require 'puppet/parser/e4_parser_adapter'
+      require 'puppet/pops/parser/code_merger'
+      E4ParserAdapter.new(file_watcher)
+    end
+
     # Creates an instance of the expression based parser 'eparser'
     #
     def self.eparser(environment)
@@ -58,6 +74,15 @@ module Puppet::Parser
         raise Puppet::DevError.new("The gem 'rgen' version >= 0.6.1 is required when using '--parser future'. An older version is installed, please update.")
       end
     end
+
+    def self.code_merger
+      if Puppet[:parser] == 'future' && Puppet[:evaluator] == 'future'
+        Puppet::Pops::Parser::CodeMerger.new
+      else
+        Puppet::Parser::CodeMerger.new
+      end
+    end
+
   end
 
 end

data/lib/puppet/parser/parser_support.rb

@@ -82,12 +82,12 @@ class Puppet::Parser::Parser
   def_delegators :@lexer, :file, :string=
 
   def file=(file)
-    unless Puppet::FileSystem::File.exist?(file)
+    unless Puppet::FileSystem.exist?(file)
       unless file =~ /\.pp$/
         file = file + ".pp"
       end
     end
-    raise Puppet::AlreadyImportedError, "Import loop detected" if known_resource_types.watching_file?(file)
+    raise Puppet::AlreadyImportedError, "Import loop detected for #{file}" if known_resource_types.watching_file?(file)
 
     watch_file(file)
     @lexer.file = file
@@ -98,6 +98,16 @@ class Puppet::Parser::Parser
   def_delegators :known_resource_types, :watch_file, :version
 
   def import(file)
+    deprecation_location_text =
+    if @lexer.file && @lexer.line
+      " at #{@lexer.file}:#{@lexer.line}"
+    elsif @lexer.file
+      " in file #{@lexer.file}"
+    elsif @lexer.line
+      " at #{@lexer.line}"
+    end
+
+    Puppet.deprecation_warning("The use of 'import' is deprecated#{deprecation_location_text}. See http://links.puppetlabs.com/puppet-import-deprecation")
     if @lexer.file
       # use a path relative to the file doing the importing
       dir = File.dirname(@lexer.file)
@@ -111,8 +121,7 @@ class Puppet::Parser::Parser
   end
 
   def initialize(env)
-    # The environment is needed to know how to find the resource type collection.
-    @environment = env.is_a?(String) ? Puppet::Node::Environment.new(env) : env
+    @environment = env
     initvars
   end
 

data/lib/puppet/parser/resource.rb

@@ -253,7 +253,7 @@ class Puppet::Parser::Resource < Puppet::Resource
       validate_parameter(name)
     end
   rescue => detail
-    fail Puppet::ParseError, detail.to_s
+    self.fail Puppet::ParseError, detail.to_s, detail
   end
 
   def extract_parameters(params)

data/lib/puppet/parser/scope.rb

@@ -24,11 +24,9 @@ class Puppet::Parser::Scope
 
   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 :compiler
   attr_accessor :parent
   attr_reader :namespaces
 
@@ -36,95 +34,160 @@ class Puppet::Parser::Scope
   # them frequently enough to justify the extra method call.
   def_delegators :compiler, :catalog, :environment
 
-  # thin wrapper around an ephemeral
-  # symbol table.
-  # when a symbol
+
+  # Abstract base class for LocalScope and MatchScope
+  #
   class Ephemeral
-    extend Forwardable
 
-    def initialize(parent=nil, local=false)
-      @symbols = {}
+    attr_reader :parent
+
+    def initialize(parent = nil)
       @parent = parent
-      @local_scope = local
     end
 
-    def_delegators :@symbols, :delete, :[]=, :each
+    def is_local_scope?
+      false
+    end
 
     def [](name)
-      if @symbols.include?(name) or @parent.nil?
-        @symbols[name]
-      else
+      if @parent
         @parent[name]
       end
     end
 
     def include?(name)
-      bound?(name) or (@parent and @parent.include?(name))
+      (@parent and @parent.include?(name))
     end
 
     def bound?(name)
-      @symbols.include?(name)
+      false
+    end
+
+    def add_entries_to(target = {})
+      @parent.add_entries_to(target) unless @parent.nil?
+      # do not include match data ($0-$n)
+      target
+    end
+  end
+
+  class LocalScope < Ephemeral
+
+    def initialize(parent=nil)
+      super parent
+      @symbols = {}
+    end
+
+    def [](name)
+      if @symbols.include?(name)
+        @symbols[name]
+      else
+        super
+      end
     end
 
     def is_local_scope?
-      @local_scope
+      true
+    end
+
+    def []=(name, value)
+      @symbols[name] = value
+    end
+
+    def include?(name)
+      bound?(name) || super
+    end
+
+    def delete(name)
+      @symbols.delete(name)
     end
 
-    # @return [Ephemeral, Hash, nil]
-    def parent
-      @parent
+    def bound?(name)
+      @symbols.include?(name)
     end
 
     def add_entries_to(target = {})
-      @parent.add_entries_to(target) unless @parent.nil?
-      # do not return pure ephemeral ($0-$n)
-      if is_local_scope?
-        @symbols.each do |k, v|
-          if v == :undef
-            target.delete(k)
-          else
-            target[ k ] = v
-          end
+      super
+      @symbols.each do |k, v|
+        if v == :undef
+          target.delete(k)
+        else
+          target[ k ] = v
         end
       end
       target
     end
-
   end
 
-  # 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.
-  #
-  # @api protected
-  #
-  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
+  class MatchScope < Ephemeral
+
+    attr_accessor :match_data
+
+    def initialize(parent = nil, match_data = nil)
+      super parent
+      @match_data = match_data
+    end
+
+    def is_local_scope?
+      false
+    end
+
+    def [](name)
+      if bound?(name)
+        @match_data[name.to_i]
+      else
+        super
+      end
+    end
+
+    def include?(name)
+      bound?(name) or super
+    end
+
+    def bound?(name)
+      # A "match variables" scope reports all numeric variables to be bound if the scope has
+      # match_data. Without match data the scope is transparent.
+      #
+      @match_data && name =~ /^\d+$/
+    end
+
+    def []=(name, value)
+      # TODO: Bad choice of exception
+      raise Puppet::ParseError, "Numerical variables cannot be changed. Attempt to set $#{name}"
+    end
+
+    def delete(name)
+      # TODO: Bad choice of exception
+      raise Puppet::ParseError, "Numerical variables cannot be deleted: Attempt to delete: $#{name}"
+    end
+
+    def add_entries_to(target = {})
+      # do not include match data ($0-$n)
+      super
+    end
 
-  def each
-    to_hash.each { |name, value| yield(name, value) }
   end
 
-  # Proxy accessors
-  def host
-    compiler.node.name
+  # Returns true if the variable of the given name has a non nil value.
+  # TODO: This has vague semantics - does the variable exist or not?
+  #       use ['name'] to get nil or value, and if nil check with exist?('name')
+  #       this include? is only useful because of checking against the boolean value false.
+  #
+  def include?(name)
+    ! self[name].nil?
   end
 
-  # TODO: 19514 - this is smelly; who uses this? functions? templates?
-  # What about trusted facts ? Should untrusted facts be removed from facts?
+  # Returns true if the variable of the given name is set to any value (including nil)
   #
-  def facts
-    compiler.node.facts
+  def exist?(name)
+    next_scope = inherited_scope || enclosing_scope
+    effective_symtable(true).include?(name) || next_scope && next_scope.exist?(name)
   end
 
-  def include?(name)
-    ! self[name].nil?
+  # Returns true if the given name is bound in the current (most nested) scope for assignments.
+  #
+  def bound?(name)
+    # Do not look in ephemeral (match scope), the semantics is to answer if an assignable variable is bound
+    effective_symtable(false).bound?(name)
   end
 
   # Is the value true?  This allows us to control the definition of truth
@@ -176,6 +239,22 @@ class Puppet::Parser::Scope
     known_resource_types.find_definition(namespaces, name)
   end
 
+  def find_global_scope()
+    # walk upwards until first found node_scope or top_scope
+    if is_nodescope? || is_topscope?
+      self
+    else
+      next_scope = inherited_scope || enclosing_scope
+      if next_scope.nil?
+        # this happens when testing, and there is only a single test scope and no link to any
+        # other scopes
+        self
+      else
+        next_scope.find_global_scope()
+      end
+    end
+  end
+
   # This just delegates directly.
   def_delegator :compiler, :findresource
 
@@ -199,9 +278,10 @@ class Puppet::Parser::Scope
     extend_with_functions_module
 
     # The symbol table for this scope.  This is where we store variables.
-    @symtable = Ephemeral.new(nil, true)
+    #    @symtable = Ephemeral.new(nil, true)
+    @symtable = LocalScope.new(nil)
 
-    @ephemeral = [ Ephemeral.new(@symtable) ]
+    @ephemeral = [ MatchScope.new(@symtable, nil) ]
 
     # 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
@@ -213,6 +293,8 @@ class Puppet::Parser::Scope
     # The table for storing class singletons.  This will only actually
     # be used by top scopes and node scopes.
     @class_scopes = {}
+
+    @enable_immutable_data = Puppet[:immutable_node_data]
   end
 
   # Store the fact that we've evaluated a class, and store a reference to
@@ -293,6 +375,8 @@ class Puppet::Parser::Scope
       class_name = $1
       variable_name = $2
       lookup_qualified_variable(class_name, variable_name, options)
+
+    # TODO: optimize with an assoc instead, this searches through scopes twice for a hit
     elsif table.include?(name)
       table[name]
     else
@@ -300,11 +384,23 @@ class Puppet::Parser::Scope
       if next_scope
         next_scope.lookupvar(name, options)
       else
-        nil
+        variable_not_found(name)
       end
     end
   end
 
+  def variable_not_found(name, reason=nil)
+    if Puppet[:strict_variables]
+      if Puppet[:evaluator] == 'future' && Puppet[:parser] == 'future'
+        throw :undefined_variable
+      else
+        reason_msg = reason.nil? ? '' : "; #{reason}"
+        raise Puppet::ParseError, "Undefined variable #{name.inspect}#{reason_msg}"
+      end
+    else
+      nil
+    end
+  end
   # Retrieves the variable value assigned to the name given as an argument. The name must be a String,
   # and namespace can be qualified with '::'. The value is looked up in this scope, its parent scopes,
   # or in a specific visible named scope.
@@ -370,15 +466,18 @@ class Puppet::Parser::Scope
         qualified_scope(class_name).lookupvar(variable_name, position)
       end
     rescue RuntimeError => e
-      location = if position[:lineproc]
-                   " at #{position[:lineproc].call}"
-                 elsif position[:file] && position[:line]
-                   " at #{position[:file]}:#{position[:line]}"
-                 else
-                   ""
-                 end
-      warning "Could not look up qualified variable '#{class_name}::#{variable_name}'; #{e.message}#{location}"
-      nil
+      unless Puppet[:strict_variables]
+        # Do not issue warning if strict variables are on, as an error will be raised by variable_not_found
+        location = if position[:lineproc]
+                     " at #{position[:lineproc].call}"
+                   elsif position[:file] && position[:line]
+                     " at #{position[:file]}:#{position[:line]}"
+                   else
+                     ""
+                   end
+        warning "Could not look up qualified variable '#{class_name}::#{variable_name}'; #{e.message}#{location}"
+      end
+      variable_not_found("#{class_name}::#{variable_name}", e.message)
     end
   end
 
@@ -418,9 +517,43 @@ class Puppet::Parser::Scope
   # by default) including the values defined in parent. Local values
   # shadow parent values. Ephemeral scopes for match results ($0 - $n) are not included.
   #
+  # This is currently a wrapper for to_hash_legacy or to_hash_future.
+  #
+  # @see to_hash_future
+  #
+  # @see to_hash_legacy
   def to_hash(recursive = true)
+    @parser ||= Puppet[:parser]
+    if @parser == 'future'
+      to_hash_future(recursive)
+    else
+      to_hash_legacy(recursive)
+    end
+  end
+
+  # Fixed version of to_hash that implements scoping correctly (i.e., with
+  # dynamic scoping disabled #28200 / PUP-1220
+  #
+  # @see to_hash
+  def to_hash_future(recursive)
+    if recursive and has_enclosing_scope?
+      target = enclosing_scope.to_hash_future(recursive)
+    else
+      target = Hash.new
+    end
+
+    # add all local scopes
+    @ephemeral.last.add_entries_to(target)
+    target
+  end
+
+  # The old broken implementation of to_hash that retains the dynamic scoping
+  # semantics
+  #
+  # @see to_hash
+  def to_hash_legacy(recursive = true)
     if recursive and parent
-      target = parent.to_hash(recursive)
+      target = parent.to_hash_legacy(recursive)
     else
       target = Hash.new
     end
@@ -462,7 +595,7 @@ class Puppet::Parser::Scope
     }
   end
 
-  RESERVED_VARIABLE_NAMES = ['trusted'].freeze
+  RESERVED_VARIABLE_NAMES = ['trusted', 'facts'].freeze
 
   # Set a variable in the current scope.  This will override settings
   # in scopes above, but will not allow variables in the current scope
@@ -471,14 +604,14 @@ class Puppet::Parser::Scope
   # when you need to set options.
   def setvar(name, value, options = {})
     if name =~ /^[0-9]+$/
-      raise Puppet::ParseError.new("Cannot assign to a numeric match result variable '$#{name}'") unless options[:ephemeral]
+      raise Puppet::ParseError.new("Cannot assign to a numeric match result variable '$#{name}'") # unless options[:ephemeral]
     end
     unless name.is_a? String
       raise Puppet::ParseError, "Scope variable name #{name.inspect} is a #{name.class}, not a string"
     end
 
     # Check for reserved variable names
-    if Puppet[:trusted_node_data] && !options[:privileged] && RESERVED_VARIABLE_NAMES.include?(name)
+    if @enable_immutable_data && !options[:privileged] && RESERVED_VARIABLE_NAMES.include?(name)
       raise Puppet::ParseError, "Attempt to assign to a reserved variable name: '#{name}'"
     end
 
@@ -506,20 +639,28 @@ class Puppet::Parser::Scope
     setvar('trusted', deep_freeze(hash), :privileged => true)
   end
 
+  def set_facts(hash)
+    setvar('facts', deep_freeze(hash), :privileged => true)
+  end
+
   # Deeply freezes the given object. The object and its content must be of the types:
   # Array, Hash, Numeric, Boolean, Symbol, Regexp, NilClass, or String. All other types raises an Error.
   # (i.e. if they are assignable to Puppet::Pops::Types::Data type).
   #
   def deep_freeze(object)
     case object
+    when Array
+      object.each {|v| deep_freeze(v) }
+      object.freeze
     when Hash
       object.each {|k, v| deep_freeze(k); deep_freeze(v) }
-    when NilClass
+      object.freeze
+    when NilClass, Numeric, TrueClass, FalseClass
       # do nothing
     when String
       object.freeze
     else
-      raise Puppet::Error, "Unsupported data type: '#{object.class}"
+      raise Puppet::Error, "Unsupported data type: '#{object.class}'"
     end
     object
   end
@@ -533,8 +674,9 @@ class Puppet::Parser::Scope
   # @param use_ephemeral [Boolean] whether the top most ephemeral (of any kind) should be used or not
   def effective_symtable use_ephemeral
     s = @ephemeral.last
-    return s if use_ephemeral
+    return s || @symtable if use_ephemeral
 
+    # Why check if ephemeral is a Hash ??? Not needed, a hash cannot be a parent scope ???
     while s && !(s.is_a?(Hash) || s.is_local_scope?())
       s = s.parent
     end
@@ -580,49 +722,54 @@ class Puppet::Parser::Scope
   end
 
   # remove ephemeral scope up to level
+  # TODO: Who uses :all ? Remove ??
+  #
   def unset_ephemeral_var(level=:all)
     if level == :all
-      @ephemeral = [ Ephemeral.new(@symtable)]
+      @ephemeral = [ MatchScope.new(@symtable, nil)]
     else
       @ephemeral.pop(@ephemeral.size - level)
     end
   end
 
-  # check if name exists in one of the ephemeral scopes.
-  def ephemeral_include?(name)
-    @ephemeral.any? {|eph| eph.include?(name) }
+  def ephemeral_level
+    @ephemeral.size
   end
 
-  # Checks whether the variable should be processed in the ephemeral scope or not.
-  # All numerical variables are processed in ephemeral scope at all times, and all other
-  # variables when the ephemeral scope is a local scope.
-  #
-  def ephemeral?(name)
-    @ephemeral.last.is_local_scope? || name =~ /^\d+$/
+  # TODO: Who calls this?
+  def new_ephemeral(local_scope = false)
+    if local_scope
+      @ephemeral.push(LocalScope.new(@ephemeral.last))
+    else
+      @ephemeral.push(MatchScope.new(@ephemeral.last, nil))
+    end
   end
 
-  def ephemeral_level
-    @ephemeral.size
+  # Sets match data in the most nested scope (which always is a MatchScope), it clobbers match data already set there
+  #
+  def set_match_data(match_data)
+    @ephemeral.last.match_data = match_data
   end
 
-  def new_ephemeral(local_scope = false)
-    @ephemeral.push(Ephemeral.new(@ephemeral.last, local_scope))
+  # Nests a match data scope
+  def new_match_scope(match_data)
+    @ephemeral.push(MatchScope.new(@ephemeral.last, match_data))
   end
 
   def ephemeral_from(match, file = nil, line = nil)
     case match
     when Hash
       # Create local scope ephemeral and set all values from hash
-      new_ephemeral true
+      new_ephemeral(true)
       match.each {|k,v| setvar(k, v, :file => file, :line => line, :ephemeral => true) }
+      # Must always have an inner match data scope (that starts out as transparent)
+      # In 3x slightly wasteful, since a new nested scope is created for a match 
+      # (TODO: Fix that problem)
+      new_ephemeral(false)
     else
       raise(ArgumentError,"Invalid regex match data. Got a #{match.class}") unless match.is_a?(MatchData)
       # Create a match ephemeral and set values from match data
-      new_ephemeral false
-      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
+      new_match_scope(match)
     end
   end
 
@@ -637,9 +784,10 @@ class Puppet::Parser::Scope
   end
 
   def find_defined_resource_type(type)
-    environment.known_resource_types.find_definition(namespaces, type.to_s.downcase)
+    known_resource_types.find_definition(namespaces, type.to_s.downcase)
   end
 
+
   def method_missing(method, *args, &block)
     method.to_s =~ /^function_(.*)$/
     name = $1
@@ -678,7 +826,8 @@ class Puppet::Parser::Scope
   private
 
   def extend_with_functions_module
-    extend Puppet::Parser::Functions.environment_module(Puppet::Node::Environment.root)
-    extend Puppet::Parser::Functions.environment_module(environment) if environment != Puppet::Node::Environment.root
+    root = Puppet.lookup(:root_environment)
+    extend Puppet::Parser::Functions.environment_module(root)
+    extend Puppet::Parser::Functions.environment_module(environment) if environment != root
   end
 end