puppet 4.0.0-x64-mingw32 → 4.1.0-x64-mingw32

data/lib/puppet/parser/scope.rb

@@ -607,12 +607,17 @@ class Puppet::Parser::Scope
       raise Puppet::ParseError, "Attempt to assign to a reserved variable name: '#{name}'"
     end
 
+    # Check for server_facts reserved variable name if the trusted_sever_facts setting is true
+    if Puppet[:trusted_server_facts] && name == 'server_facts' && !options[:privileged]
+      raise Puppet::ParseError, "Attempt to assign to a reserved variable name: '#{name}'"
+    end
+
     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")
+        error = Puppet::ParseError.new("Cannot append, variable '$#{name}' is defined in this scope")
       else
-        error = Puppet::ParseError.new("Cannot reassign variable #{name}")
+        error = Puppet::ParseError.new("Cannot reassign variable '$#{name}'")
       end
       error.file = options[:file] if options[:file]
       error.line = options[:line] if options[:line]
@@ -636,6 +641,10 @@ class Puppet::Parser::Scope
     setvar('facts', deep_freeze(hash), :privileged => true)
   end
 
+  def set_server_facts(hash)
+    setvar('server_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).

data/lib/puppet/parser/templatewrapper.rb

@@ -1,5 +1,6 @@
 require 'puppet/parser/files'
 require 'erb'
+require 'puppet/file_system'
 
 # A simple wrapper for templates, so they don't have full access to
 # the scope objects.
@@ -70,7 +71,7 @@ class Puppet::Parser::TemplateWrapper
     if string
       template_source = "inline template"
     else
-      string = File.read(@__file__)
+      string = Puppet::FileSystem.read_preserve_line_endings(@__file__)
       template_source = @__file__
     end
 

data/lib/puppet/pops.rb

@@ -122,6 +122,10 @@ module Puppet
       require 'puppet/pops/functions/dispatch'
       require 'puppet/pops/functions/dispatcher'
     end
+
+    module Migration
+      require 'puppet/pops/migration/migration_checker'
+    end
   end
 
   require 'puppet/parser/ast/pops_bridge'

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

@@ -251,17 +251,37 @@ class Puppet::Pops::Evaluator::AccessOperator
   def access_POptionalType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
-      unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
-        fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Optional-Type', :actual => keys[0].class})
+      type = keys[0]
+      unless type.is_a?(Puppet::Pops::Types::PAnyType) || type.is_a?(String)
+        fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Optional-Type', :actual => type.class})
       end
-      result = Puppet::Pops::Types::POptionalType.new()
-      result.optional_type = keys[0]
-      result
+      TYPEFACTORY.optional(type)
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Optional-Type', :min => 1, :actual => keys.size})
     end
   end
 
+  def access_PNotUndefType(o, scope, keys)
+    keys.flatten!
+    case keys.size
+    when 0
+      TYPEFACTORY.not_undef
+    when 1
+      type = keys[0]
+      case type
+      when String
+        type = TYPEFACTORY.string(type)
+      when Puppet::Pops::Types::PAnyType
+        type = nil if type.class == Puppet::Pops::Types::PAnyType
+      else
+        fail(Puppet::Pops::Issues::BAD_NOT_UNDEF_SLICE_TYPE, @semantic.keys[0], {:base_type => 'NotUndef-Type', :actual => type.class})
+      end
+      TYPEFACTORY.not_undef(type)
+    else
+      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'NotUndef-Type', :min => 0, :max => 1, :actual => keys.size})
+    end
+  end
+
   def access_PType(o, scope, keys)
     keys.flatten!
     if keys.size == 1

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

@@ -39,10 +39,18 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
     if tc.callable?(type, final_args)
       @evaluator.evaluate_block_with_bindings(@enclosing_scope, variable_bindings, @model.body)
     else
-      raise ArgumentError, "lambda called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string('lambda', final_args, [self])}"
+      raise ArgumentError, "#{closure_name} called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string(closure_name, final_args, [self])}"
     end
   end
 
+  # This method makes a Closure compatible with a Dispatch. This is used when the closure is wrapped in a Function
+  # and the function is called. (Saves an extra Dispatch that just delegates to a Closure and avoids having two
+  # checks of the argument type/arity validity).
+  # @api private
+  def invoke(instance, calling_scope, args, &block)
+    call(*args, &block)
+  end
+
   # Call closure with argument assignment by name
   def call_by_name(args_hash, enforce_parameters)
     if enforce_parameters
