puppet 3.7.5-x64-mingw32 → 3.8.1-x64-mingw32

data/lib/puppet/functions/hiera_include.rb

@@ -1,4 +1,4 @@
-require 'hiera_puppet'
+require 'hiera/puppet_function'
 
 # Assigns classes to a node using an array merge lookup that retrieves the value for a user-specified key
 #   from a Hiera data source.

data/lib/puppet/node/environment.rb

@@ -568,6 +568,10 @@ class Puppet::Node::Environment
         parser.parse
       end
     end
+  rescue Puppet::ParseErrorWithIssue => detail
+    @known_resource_types.parse_failed = true
+    detail.environment = self.name
+    raise
   rescue => detail
     @known_resource_types.parse_failed = true
 

data/lib/puppet/parser/compiler.rb

@@ -32,6 +32,10 @@ class Puppet::Parser::Compiler
     end
 
     new(node).compile {|resulting_catalog| resulting_catalog.to_resource }
+  rescue Puppet::ParseErrorWithIssue => detail
+    detail.node = node.name
+    Puppet.log_exception(detail)
+    raise
   rescue => detail
     message = "#{detail} on node #{node.name}"
     Puppet.log_exception(detail, message)
@@ -150,8 +154,7 @@ class Puppet::Parser::Compiler
 
   # Constructs the overrides for the context
   def context_overrides()
-    if Puppet.future_parser?
-      require 'puppet/loaders'
+    if Puppet.future_parser?(environment)
       {
         :current_environment => environment,
         :global_scope => @topscope,             # 4x placeholder for new global scope

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

@@ -38,8 +38,33 @@ Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :arity => -2,
       defined(File[\'/some/file\'])
       defined(Class[\'foo\'])
 
+  The `defined` function does not answer if 4.x data types (e.g. `Integer`) are defined. If
+  given the string 'integer' the result is false, and if given a non CatalogEntry type,
+  an error is raised.
+
+  The rules for asking for undef, empty strings, and the main class are different from 3.x
+  (non future parser) and 4.x (with future parser or in Puppet 4.0.0 and later):
+
+      defined('')     # 3.x => true, 4.x => false
+      defined(undef)  # 3.x => true, 4.x => error
+      defined('main') # 3.x => false, 4.x => true
+
+  With the future parser, it is also possible to ask specifically if a name is
+  a resource type (built in or defined), or a class, by giving its type:
+
+      defined(Type[Class['foo']])
+      defined(Type[Resource['foo']])
+
+  Which is different from asking:
+
+      defined('foo')
+
+  Since the later returns true if 'foo' is either a class, a built-in resource type, or a user defined
+  resource type, and a specific request like `Type[Class['foo']]` only returns true if `'foo'` is a class.
+
  - Since 2.7.0
- - Since 3.6.0 variable reference and future parser types") do |vals|
+ - Since 3.6.0 variable reference and future parser types
+ - Since 3.8.1 type specific requests with future parser") do |vals|
     vals = [vals] unless vals.is_a?(Array)
     vals.any? do |val|
       case val

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

@@ -1,3 +1,5 @@
+require 'puppet/file_system'
+
 Puppet::Parser::Functions::newfunction(
   :file, :arity => -2, :type => :rvalue,
   :doc => "Loads a file from a module and returns its contents as a string.
@@ -24,7 +26,7 @@ Puppet::Parser::Functions::newfunction(
     end
 
     if path
-      File.read(path)
+      Puppet::FileSystem.read_preserve_line_endings(path)
     else
       raise Puppet::ParseError, "Could not find any files from #{vals.join(", ")}"
     end

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.
@@ -97,7 +98,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

@@ -119,9 +119,14 @@ 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'
   require 'puppet/bindings'
   require 'puppet/functions'
+  require 'puppet/loaders'
 end

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

@@ -254,17 +254,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/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/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/evaluator_impl.rb

@@ -53,6 +53,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
@@ -254,7 +257,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)
@@ -404,14 +407,19 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     left = evaluate(o.left_expr, scope)
     right = evaluate(o.right_expr, scope)
 
+    @migration_checker.report_uc_bareword_type(left, o.left_expr)
+    @migration_checker.report_uc_bareword_type(right, o.right_expr)
+
     begin
     # Left is a type
     if left.is_a?(Puppet::Pops::Types::PAnyType)
       case o.operator
       when :'=='
+        @migration_checker.report_equality_type_mismatch(left, right, o)
         @@type_calculator.equals(left,right)
 
       when :'!='
+        @migration_checker.report_equality_type_mismatch(left, right, o)
         !@@type_calculator.equals(left,right)
 
       when :'<'
@@ -432,8 +440,10 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     else
       case o.operator
       when :'=='
+        @migration_checker.report_equality_type_mismatch(left, right, o)
         @@compare_operator.equals(left,right)
       when :'!='
+        @migration_checker.report_equality_type_mismatch(left, right, o)
         ! @@compare_operator.equals(left,right)
       when :'<'
         @@compare_operator.compare(left,right) < 0
@@ -478,6 +488,8 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     left = evaluate(o.left_expr, scope)
     pattern = evaluate(o.right_expr, scope)
 
+    @migration_checker.report_uc_bareword_type(left, o.left_expr)
+
     # matches RHS types as instance of for all types except a parameterized Regexp[R]
     if pattern.is_a?(Puppet::Pops::Types::PAnyType)
       # evaluate as instance? of type check
@@ -507,6 +519,8 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   def eval_InExpression o, scope
     left = evaluate(o.left_expr, scope)
     right = evaluate(o.right_expr, scope)
+    @migration_checker.report_uc_bareword_type(left, o.left_expr)
+    @migration_checker.report_in_expression(o)
     @@compare_operator.include?(right, left, scope)
   end
 
@@ -515,7 +529,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
@@ -523,7 +537,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
@@ -562,21 +576,24 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     #
     with_guarded_scope(scope) do
       test = evaluate(o.test, scope)
+      @migration_checker.report_uc_bareword_type(test, o.test)
+
       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)
@@ -800,13 +817,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)
@@ -892,9 +909,11 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     #
     with_guarded_scope(scope) do
       test = evaluate(o.left_expr, scope)
+      @migration_checker.report_uc_bareword_type(test, o.left_expr)
+
       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
@@ -902,9 +921,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
@@ -932,7 +951,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)
@@ -943,7 +962,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)
@@ -1144,22 +1163,12 @@ 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
-    if right.is_a?(Regexp)
-      return false unless left.is_a? String
-      matched = right.match(left)
-      set_match_data(matched, scope) # creates or clears ephemeral
-      !!matched # convert to boolean
-    elsif right.is_a?(Puppet::Pops::Types::PAnyType)
-      # 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?(right, left)
-    else
-      # Handle equality the same way as the language '==' operator (case insensitive etc.)
-      @@compare_operator.equals(left,right)
+  def is_match?(left, right, o, option_expr, scope)
+    @migration_checker.report_option_type_mismatch(left, right, option_expr, o)
+    if right.is_a?(Puppet::Pops::Types::PAnyType)
+      @migration_checker.report_uc_bareword_type(right, o)
     end
+    @@compare_operator.match(left, right, scope)
   end
 
   def with_guarded_scope(scope)
@@ -1180,6 +1189,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
@@ -1190,4 +1200,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