puppet 3.7.4-x86-mingw32 → 3.7.5-x86-mingw32

data/lib/puppet/parser/parser_factory.rb

@@ -9,7 +9,7 @@ module Puppet::Parser
   class ParserFactory
     # Produces a parser instance for the given environment
     def self.parser(environment)
-      if Puppet[:parser] == 'future'
+      if Puppet.future_parser?
         evaluating_parser(environment)
       else
         classic_parser(environment)
@@ -66,7 +66,7 @@ module Puppet::Parser
     end
 
     def self.code_merger
-      if Puppet[:parser] == 'future'
+      if Puppet.future_parser?
         Puppet::Pops::Parser::CodeMerger.new
       else
         Puppet::Parser::CodeMerger.new

data/lib/puppet/parser/relationship.rb

@@ -7,7 +7,7 @@ class Puppet::Parser::Relationship
     # This if statement is needed because the 3x parser cannot load
     # Puppet::Pops. This logic can be removed for 4.0 when the 3x AST
     # is removed (when Pops is always used).
-    if !(Puppet[:parser] == 'future')
+    if !(Puppet.future_parser?)
       case resources
       when Puppet::Parser::Collector
         resources.collected.values

data/lib/puppet/parser/scope.rb

@@ -22,6 +22,9 @@ class Puppet::Parser::Scope
 
   AST = Puppet::Parser::AST
 
+  # Variables that always exist with nil value even if not set
+  BUILT_IN_VARS = ['module_name'.freeze, 'caller_module_name'.freeze].freeze
+
   Puppet::Util.logmethods(self)
 
   include Puppet::Util::Errors
@@ -181,9 +184,29 @@ class Puppet::Parser::Scope
 
   # Returns true if the variable of the given name is set to any value (including nil)
   #
+  # @return [Boolean] if variable exists or not
+  #
   def exist?(name)
-    next_scope = inherited_scope || enclosing_scope
-    effective_symtable(true).include?(name) || next_scope && next_scope.exist?(name)
+    # Note !! ensure the answer is boolean
+    !! if name =~ /^(.*)::(.+)$/
+      class_name = $1
+      variable_name = $2
+      return true if class_name == '' && BUILT_IN_VARS.include?(variable_name)
+
+      # lookup class, but do not care if it is not evaluated since that will result
+      # in it not existing anyway. (Tests may run with just scopes and no evaluated classes which
+      # will result in class_scope for "" not returning topscope).
+      klass = find_hostclass(class_name)
+      other_scope = klass.nil? ? nil : class_scope(klass)
+      if other_scope.nil?
+        class_name == '' ? compiler.topscope.exist?(variable_name) : false
+      else
+        other_scope.exist?(variable_name)
+      end
+    else
+      next_scope = inherited_scope || enclosing_scope
+      effective_symtable(true).include?(name) || next_scope && next_scope.exist?(name) || BUILT_IN_VARS.include?(name)
+    end
   end
 
   # Returns true if the given name is bound in the current (most nested) scope for assignments.
@@ -400,8 +423,12 @@ class Puppet::Parser::Scope
   end
 
   def variable_not_found(name, reason=nil)
+    # Built in variables always exist
+    if BUILT_IN_VARS.include?(name)
+      return nil
+    end
     if Puppet[:strict_variables]
-      if Puppet[:parser] == 'future'
+      if Puppet.future_parser?
         throw :undefined_variable
       else
         reason_msg = reason.nil? ? '' : "; #{reason}"
@@ -534,8 +561,8 @@ class Puppet::Parser::Scope
   #
   # @see to_hash_legacy
   def to_hash(recursive = true)
-    @parser ||= Puppet[:parser]
-    if @parser == 'future'
+    @future_parser ||= Puppet.future_parser?
+    if @future_parser
       to_hash_future(recursive)
     else
       to_hash_legacy(recursive)
@@ -847,7 +874,7 @@ class Puppet::Parser::Scope
   # 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
