puppet 3.1.1 → 3.2.0.rc1

data/lib/puppet/parser/parser_factory.rb

@@ -0,0 +1,62 @@
+module Puppet; end
+
+module Puppet::Parser
+  # The ParserFactory makes selection of parser possible.
+  # Currently, it is possible to switch between two different parsers:
+  # * classic_parser, the parser in 3.1
+  # * eparser, the Expression Based Parser
+  #
+  class ParserFactory
+    # Produces a parser instance for the given environment
+    def self.parser(environment)
+      case Puppet[:parser]
+      when 'future'
+        eparser(environment)
+      else
+        classic_parser(environment)
+      end
+    end
+
+    # Creates an instance of the classic parser.
+    #
+    def self.classic_parser(environment)
+      require 'puppet/parser'
+      Puppet::Parser::Parser.new(environment)
+    end
+
+    # Creates an instance of the expression based parser 'eparser'
+    #
+    def self.eparser(environment)
+      # Since RGen is optional, test that it is installed
+      @@asserted ||= false
+      assert_rgen_installed() unless @asserted
+      require 'puppet/parser'
+      require 'puppet/parser/e_parser_adapter'
+      EParserAdapter.new(Puppet::Parser::Parser.new(environment))
+    end
+
+    private
+
+    def self.assert_rgen_installed
+      begin
+        require 'rgen/metamodel_builder'
+      rescue LoadError
+        raise Puppet::DevError.new("The gem 'rgen' version >= 0.6.1 is required when using the setting '--parser future'. Please install 'rgen'.")
+      end
+      # Since RGen is optional, there is nothing specifying its version.
+      # It is not installed in any controlled way, so not possible to use gems to check (it may be installed some other way).
+      # Instead check that "eContainer, and eContainingFeature" has been installed.
+      require 'puppet/pops'
+      begin
+        litstring = Puppet::Pops::Model::LiteralString.new();
+        container = Puppet::Pops::Model::ArithmeticExpression.new();
+        container.left_expr = litstring
+        raise "no eContainer" if litstring.eContainer() != container
+        raise "no eContainingFeature" if litstring.eContainingFeature() != :left_expr
+      rescue =>e
+        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
+  end
+
+end

data/lib/puppet/parser/parser_support.rb

@@ -38,6 +38,11 @@ class Puppet::Parser::Parser
     ast AST::ASTArray, :children => [arg]
   end
 
+  # Create an AST block containing a single element
+  def block(arg)
+    ast AST::BlockExpression, :children => [arg]
+  end
+
   # Create an AST object, and automatically add the file and line information if
   # available.
   def ast(klass, hash = {})
@@ -146,9 +151,10 @@ class Puppet::Parser::Parser
       rescue Puppet::ParseError => except
         except.line ||= @lexer.line
         except.file ||= @lexer.file
+        except.pos ||= @lexer.pos
         raise except
       rescue => except
-        raise Puppet::ParseError.new(except.message, @lexer.file, @lexer.line, except)
+        raise Puppet::ParseError.new(except.message, @lexer.file, @lexer.line, nil, except)
       end
     end
     # Store the results as the top-level class.
@@ -166,6 +172,6 @@ class Puppet::Parser::Parser
     main_object.instance_eval(File.read(self.file))
 
     # Then extract any types that were created.
-    Puppet::Parser::AST::ASTArray.new :children => main_object.instance_eval { @__created_ast_objects__ }
+    Puppet::Parser::AST::BlockExpression.new :children => main_object.instance_eval { @__created_ast_objects__ }
   end
 end

data/lib/puppet/parser/scope.rb

@@ -2,7 +2,7 @@
 # such.
 require 'forwardable'
 
-require 'puppet/parser/parser'
+require 'puppet/parser'
 require 'puppet/parser/templatewrapper'
 
 require 'puppet/resource/type_collection_helper'
@@ -42,12 +42,13 @@ class Puppet::Parser::Scope
   class Ephemeral
     extend Forwardable
 