@@ -73,7 +81,7 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
       tc = Puppet::Pops::Types::TypeCalculator
       final_args = tc.infer_set(parameter_names.collect { |param| scope_hash[param] })
       if !tc.callable?(type, final_args)
-        raise ArgumentError, "lambda called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string('lambda', final_args, [self])}"
+        raise ArgumentError, "#{closure_name} called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string(closure_name, final_args, [self])}"
       end
     else
       scope_hash = args_hash
@@ -115,6 +123,24 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
     'unsupported_block'
   end
 
+  CLOSURE_NAME = 'lambda'.freeze
+
+  # @api public
+  def closure_name()
+    CLOSURE_NAME
+  end
+
+  class Named < Puppet::Pops::Evaluator::Closure
+    def initialize(name, evaluator, model, scope)
+      @name = name
+      super(evaluator, model, scope)
+    end
+
+    def closure_name
+      @name
+    end
+  end
+
   private
 
   def combine_values_with_parameters(args)

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

@@ -27,7 +27,7 @@ class Puppet::Pops::Evaluator::CollectorTransformer
 
     if !o.operations.empty?
       overrides = {
-        :parameters => o.operations.map{ |x| to_3x_param(x).evaluate(scope)},
+        :parameters => o.operations.map{ |x| @@evaluator.evaluate(x, scope)}.flatten,
         :file       => file_path,
         :line       => [line_num, position],
         :source     => scope.source,
@@ -206,14 +206,4 @@ protected
   def match_Object(o, scope)
     raise ArgumentError, "Cannot transform object of class #{o.class}"
   end
-
-  # Produces (name => expr) or (name +> expr)
-  def to_3x_param(o)
-    bridge = Puppet::Parser::AST::PopsBridge::Expression.new(:value => o.value_expr)
-    args = { :value => bridge }
-    args[:add] = true if o.operator == :'+>'
-    args[:param] = o.attribute_name
-    args= Puppet::Pops::Model::AstTransformer.new().merge_location(args, o)
-    Puppet::Parser::AST::ResourceParam.new(args)
-  end
 end

data/lib/puppet/pops/evaluator/collectors/catalog_collector.rb

@@ -22,4 +22,8 @@ class Puppet::Pops::Evaluator::Collectors::CatalogCollector < Puppet::Pops::Eval
       resource.type == t && (q ?  q.call(resource) : true)
     end
   end
+
+  def to_s
+    "Catalog-Collector[#{@type.to_s}]"
+  end
 end

data/lib/puppet/pops/evaluator/collectors/exported_collector.rb

@@ -63,4 +63,8 @@ class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Eva
 
     resources
   end
+
+  def to_s
+    "Exported-Collector[#{@type.to_s}]"
+  end
 end

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

@@ -17,6 +17,7 @@ class Puppet::Pops::Evaluator::CompareOperator
   def initialize
     @@equals_visitor  ||= Puppet::Pops::Visitor.new(self, "equals", 1, 1)
     @@compare_visitor ||= Puppet::Pops::Visitor.new(self, "cmp", 1, 1)
+    @@match_visitor ||= Puppet::Pops::Visitor.new(self, "match", 2, 2)
     @@include_visitor ||= Puppet::Pops::Visitor.new(self, "include", 2, 2)
     @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
   end
@@ -31,6 +32,11 @@ class Puppet::Pops::Evaluator::CompareOperator
     @@compare_visitor.visit_this_1(self, a, b)
   end
 
+  # Performs a match of a and b, and returns true if b matches a
+  def match(a, b, scope)
+    @@match_visitor.visit_this_2(self, b, a, scope)
+  end
+
   # Answers is b included in a
   def include?(a, b, scope)
     @@include_visitor.visit_this_2(self, a, b, scope)
@@ -149,4 +155,41 @@ class Puppet::Pops::Evaluator::CompareOperator
   def include_Hash(a, b, scope)
     include?(a.keys, b, scope)
   end
+
+  # Matches in general by using == operator
+  def match_Object(pattern, a, scope)
+    equals(a, pattern)
+  end
+
+  # Matches only against strings
+  def match_Regexp(regexp, left, scope)
+    return false unless left.is_a? String
+    matched = regexp.match(left)
+    set_match_data(matched, scope) # creates or clears ephemeral
+    !!matched # convert to boolean
+  end
+
+  def match_PAnyType(any_type, left, scope)
+    # right is a type and left is not - check if left is an instance of the given type
+    # (The reverse is not terribly meaningful - computing which of the case options that first produces
+    # an instance of a given type).
+    #
+    @type_calculator.instance?(any_type, left)
+  end
+
+  def match_Array(array, left, scope)
+    return false unless left.is_a?(Array)
+    return false unless left.length == array.length
+    array.each_with_index.all? { | pattern, index| match(left[index], pattern, scope) }
+  end
+
+  def match_Hash(hash, left, scope)
+    return false unless left.is_a?(Hash)
+    hash.all? {|x,y| match(left[x], y, scope) }
+  end
+
+  def match_Symbol(symbol, left, scope)
+    return true if symbol == :default
+    equals(left, default, scope)
+  end
 end

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

@@ -24,10 +24,15 @@ class Puppet::Pops::Evaluator::EppEvaluator
       raise ArgumentError, "epp(): the first argument must be a String with the filename, got a #{file.class}"
     end
 
-    file = file + ".epp" unless file =~ /\.epp$/
+    unless Puppet::FileSystem.exist?(file)
+      unless file =~ /\.epp$/
+        file = file + ".epp"
+      end
+    end
+
     scope.debug "Retrieving epp template #{file}"
     template_file = Puppet::Parser::Files.find_template(file, env_name)
-    unless template_file
+    if template_file.nil? ||  !Puppet::FileSystem.exist?(template_file)
       raise Puppet::ParseError, "Could not find template '#{file}'"
     end
 

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

@@ -49,6 +49,9 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
 
     @@compare_operator     ||= Puppet::Pops::Evaluator::CompareOperator.new()
     @@relationship_operator ||= Puppet::Pops::Evaluator::RelationshipOperator.new()
+
+    # Use null migration checker unless given in context
+    @migration_checker = (Puppet.lookup(:migration_checker) { Puppet::Pops::Migration::MigrationChecker.new() })
   end
 
   # @api private
@@ -176,6 +179,11 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     fail(Issues::ILLEGAL_ASSIGNMENT, o)
   end
 
+  # An array is assignable if all entries are lvalues
+  def lvalue_LiteralList(o, scope)
+    o.values.map {|x| lvalue(x, scope) }
+  end
+
   # Assign value to named variable.
   # The '$' sign is never part of the name.
   # @example In Puppet DSL
@@ -204,6 +212,22 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     fail(Issues::ILLEGAL_ASSIGNMENT, o)
   end
 
+  def assign_Array(lvalues, values, o, scope)
+    if values.is_a?(Hash)
+      lvalues.map do |lval|
+        assign(lval,
+          values.fetch(lval) {|k| fail(Issues::MISSING_MULTI_ASSIGNMENT_KEY, o, :key =>k)},
+          o, scope)
+      end
+    else
+      values = [values] unless values.is_a?(Array)
+      if values.size != lvalues.size
+        fail(Issues::ILLEGAL_MULTI_ASSIGNMENT_SIZE, o, :expected =>lvalues.size, :actual => values.size)
+      end
+      lvalues.zip(values).map { |lval, val| assign(lval, val, o, scope) }
+    end
+  end
+
   def eval_Factory(o, scope)
     evaluate(o.current, scope)
   end
@@ -250,7 +274,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   end
 
   def eval_NotExpression(o, scope)
-    ! is_true?(evaluate(o.expr, scope))
+    ! is_true?(evaluate(o.expr, scope), o.expr)
   end
 
   def eval_UnaryMinusExpression(o, scope)
@@ -511,7 +535,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # b is only evaluated if a is true
   #
   def eval_AndExpression o, scope
-    is_true?(evaluate(o.left_expr, scope)) ? is_true?(evaluate(o.right_expr, scope)) : false
+    is_true?(evaluate(o.left_expr, scope), o.left_expr) ? is_true?(evaluate(o.right_expr, scope), o.right_expr) : false
   end
 
   # @example
@@ -519,7 +543,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # b is only evaluated if a is false
   #
   def eval_OrExpression o, scope
-    is_true?(evaluate(o.left_expr, scope)) ? true : is_true?(evaluate(o.right_expr, scope))
+    is_true?(evaluate(o.left_expr, scope), o.left_expr) ? true : is_true?(evaluate(o.right_expr, scope), o.right_expr)
   end
 
   # Evaluates each entry of the literal list and creates a new Array
@@ -558,21 +582,23 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     #
     with_guarded_scope(scope) do
       test = evaluate(o.test, scope)
+
       result = nil
       the_default = nil
       if o.options.find do |co|
         # the first case option that matches
         if co.values.find do |c|
+          c = unwind_parentheses(c)
           case c
           when Puppet::Pops::Model::LiteralDefault
             the_default = co.then_expr
-            is_match?(test, evaluate(c, scope), c, scope)
+            next false
           when Puppet::Pops::Model::UnfoldExpression
             # not ideal for error reporting, since it is not known which unfolded result
             # that caused an error - the entire unfold expression is blamed (i.e. the var c, passed to is_match?)
-            evaluate(c, scope).any? {|v| is_match?(test, v, c, scope) }
+            evaluate(c, scope).any? {|v| is_match?(test, v, c, co, scope) }
           else
-            is_match?(test, evaluate(c, scope), c, scope)
+            is_match?(test, evaluate(c, scope), c, co, scope)
           end
         end
         result = evaluate(co.then_expr, scope)
@@ -796,13 +822,13 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     unless o.functor_expr.is_a? Puppet::Pops::Model::NamedAccessExpression
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function accessor', :container => o})
     end
-    receiver = evaluate(o.functor_expr.left_expr, scope)
+    receiver = unfold([], [o.functor_expr.left_expr], scope)
     name = o.functor_expr.right_expr
     unless name.is_a? Puppet::Pops::Model::QualifiedName
       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)