+  # Names are now made absolute if Puppet.future_parser? is true, this will
   # be the default behavior in Puppet 4.0
   #
   # Transforms Class[] and Resource[] type referenes to class name
@@ -860,7 +887,7 @@ class Puppet::Parser::Scope
   # @return [Array<String>] names after transformation
   #
   def transform_and_assert_classnames(names)
-    if Puppet[:parser] == 'future'
+    if Puppet.future_parser?
       names.map do |name|
         case name
         when String

data/lib/puppet/pops.rb

@@ -96,11 +96,13 @@ module Puppet
 
     module Evaluator
       require 'puppet/pops/evaluator/callable_signature'
+      require 'puppet/pops/evaluator/runtime3_converter'
       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'
       require 'puppet/pops/evaluator/collector_transformer'
+      require 'puppet/pops/evaluator/puppet_proc'
       module Collectors
         require 'puppet/pops/evaluator/collectors/abstract_collector'
         require 'puppet/pops/evaluator/collectors/fixed_set_collector'

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

@@ -46,14 +46,17 @@ class Puppet::Pops::Binder::Lookup
     names.each {|n| options[n] = undef_as_nil(input[n.to_s] || input[n]) }
     options
   end
+  private_class_method :to_symbolic_hash
 
   def self.type_mismatch(type_calculator, expected, got)
     "has wrong type, expected #{type_calculator.string(expected)}, got #{type_calculator.string(got)}"
   end
+  private_class_method :type_mismatch
 
   def self.fail(msg)
     raise Puppet::ParseError, "Function lookup() " + msg
   end
+  private_class_method :fail
 
   def self.fail_lookup(names)
     name_part = if names.size == 1
@@ -63,6 +66,7 @@ class Puppet::Pops::Binder::Lookup
     end
     fail("did not find a value for #{name_part}")
   end
+  private_class_method :fail_lookup
 
   def self.validate_options(options, type_calculator)
     type_parser = Puppet::Pops::Types::TypeParser.new
@@ -74,7 +78,7 @@ class Puppet::Pops::Binder::Lookup
 
     t = type_calculator.infer(options[:name])
     if ! type_calculator.assignable?(name_type, t)
-      fail("given 'name' argument, #{type_mismatch(type_calculator, options[:name], t)}")
+      fail("given 'name' argument, #{type_mismatch(type_calculator, name_type, t)}")
     end
 
     # unless a type is already given (future case), parse the type (or default 'Data'), fails if invalid type is given
@@ -103,18 +107,22 @@ class Puppet::Pops::Binder::Lookup
     options[:override] = {} unless options[:override]
 
   end
+  private_class_method :validate_options
 
   def self.nil_as_undef(x)
     x.nil? ? :undef : x
   end
+  private_class_method :nil_as_undef
 
   def self.undef_as_nil(x)
     is_nil_or_undef?(x) ? nil : x
   end
+  private_class_method :undef_as_nil
 
   def self.is_nil_or_undef?(x)
     x.nil? || x == :undef
   end
+  private_class_method :is_nil_or_undef?
 
   # This is used as a marker - a value that cannot (at least not easily) by mistake be found in
   # hiera data.
@@ -128,7 +136,7 @@ class Puppet::Pops::Binder::Lookup
     elsif !(result = scope.compiler.injector.lookup(scope, type, name)).nil?
       result
    else
-     result = scope.function_hiera([name, PrivateNotFoundMarker])
+     result = call_hiera_function(scope, name, PrivateNotFoundMarker)
      if !result.nil? && result != PrivateNotFoundMarker
        result
      else
@@ -136,8 +144,17 @@ class Puppet::Pops::Binder::Lookup
      end
    end
   end
+  private_class_method :search_for
 