-    def initialize(parent=nil)
+    def initialize(parent=nil, local=false)
       @symbols = {}
       @parent = parent
+      @local_scope = local
     end
 
-    def_delegators :@symbols, :include?, :delete, :[]=
+    def_delegators :@symbols, :delete, :[]=, :each
 
     def [](name)
       if @symbols.include?(name) or @parent.nil?
@@ -56,6 +57,23 @@ class Puppet::Parser::Scope
         @parent[name]
       end
     end
+
+    def include?(name)
+      bound?(name) or (@parent and @parent.include?(name))
+    end
+
+    def bound?(name)
+      @symbols.include?(name)
+    end
+
+    def is_local_scope?
+      @local_scope
+    end
+
+    # @return [Ephemeral, Hash, nil]
+    def parent
+      @parent
+    end
   end
 
   # Initialize a new scope suitable for parser function testing.  This method
@@ -164,14 +182,9 @@ class Puppet::Parser::Scope
     @tags = []
 
     # The symbol table for this scope.  This is where we store variables.
-    @symtable = {}
+    @symtable = Ephemeral.new
 
-    # 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 ]
+    @ephemeral = [ Ephemeral.new(@symtable) ]
 
     # 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
@@ -257,27 +270,21 @@ class Puppet::Parser::Scope
       raise Puppet::DevError, "Scope variable name is a #{name.class}, not a string"
     end
 
-    # Save the originating scope for the request
-    options[:origin] = self unless options[:origin]
-    table = ephemeral?(name) ? @ephemeral.last : @symtable
+    table = @ephemeral.last
 
     if name =~ /^(.*)::(.+)$/
-      begin
-        qualified_scope($1).lookupvar($2, options.merge({:origin => nil}))
-      rescue RuntimeError => e
-        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}"
-        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])
+      class_name = $1
+      variable_name = $2
+      lookup_qualified_variable(class_name, variable_name, options)
+    elsif table.include?(name)
       table[name]
-    elsif resource and resource.type == "Class" and parent_type = resource.resource_type.parent
-      qualified_scope(parent_type).lookupvar(name, options.merge({:origin => nil}))
-    elsif parent
-      parent.lookupvar(name, options)
     else
-      nil
+      next_scope = inherited_scope || enclosing_scope
+      if next_scope
+        next_scope.lookupvar(name, options)
+      else
+        nil
+      end
     end
   end
 
@@ -295,6 +302,75 @@ class Puppet::Parser::Scope
     lookupvar(varname, options)
   end
 
+  # The scope of the inherited thing of this scope's resource. This could
+  # either be a node that was inherited or the class.
+  #
+  # @returns [Puppet::Parser::Scope] The scope or nil if there is not an inherited scope
+  def inherited_scope
+    if has_inherited_class?
+      qualified_scope(resource.resource_type.parent)
+    else
+      nil
+    end
+  end
+
+  # The enclosing scope (topscope or nodescope) of this scope.
+  # The enclosing scopes are produced when a class or define is included at
+  # some point. The parent scope of the included class or define becomes the
+  # scope in which it was included. The chain of parent scopes is followed
+  # until a node scope or the topscope is found
+  #
+  # @returns [Puppet::Parser::Scope] The scope or nil if there is no enclosing scope
+  def enclosing_scope
+    if has_enclosing_scope?
+      if parent.is_topscope? or parent.is_nodescope?
+        parent
+      else
+        parent.enclosing_scope
+      end
+    else
+      nil
+    end
+  end
+
+  def is_classscope?
+    resource and resource.type == "Class"
+  end
+
+  def is_nodescope?
+    resource and resource.type == "Node"
+  end
+
+  def is_topscope?
+    compiler and self == compiler.topscope
+  end
+
+  def lookup_qualified_variable(class_name, variable_name, position)
+    begin
+      qualified_scope(class_name).lookupvar(variable_name, position)
+    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
+    end
+  end
+
+  def has_inherited_class?
+    is_classscope? and resource.resource_type.parent
+  end
+  private :has_inherited_class?
+
+  def has_enclosing_scope?
+    not parent.nil?
+  end
+  private :has_enclosing_scope?
+
   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)