+    call_function_with_block(name, unfold(receiver, o.arguments || [], scope), o, scope)
   end
 
   def call_function_with_block(name, evaluated_arguments, o, scope)
@@ -824,9 +850,10 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     #
     with_guarded_scope(scope) do
       test = evaluate(o.left_expr, scope)
+
       the_default = nil
       selected = o.selectors.find do |s|
-        me = s.matching_expr
+        me = unwind_parentheses(s.matching_expr)
         case me
         when Puppet::Pops::Model::LiteralDefault
           the_default = s.value_expr
@@ -834,9 +861,9 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
         when Puppet::Pops::Model::UnfoldExpression
           # not ideal for error reporting, since it is not known which unfolded result
           # that caused an error - the entire unfold expression is blamed (i.e. the var c, passed to is_match?)
-          evaluate(me, scope).any? {|v| is_match?(test, v, me, scope) }
+          evaluate(me, scope).any? {|v| is_match?(test, v, me, s, scope) }
         else
-          is_match?(test, evaluate(me, scope), me, scope)
+          is_match?(test, evaluate(me, scope), me, s, scope)
         end
       end
       if selected
@@ -864,7 +891,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # Evaluates Puppet DSL `if`
   def eval_IfExpression o, scope
     with_guarded_scope(scope) do