-  # This is the method called from the puppet/parser/functions/lookup.rb
+  def self.call_hiera_function(scope, name, dflt)
+    loader = scope.compiler.loaders.private_environment_loader
+    func = loader.load(:function, :hiera) unless loader.nil?
+    raise Error, 'Function not found: hiera' if func.nil?
+    func.call(scope, name, dflt)
+  end
+  private_class_method :call_hiera_function
+
+    # This is the method called from the puppet/parser/functions/lookup.rb
   # @param args [Array] array following the puppet function call conventions
   def self.lookup(scope, args)
     type_calculator = Puppet::Pops::Types::TypeCalculator.new
@@ -166,11 +183,11 @@ class Puppet::Pops::Binder::Lookup
     result = if pblock = options[:pblock]
       result2 = case pblock.parameter_count
       when 1
-        pblock.call(scope, undef_as_nil(result))
+        pblock.call(undef_as_nil(result))
       when 2
-        pblock.call(scope, result_with_name[ 0 ], undef_as_nil(result))
+        pblock.call(result_with_name[ 0 ], undef_as_nil(result))
       else
-        pblock.call(scope, result_with_name[ 0 ], undef_as_nil(result), undef_as_nil(options[ :default ]))
+        pblock.call(result_with_name[ 0 ], undef_as_nil(result), undef_as_nil(options[ :default ]))
       end
 
       # if the given result was returned, there is no need to type-check it again
@@ -193,7 +210,7 @@ class Puppet::Pops::Binder::Lookup
       # way, and should instead be turned into :undef.
       # TODO PUPPET4: Simply return the result
       #
-      Puppet[:parser] == 'future' ? result : nil_as_undef(result)
+      Puppet.future_parser? ? result : nil_as_undef(result)
     end
   end
 end

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

@@ -57,7 +57,7 @@ module Puppet::Pops::Binder::Producers
     def initialize(injector, binding, scope, options)
       if transformer_lambda = options[:transformer]
         if transformer_lambda.is_a?(Proc)
-          raise ArgumentError, "Transformer Proc must take two arguments; scope, value." unless transformer_lambda.arity == 2
+          raise ArgumentError, "Transformer Proc must take one argument; value." unless transformer_lambda.arity == 1
           @transformer = transformer_lambda
         else
           raise ArgumentError, "Transformer must be a LambdaExpression" unless transformer_lambda.is_a?(Puppet::Pops::Model::LambdaExpression)
@@ -110,7 +110,7 @@ module Puppet::Pops::Binder::Producers
     #
     def do_transformation(scope, produced_value)
       return produced_value unless transformer
-      transformer.call(scope, produced_value)
+      transformer.call(produced_value)
     end
   end
 

data/lib/puppet/pops/evaluator/closure.rb

@@ -29,7 +29,7 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
 
   # compatible with 3x AST::Lambda
   # @api public
-  def call(scope, *args)
+  def call(*args)
     variable_bindings = combine_values_with_parameters(args)
 
     tc = Puppet::Pops::Types::TypeCalculator

data/lib/puppet/pops/evaluator/evaluator_impl.rb

@@ -53,9 +53,6 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
 
     @@compare_operator     ||= Puppet::Pops::Evaluator::CompareOperator.new()
     @@relationship_operator ||= Puppet::Pops::Evaluator::RelationshipOperator.new()
-
-    # Initialize the runtime module
-    Puppet::Pops::Evaluator::Runtime3Support.instance_method(:initialize).bind(self).call()
   end
 
   # @api private
@@ -77,14 +74,43 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       @@eval_visitor.visit_this_1(self, target, scope)
 
     rescue Puppet::Pops::SemanticError => e
-      # a raised issue may not know the semantic target
+      # A raised issue may not know the semantic target, use errors call stack, but fill in the 
+      # rest from a supplied semantic object, or the target instruction if there is not semantic
+      # object.
+      #
       fail(e.issue, e.semantic || target, e.options, e)
 