@@ -361,12 +437,15 @@ class Puppet::Parser::Scope
   #   It's preferred that you use self[]= instead of this; only use this
   # 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]
+    end
     unless name.is_a? String
       raise Puppet::DevError, "Scope variable name is a #{name.class}, not a string"
     end
 
-    table = options[:ephemeral] ? @ephemeral.last : @symtable
-    if table.include?(name)
+    table = effective_symtable options[:ephemeral]
+    if table.bound?(name)
       if options[:append]
         error = Puppet::ParseError.new("Cannot append, variable #{name} is defined in this scope")
       else
@@ -379,9 +458,26 @@ class Puppet::Parser::Scope
 
     if options[:append]
       table[name] = append_value(undef_as('', self[name]), value)
-    else 
+    else
       table[name] = value
     end
+    table[name]
+  end
+
+  # Return the effective "table" for setting variables.
+  # This method returns the first ephemeral "table" that acts as a local scope, or this
+  # scope's symtable. If the parameter `use_ephemeral` is true, the "top most" ephemeral "table"
+  # will be returned (irrespective of it being a match scope or a local scope).
+  #
+  # @param [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
+
+    while s && !(s.is_a?(Hash) || s.is_local_scope?())
+      s = s.parent
+    end
+    s ? s : @symtable
   end
 
   # Sets the variable value of the name given as an argument to the given value. The value is
@@ -407,7 +503,7 @@ class Puppet::Parser::Scope
       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" 
+        raise ArgumentError, "Trying to append to a hash with something which is not a hash is unsupported"
       end
       bound_value + new_value
     end
@@ -425,7 +521,7 @@ class Puppet::Parser::Scope
   # remove ephemeral scope up to level
   def unset_ephemeral_var(level=:all)
     if level == :all
-      @ephemeral = [ Ephemeral.new ]
+      @ephemeral = [ Ephemeral.new(@symtable)]
     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
@@ -436,32 +532,41 @@ class Puppet::Parser::Scope
     end
   end
 
-  # check if name exists in one of the ephemeral scope.
+  # check if name exists in one of the ephemeral scopes.
   def ephemeral_include?(name)
     @ephemeral.any? {|eph| eph.include?(name) }
   end
 
-  # is name an ephemeral variable?
+  # 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)
-    name =~ /^\d+$/
+    @ephemeral.last.is_local_scope? || name =~ /^\d+$/
   end
 
   def ephemeral_level
     @ephemeral.size
   end
 
-  def new_ephemeral
-    @ephemeral.push(Ephemeral.new(@ephemeral.last))
+  def new_ephemeral(local_scope = false)
+    @ephemeral.push(Ephemeral.new(@ephemeral.last, local_scope))
   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)
+    case match
+    when Hash
+      # Create local scope ephemeral and set all values from hash
+      new_ephemeral true
+      match.each {|k,v| setvar(k, v, :file => file, :line => line, :ephemeral => true) }
+    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
     end
   end
 
@@ -481,14 +586,15 @@ class Puppet::Parser::Scope
 
   def method_missing(method, *args, &block)
     method.to_s =~ /^function_(.*)$/
-    super unless $1
-    super unless Puppet::Parser::Functions.function($1)
+    name = $1
+    super unless name
+    super unless Puppet::Parser::Functions.function(name)
     # In odd circumstances, this might not end up defined by the previous
     # method, so we might as well be certain.
     if respond_to? method
       send(method, *args)
     else
-      raise Puppet::DevError, "Function #{$1} not defined despite being loaded!"
+      raise Puppet::DevError, "Function #{name} not defined despite being loaded!"
     end
   end
 

data/lib/puppet/parser/templatewrapper.rb