-      if is_true?(evaluate(o.test, scope))
+      if is_true?(evaluate(o.test, scope), o.test)
         evaluate(o.then_expr, scope)
       else
         evaluate(o.else_expr, scope)
@@ -875,7 +902,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # Evaluates Puppet DSL `unless`
   def eval_UnlessExpression o, scope
     with_guarded_scope(scope) do
-      unless is_true?(evaluate(o.test, scope))
+      unless is_true?(evaluate(o.test, scope), o.test)
         evaluate(o.then_expr, scope)
       else
         evaluate(o.else_expr, scope)
@@ -1076,7 +1103,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # This is the type of matching performed in a case option, using == for every type
   # of value except regular expression where a match is performed.
   #
-  def is_match? left, right, o, scope
+  def is_match?(left, right, o, option_expr, scope)
     if right.is_a?(Regexp)
       return false unless left.is_a? String
       matched = right.match(left)
@@ -1092,6 +1119,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       # Handle equality the same way as the language '==' operator (case insensitive etc.)
       @@compare_operator.equals(left,right)
     end
+    @@compare_operator.match(left, right, scope)
   end
 
   def with_guarded_scope(scope)
@@ -1112,6 +1140,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   #
   def unfold(result, array, scope)
     array.each do |x|
+      x = unwind_parentheses(x)
       if x.is_a?(Puppet::Pops::Model::UnfoldExpression)
         result.concat(evaluate(x, scope))
       else
@@ -1122,4 +1151,9 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   end
   private :unfold
 
+  def unwind_parentheses(o)
+    return o unless o.is_a?(Puppet::Pops::Model::ParenthesizedExpression)
+    unwind_parentheses(o.expr)
+  end
+  private :unwind_parentheses
 end