-    rescue StandardError => e
-      if e.is_a? Puppet::ParseError
-        # ParseError's are supposed to be fully configured with location information
+    rescue Puppet::PreformattedError => e
+      # Already formatted with location information, and with the wanted call stack.
+      # Note this is currently a specialized ParseError, so rescue-order is important
+      #
+      raise e
+
+    rescue Puppet::ParseError => e
+      # ParseError may be raised in ruby code without knowing the location
+      # in puppet code.
+      # Accept a ParseError that has file or line information available
+      # as an error that should be used verbatim. (Tests typically run without
+      # setting a file name).
+      # ParseError can supply an original - it is impossible to determine which
+      # call stack that should be propagated, using the ParseError's backtrace.
+      #
+      if e.file || e.line
         raise e
+      else
+        # Since it had no location information, treat it as user intended a general purpose
+        # error. Pass on its call stack.
+        fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e)
       end
+
+
+    rescue Puppet::Error => e
+      # PuppetError has the ability to wrap an exception, if so, use the wrapped exception's
+      # call stack instead
+      fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e.original || e)
+
+    rescue StandardError => e
+      # All other errors, use its message and call stack
       fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e)
     end
   end
@@ -238,6 +264,8 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   def eval_UnfoldExpression(o, scope)
     candidate = evaluate(o.expr, scope)
     case candidate
+    when nil
+      []
     when Array
       candidate
     when Hash
@@ -763,12 +791,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end
     name = o.functor_expr.value
-
-    evaluated_arguments = unfold([], o.arguments, scope)
-
-    # wrap lambda in a callable block if it is present
-    evaluated_arguments << Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope) if o.lambda
-    call_function(name, evaluated_arguments, o, scope)
+    call_function_with_block(name, unfold([], o.arguments, scope), o, scope)
   end
 
   # Evaluation of CallMethodExpression handles a NamedAccessExpression functor (receiver.function_name)
@@ -783,13 +806,82 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end 
     name = name.value # the string function name
+    call_function_with_block(name, unfold([receiver], o.arguments || [], scope), o, scope)
+  end
 
-    evaluated_arguments = unfold([receiver], o.arguments || [], scope)
+  def call_function_with_block(name, evaluated_arguments, o, scope)
+    if o.lambda.nil?
+      call_function(name, evaluated_arguments, o, scope)
+    else
+      closure = Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope)
+      call_function(name, evaluated_arguments, o, scope, &proc_from_closure(closure))
+    end
+  end
+  private :call_function_with_block
 
-    # wrap lambda in a callable block if it is present
-    evaluated_arguments << Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope) if o.lambda
-    call_function(name, evaluated_arguments, o, scope)
+  # Creates a Proc with an arity count that matches the parameters of the given closure. The arity will
+  # be correct up to 10 parameters and then default to varargs (-1)
+  #
+  def proc_from_closure(closure)
+    return Puppet::Pops::Evaluator::PuppetProc.new(closure) { |*args| closure.call(*args) } unless RUBY_VERSION[0,3] == '1.8'
+
+    # This code is required since a Proc isn't propagated by reference in Ruby 1.8.x. It produces a standard
+    # Proc that has correct arity as a replacement for the otherwise used PuppetProc
+    # TODO: Remove when Ruby 1.8.x support is dropped
+    arity = closure.parameters.reduce(0) do |memo, param|
+      count = memo + 1
+      break -count if param.captures_rest || !param.value.nil?
+      count
+    end
+
+    case arity
+    when 0
+      proc { || closure.call }
+    when 1
+      proc { |a| closure.call(a) }
+    when 2
+      proc { |a, b| closure.call(a, b) }
+    when 3
+      proc { |a, b, c| closure.call(a, b, c) }
+    when 4
+      proc { |a, b, c, d| closure.call(a, b, c, d) }
+    when 5
+      proc { |a, b, c, d, e| closure.call(a, b, c, d, e) }
+    when 6
+      proc { |a, b, c, d, e, f| closure.call(a, b, c, d, e, f) }
+    when 7
+      proc { |a, b, c, d, e, f, g| closure.call(a, b, c, d, e, f, g) }
+    when 8
+      proc { |a, b, c, d, e, f, g, h| closure.call(a, b, c, d, e, f, g, h) }
+    when 9
+      proc { |a, b, c, d, e, f, g, h, i| closure.call(a, b, c, d, e, f, g, h, i) }
+    when 10
+      proc { |a, b, c, d, e, f, g, h, i, j| closure.call(a, b, c, d, e, f, g, h, i, j) }
+    when -1
+      proc { |*v| closure.call(*v) }
+    when -2
+      proc { |a, *v| closure.call(a, *v) }
+    when -3
+      proc { |a, b, *v| closure.call(a, b, *v) }
+    when -4
+      proc { |a, b, c, *v| closure.call(a, b, c, *v) }
+    when -5
+      proc { |a, b, c, d, *v| closure.call(a, b, c, d, *v) }
+    when -6
+      proc { |a, b, c, d, e, *v| closure.call(a, b, c, d, e, *v) }
+    when -7
+      proc { |a, b, c, d, e, f, *v| closure.call(a, b, c, d, e, f, *v) }
+    when -8
+      proc { |a, b, c, d, e, f, g, *v| closure.call(a, b, c, d, e, f, g, *v) }
+    when -9
+      proc { |a, b, c, d, e, f, g, h, *v| closure.call(a, b, c, d, e, f,g, h, *v) }
+    when -10
+      proc { |a, b, c, d, e, f, g, h, i, *v| closure.call(a, b, c, d, e, f,g, h, i, *v) }
+    else
+      proc { |*a| closure.call(*a) }
+    end
   end
