puppet 3.6.2 → 3.7.0

data/lib/puppet/parser/functions/template.rb

@@ -1,10 +1,17 @@
 Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :arity => -2, :doc =>
-  "Evaluate a template and return its value.  See
-  [the templating docs](http://docs.puppetlabs.com/guides/templating.html) for
-  more information.
+  "Loads an ERB template from a module, evaluates it, and returns the resulting
+  value as a string.
 
-  Note that if multiple templates are specified, their output is all
-  concatenated and returned as the output of the function.") do |vals|
+  The argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
+  reference, which will load `<TEMPLATE FILE>` from a module's `templates`
+  directory. (For example, the reference `apache/vhost.conf.erb` will load the
+  file `<MODULES DIRECTORY>/apache/templates/vhost.conf.erb`.)
+
+  This function can also accept:
+
+  * An absolute path, which can load a template file from anywhere on disk.
+  * Multiple arguments, which will evaluate all of the specified templates and
+  return their outputs concatenated into a single string.") do |vals|
     vals.collect do |file|
       # Use a wrapper, so the template can't get access to the full
       # Scope object.

data/lib/puppet/parser/functions/with.rb

@@ -0,0 +1,21 @@
+Puppet::Parser::Functions::newfunction(
+  :with,
+  :type => :rvalue,
+  :arity => -1,
+  :doc => <<-DOC
+Call a lambda code block with the given arguments. Since the parameters of the lambda
+are local to the lambda's scope, this can be used to create private sections
+of logic in a class so that the variables are not visible outside of the
+class.
+
+Example:
+
+     # notices the array [1, 2, 'foo']
+     with(1, 2, 'foo') |$x, $y, $z| { notice [$x, $y, $z] }
+
+- since 3.7.0
+- note requires future parser
+DOC
+) do |args|
+  function_fail(["with() is only available when parser/evaluator future is in effect"])
+end

data/lib/puppet/parser/lexer.rb

@@ -28,7 +28,7 @@ class Puppet::Parser::Lexer
     # Make the lexer comply with newer API. It does not produce a pos...
     nil
   end
-  
+
   def lex_error msg
     raise Puppet::LexError.new(msg)
   end

data/lib/puppet/parser/parser_factory.rb

@@ -9,13 +9,8 @@ module Puppet::Parser
   class ParserFactory
     # Produces a parser instance for the given environment
     def self.parser(environment)
-      case Puppet[:parser]
-      when 'future'
-        if Puppet[:evaluator] == 'future'
-          evaluating_parser(environment)
-        else
-          eparser(environment)
-        end
+      if Puppet[:parser] == 'future'
+        evaluating_parser(environment)
       else
         classic_parser(environment)
       end
@@ -24,41 +19,35 @@ module Puppet::Parser
     # Creates an instance of the classic parser.
     #
     def self.classic_parser(environment)
-      require 'puppet/parser'
-
+      # avoid expensive require if already loaded
+      require 'puppet/parser' unless defined? Puppet::Parser::Parser
       Puppet::Parser::Parser.new(environment)
     end
 
-    # Returns an instance of an EvaluatingParser
+    # Creates an instance of an E4ParserAdapter that adapts an
+    # EvaluatingParser to the 3x way of parsing.
+    #
     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'
+      assert_rgen_installed()
+      unless defined?(Puppet::Pops::Parser::E4ParserAdapter)
+        require 'puppet/parser/e4_parser_adapter'
+        require 'puppet/pops/parser/code_merger'
+      end
       E4ParserAdapter.new(file_watcher)
     end
 
-    # Creates an instance of the expression based parser 'eparser'
+    # Asserts that RGen >= 0.6.6 is installed by checking that certain behavior is available.
+    # Note that this assert is expensive as it also requires puppet/pops (if not already loaded).
     #
-    def self.eparser(environment)
-      # Since RGen is optional, test that it is installed
+    def self.assert_rgen_installed
       @@asserted ||= false
-      assert_rgen_installed() unless @@asserted
+      return if @@asserted
       @@asserted = true
-      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'.")
+        raise Puppet::DevError.new("The gem 'rgen' version >= 0.7.0 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).
@@ -70,19 +59,18 @@ module Puppet::Parser
         container.left_expr = litstring
         raise "no eContainer" if litstring.eContainer() != container
         raise "no eContainingFeature" if litstring.eContainingFeature() != :left_expr
-      rescue
-        raise Puppet::DevError.new("The gem 'rgen' version >= 0.6.1 is required when using '--parser future'. An older version is installed, please update.")
+      rescue => e
+        # TODO: RGen can raise exceptions for other reasons!
+        raise Puppet::DevError.new("The gem 'rgen' version >= 0.7.0 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'
+      if Puppet[:parser] == 'future'
         Puppet::Pops::Parser::CodeMerger.new
       else
         Puppet::Parser::CodeMerger.new
       end
     end
-
   end
-
 end

data/lib/puppet/parser/resource.rb

@@ -180,8 +180,8 @@ class Puppet::Parser::Resource < Puppet::Resource
   def to_hash
     @parameters.inject({}) do |hash, ary|
       param = ary[1]
-      # Skip "undef" values.
-      hash[param.name] = param.value if param.value != :undef
+      # Skip "undef" and nil values.
+      hash[param.name] = param.value if param.value != :undef && !param.value.nil?
       hash
     end
   end
@@ -238,7 +238,6 @@ 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
 

data/lib/puppet/parser/scope.rb

@@ -30,6 +30,9 @@ class Puppet::Parser::Scope
   attr_accessor :parent
   attr_reader :namespaces
 
+  # Hash of hashes of default values per type name
+  attr_reader :defaults
+
   # 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
@@ -108,7 +111,7 @@ class Puppet::Parser::Scope
     def add_entries_to(target = {})
       super
       @symbols.each do |k, v|
-        if v == :undef
+        if v == :undef || v.nil?
           target.delete(k)
         else
           target[ k ] = v
@@ -318,9 +321,16 @@ class Puppet::Parser::Scope
   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.
+  # 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.
+  #
+  # The lookupdefaults searches in the the order:
+  #
+  #   * inherited
+  #   * contained (recursive)
+  #   * self
+  #
   def lookupdefaults(type)
     values = {}
 
@@ -391,7 +401,7 @@ class Puppet::Parser::Scope
 
   def variable_not_found(name, reason=nil)
     if Puppet[:strict_variables]
-      if Puppet[:evaluator] == 'future' && Puppet[:parser] == 'future'
+      if Puppet[:parser] == 'future'
         throw :undefined_variable
       else
         reason_msg = reason.nil? ? '' : "; #{reason}"
@@ -401,6 +411,7 @@ class Puppet::Parser::Scope
       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.
@@ -618,7 +629,7 @@ class Puppet::Parser::Scope
       raise Puppet::ParseError, "Attempt to assign to a reserved variable name: '#{name}'"
     end
 
-    table = effective_symtable options[:ephemeral]
+    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")
@@ -631,11 +642,12 @@ class Puppet::Parser::Scope
     end
 
     if options[:append]
-      table[name] = append_value(undef_as('', self[name]), value)
+      # produced result (value) is the resulting appended value, note: the table[]= does not return the value
+      table[name] = (value = append_value(undef_as('', self[name]), value))
     else
       table[name] = value
     end
-    table[name]
+    value
   end
 
   def set_trusted(hash)
@@ -643,6 +655,10 @@ class Puppet::Parser::Scope
   end
 
   def set_facts(hash)
+    # Remove _timestamp (it has an illegal datatype). It is not allowed to mutate the given hash
+    # since it contains the facts.
+    hash = hash.dup
+    hash.delete('_timestamp')
     setvar('facts', deep_freeze(hash), :privileged => true)
   end
 
@@ -675,15 +691,16 @@ class Puppet::Parser::Scope
   # will be returned (irrespective of it being a match scope or a local scope).
   #
   # @param use_ephemeral [Boolean] whether the top most ephemeral (of any kind) should be used or not
-  def effective_symtable use_ephemeral
+  def effective_symtable(use_ephemeral)
     s = @ephemeral.last
-    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
+    if use_ephemeral
+      return s || @symtable
+    else
+      while s && !s.is_local_scope?()
+        s = s.parent
+      end
+      s || @symtable
     end
-    s ? s : @symtable
   end
 
   # Sets the variable value of the name given as an argument to the given value. The value is
@@ -826,8 +843,61 @@ class Puppet::Parser::Scope
     return [type, titles]
   end
 
+  # Transforms references to classes to the form suitable for
+  # lookup in the compiler.
+  #
+  # Makes names passed in the names array absolute if they are relative
+  # Names are now made absolute if Puppet[:parser] == 'future', this will
+  # be the default behavior in Puppet 4.0
+  #
+  # Transforms Class[] and Resource[] type referenes to class name
+  # or raises an error if a Class[] is unspecific, if a Resource is not
+  # a 'class' resource, or if unspecific (no title).
+  #
+  # TODO: Change this for 4.0 to always make names absolute
+  #
+  # @param names [Array<String>] names to (optionally) make absolute
+  # @return [Array<String>] names after transformation
+  #
+  def transform_and_assert_classnames(names)
+    if Puppet[:parser] == 'future'
+      names.map do |name|
+        case name
+        when String
+          name.sub(/^([^:]{1,2})/, '::\1')
+
+        when Puppet::Resource
+          assert_class_and_title(name.type, name.title)
+          name.title.sub(/^([^:]{1,2})/, '::\1')
+
+        when Puppet::Pops::Types::PHostClassType
+          raise ArgumentError, "Cannot use an unspecific Class[] Type" unless name.class_name
+          name.class_name.sub(/^([^:]{1,2})/, '::\1')
+
+        when Puppet::Pops::Types::PResourceType
+          assert_class_and_title(name.type_name, name.title)
+          name.title.sub(/^([^:]{1,2})/, '::\1')
+        end
+      end
+    else
+      names
+    end
+  end
+
   private
 
+  def assert_class_and_title(type_name, title)
+    if type_name.nil? || type_name == ''
+      raise ArgumentError, "Cannot use an unspecific Resource[] where a Resource['class', name] is expected"
+    end
+    unless type_name =~ /^[Cc]lass$/
+      raise ArgumentError, "Cannot use a Resource[#{type_name}] where a Resource['class', name] is expected"
+    end
+    if title.nil?
+      raise ArgumentError, "Cannot use an unspecific Resource['class'] where a Resource['class', name] is expected"
+    end
+  end
+
   def extend_with_functions_module
     root = Puppet.lookup(:root_environment)
     extend Puppet::Parser::Functions.environment_module(root)

data/lib/puppet/pops.rb

@@ -29,14 +29,14 @@ module Puppet
 
     require 'puppet/pops/model/model'
 
-    module Types
-      require 'puppet/pops/types/types'
-      require 'puppet/pops/types/type_calculator'
-      require 'puppet/pops/types/type_factory'
-      require 'puppet/pops/types/type_parser'
-      require 'puppet/pops/types/class_loader'
-      require 'puppet/pops/types/enumeration'
-    end
+    # (the Types module initializes itself)
+    require 'puppet/pops/types/types'
+    require 'puppet/pops/types/type_calculator'
+    require 'puppet/pops/types/type_factory'
+    require 'puppet/pops/types/type_parser'
+    require 'puppet/pops/types/class_loader'
+    require 'puppet/pops/types/enumeration'
+
 
     module Model
       require 'puppet/pops/model/tree_dumper'
@@ -84,15 +84,12 @@ module Puppet
       require 'puppet/pops/parser/parser_support'
       require 'puppet/pops/parser/locator'
       require 'puppet/pops/parser/locatable'
-      require 'puppet/pops/parser/lexer'
       require 'puppet/pops/parser/lexer2'
       require 'puppet/pops/parser/evaluating_parser'
       require 'puppet/pops/parser/epp_parser'
     end
 
     module Validation
-      require 'puppet/pops/validation/checker3_1'
-      require 'puppet/pops/validation/validator_factory_3_1'
       require 'puppet/pops/validation/checker4_0'
       require 'puppet/pops/validation/validator_factory_4_0'
     end
@@ -102,6 +99,7 @@ module Puppet
       require 'puppet/pops/evaluator/runtime3_support'
       require 'puppet/pops/evaluator/evaluator_impl'
       require 'puppet/pops/evaluator/epp_evaluator'
+      require 'puppet/pops/evaluator/callable_mismatch_describer'
     end
 
     # Subsystem for puppet functions defined in ruby.

data/lib/puppet/pops/adapters.rb

@@ -69,7 +69,8 @@ module Puppet::Pops::Adapters
     # @note This is an expensive operation
     #
     def line
-      locator.line_for_offset(offset)
+      # Optimization: manual inlining of locator accessor since this method is frequently called
+      (@locator ||= find_locator(@adapted.eContainer)).line_for_offset(offset)
     end
 
     # Produces the position on the line of the given offset.

data/lib/puppet/pops/binder/bindings_checker.rb

@@ -13,7 +13,7 @@ class Puppet::Pops::Binder::BindingsChecker
   def initialize(diagnostics_producer)
     @@check_visitor     ||= Puppet::Pops::Visitor.new(nil, "check", 0, 0)
     @type_calculator      = Puppet::Pops::Types::TypeCalculator.new()
-    @expression_validator = Puppet::Pops::Validation::ValidatorFactory_3_1.new().checker(diagnostics_producer)
+    @expression_validator = Puppet::Pops::Validation::ValidatorFactory_4_0.new().checker(diagnostics_producer)
     @acceptor             = diagnostics_producer
   end
 
@@ -31,14 +31,14 @@ class Puppet::Pops::Binder::BindingsChecker
   # Performs binding validity check
   # @api private
   def check(b)
-    @@check_visitor.visit_this(self, b)
+    @@check_visitor.visit_this_0(self, b)
   end
 
   # Checks that a binding has a producer and a type
   # @api private
   def check_Binding(b)
     # Must have a type
-    acceptor.accept(Issues::MISSING_TYPE, b) unless b.type.is_a?(Types::PObjectType)
+    acceptor.accept(Issues::MISSING_TYPE, b) unless b.type.is_a?(Types::PAnyType)
 
     # Must have a producer
     acceptor.accept(Issues::MISSING_PRODUCER, b) unless b.producer.is_a?(Bindings::ProducerDescriptor)
@@ -167,7 +167,7 @@ class Puppet::Pops::Binder::BindingsChecker
   end
 
   # @api private
-  def check_PObjectType(t)
+  def check_PAnyType(t)
     # Do nothing
   end
 

data/lib/puppet/pops/binder/bindings_factory.rb

@@ -219,7 +219,7 @@ module Puppet::Pops::Binder::BindingsFactory
     # @example creating a Hash with Integer key and Array[Integer] element type
     #     tc = type_factory
     #     type(tc.hash(tc.array_of(tc.integer), tc.integer)
-    # @param type [Puppet::Pops::Types::PObjectType] the type to set for the binding
+    # @param type [Puppet::Pops::Types::PAnyType] the type to set for the binding
     # @api public
     #
     def type(type)
@@ -284,7 +284,7 @@ module Puppet::Pops::Binder::BindingsFactory
     end
 
     # Sets the type of the binding to Array[T], where T is given.
-    # @param t [Puppet::Pops::Types::PObjectType] the type of the elements of the array
+    # @param t [Puppet::Pops::Types::PAnyType] the type of the elements of the array
     # @return [Puppet::Pops::Types::PArrayType] the type
     # @api public
     def array_of(t)
@@ -310,7 +310,7 @@ module Puppet::Pops::Binder::BindingsFactory
     # Sets the type of the binding based on the given argument.
     # @overload instance_of(t)
     #   The same as calling {#type} with `t`.
-    #   @param t [Puppet::Pops::Types::PObjectType] the type
+    #   @param t [Puppet::Pops::Types::PAnyType] the type
     # @overload instance_of(o)
     #   Infers the type from the given Ruby object and sets that as the type - i.e. "set the type
     #   of the binding to be that of the given data object".
@@ -318,7 +318,7 @@ module Puppet::Pops::Binder::BindingsFactory
     # @overload instance_of(c)
     #   @param c [Class] the Class to base the type on.
     #   Sets the type based on the given ruby class. The result is one of the specific puppet types
-    #   if the class can be represented by a specific type, or the open ended PRubyType otherwise.
+    #   if the class can be represented by a specific type, or the open ended PRuntimeType otherwise.
     # @overload instance_of(s)
     #   The same as using a class, but instead of giving a class instance, the class is expressed using its fully
     #   qualified name. This method of specifying the type allows late binding (the class does not have to be loaded
@@ -695,7 +695,7 @@ module Puppet::Pops::Binder::BindingsFactory
   end
 
   # Creates a Producer that looks up a value.
-  # @param type [Puppet::Pops::Types::PObjectType] the type to lookup
+  # @param type [Puppet::Pops::Types::PAnyType] the type to lookup
   # @param name [String] the name to lookup
   # @return [Puppet::Pops::Binder::Bindings::ProducerDescriptor] a producer description
   # @api public
@@ -709,7 +709,7 @@ module Puppet::Pops::Binder::BindingsFactory
   # Creates a Hash lookup producer that looks up a hash value, and then a key in the hash.
   #
   # @return [Puppet::Pops::Binder::Bindings::ProducerDescriptor] a producer description
-  # @param type [Puppet::Pops::Types::PObjectType] the type to lookup (i.e. a Hash of some key/value type).
+  # @param type [Puppet::Pops::Types::PAnyType] the type to lookup (i.e. a Hash of some key/value type).
   # @param name [String] the name to lookup
   # @param key [Object] the key to lookup in the looked up hash (type should comply with given key type).
   # @api public