@@ -1,10 +1,11 @@
-# A simple wrapper for templates, so they don't have full access to
-# the scope objects.
 require 'puppet/parser/files'
 require 'erb'
 
+# A simple wrapper for templates, so they don't have full access to
+# the scope objects.
+#
+# @api private
 class Puppet::Parser::TemplateWrapper
-  attr_writer :scope
   include Puppet::Util
   Puppet::Util.logmethods(self)
 
@@ -12,41 +13,47 @@ class Puppet::Parser::TemplateWrapper
     @__scope__ = scope
   end
 
+  # @return [String] The full path name of the template that is being executed
+  # @api public
   def file
     @__file__
   end
 
+  # @return [Puppet::Parser::Scope] The scope in which the template is evaluated
+  # @api public
   def scope
     @__scope__
   end
 
-  def script_line_proc
-    # find which line in the template (if any) we were called from
-    # but defer to when necessary since fetching the caller information on
-    # every variable lookup can be quite time consuming
-    Proc.new { (caller.find { |l| l =~ /#{@__file__}:/ }||"")[/:(\d+):/,1] }
-  end
-
+  # Find which line in the template (if any) we were called from.
+  # @return [String] the line number
+  # @api private
   def script_line
-    script_line_proc.call
+    identifier = Regexp.escape(@__file__ || "(erb)")
+    (caller.find { |l| l =~ /#{identifier}:/ }||"")[/:(\d+):/,1]
   end
+  private :script_line
 
   # Should return true if a variable is defined, false if it is not
+  # @api public
   def has_variable?(name)
     scope.include?(name.to_s)
   end
 
-  # Allow templates to access the defined classes
+  # @return [Array<String>] The list of defined classes
+  # @api public
   def classes
     scope.catalog.classes
   end
 
-  # Allow templates to access the tags defined in the current scope
+  # @return [Array<String>] The tags defined in the current scope
+  # @api public
   def tags
     scope.tags
   end
 
-  # Allow templates to access the all the defined tags
+  # @return [Array<String>] All the defined tags
+  # @api public
   def all_tags
     scope.catalog.tags
   end
@@ -64,15 +71,18 @@ class Puppet::Parser::TemplateWrapper
   # the missing_method definition here until we declare the syntax finally
   # dead.
   def method_missing(name, *args)
+    line_number = script_line
     if scope.include?(name.to_s)
-      return scope[name.to_s, {:file => @__file__, :lineproc => script_line_proc}]
+      Puppet.deprecation_warning("Variable access via '#{name}' is deprecated. Use '@#{name}' instead. #{to_s}:#{line_number}")
+      return scope[name.to_s, { :file => @__file__, :line => line_number }]
     else
       # Just throw an error immediately, instead of searching for
       # other missingmethod things or whatever.
-      raise Puppet::ParseError.new("Could not find value for '#{name}'", @__file__, script_line)
+      raise Puppet::ParseError.new("Could not find value for '#{name}'", @__file__, line_number)
     end
   end
 
+  # @api private
   def file=(filename)
     unless @__file__ = Puppet::Parser::Files.find_template(filename, scope.compiler.environment.to_s)
       raise Puppet::ParseError, "Could not find template '#{filename}'"
@@ -82,6 +92,7 @@ class Puppet::Parser::TemplateWrapper
     scope.known_resource_types.watch_file(@__file__)
   end
 
+  # @api private
   def result(string = nil)
     if string
       template_source = "inline template"
@@ -95,11 +106,7 @@ class Puppet::Parser::TemplateWrapper
     # to the regular methods.
     benchmark(:debug, "Bound template variables for #{template_source}") do
       scope.to_hash.each do |name, value|
-        if name.kind_of?(String)
-          realname = name.gsub(/[^\w]/, "_")
-        else
-          realname = name
-        end
+        realname = name.gsub(/[^\w]/, "_")
         instance_variable_set("@#{realname}", value)
       end
     end