+  private :proc_from_closure
 
   # @example
   #   $x ? { 10 => true, 20 => false, default => 0 }

data/lib/puppet/pops/evaluator/puppet_proc.rb

@@ -0,0 +1,69 @@
+# Complies with Proc API by mapping a Puppet::Pops::Evaluator::Closure to a ruby Proc.
+# Creating and passing an instance of this class instead of just a plain block makes
+# it possible to inherit the parameter info and arity from the closure. Advanced users
+# may also access the closure itself. The Puppet::Pops::Functions::Dispatcher uses this
+# when it needs to get the Callable type of the closure.
+#
+# The class is part of the Puppet Function API for Ruby and thus public API but a user
+# should never create an instance of this class.
+#
+# @api public
+class Puppet::Pops::Evaluator::PuppetProc < Proc
+  # Creates a new instance from a closure and a block that will dispatch
+  # all parameters to the closure. The block must be similar to:
+  #
+  #   { |*args| closure.call(*args) }
+  #
+  # @param closure [Puppet::Pops::Evaluator::Closure] The closure to map
+  # @param &block [Block] The varargs block that invokes the closure.call method
+  #
+  # @api private
+  def self.new(closure, &block)
+    proc = super(&block)
+    proc.instance_variable_set(:@closure, closure)
+    proc
+  end
+
+  # @return  [Puppet::Pops::Evaluator::Closure] the mapped closure
+  # @api public
+  attr_reader :closure
+
+  # @overrides Block.lambda?
+  # @return [Boolean] always false since this proc doesn't do the Ruby lambda magic
+  # @api public
+  def lambda?
+    false
+  end
+
+  # Maps the closure parameters to standard Block parameter info where each
+  # parameter is represented as a two element Array where the first
+  # element is :req, :opt, or :rest and the second element is the name
+  # of the parameter.
+  #
+  # @return [Array<Array<Symbol>>] array of parameter info pairs
+  # @overrides Block.parameters
+  # @api public
+  def parameters
+    @closure.parameters.map do |param|
+      sym = param.name.to_sym
+      if param.captures_rest
+        [ :rest, sym ]
+      elsif param.value
+        [ :opt, sym ]
+      else
+        [ :req, sym ]
+      end
+    end
+  end
+
+  # @return [Fixnum] the arity of the block
+  # @overrides Block.arity
+  # @api public
+  def arity
+    parameters.reduce(0) do |memo, param|
+      count = memo + 1
+      break -count unless param[0] == :req
+      count
+    end
+  end
+end