puppet 8.2.0-x86-mingw32 → 8.4.0-x86-mingw32

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/parser/scope'
 require_relative '../../../puppet/pops/evaluator/compare_operator'
 require_relative '../../../puppet/pops/evaluator/relationship_operator'
@@ -36,11 +37,6 @@ class EvaluatorImpl
 
   COMMA_SEPARATOR = ', '
 
-  # Reference to Issues name space makes it easier to refer to issues
-  # (Issues are shared with the validator).
-  #
-  Issues = Issues
-
   def initialize
     @@initialized ||= static_initialize
 
@@ -80,20 +76,17 @@ class EvaluatorImpl
   def evaluate(target, scope)
     begin
       @@eval_visitor.visit_this_1(self, target, scope)
-
     rescue SemanticError => e
       # 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 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.
@@ -110,17 +103,13 @@ class EvaluatorImpl
         # 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 StopIteration => e
       # Ensure these are not rescued as StandardError
       raise e
-
     rescue StandardError => e
       # All other errors, use its message and call stack
       fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e)
@@ -220,6 +209,7 @@ class EvaluatorImpl
     if name =~ /::/
       fail(Issues::CROSS_SCOPE_ASSIGNMENT, o.left_expr, {:name => name})
     end
+
     set_variable(name, value, o, scope)
     value
   end
@@ -238,13 +228,14 @@ class EvaluatorImpl
     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)
+               values.fetch(lval) {|k| fail(Issues::MISSING_MULTI_ASSIGNMENT_KEY, o, :key =>k)},
+               o, scope)
       end
     elsif values.is_a?(Puppet::Pops::Types::PClassType)
       if Puppet[:tasks]
         fail(Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING, o, {:operation => _('multi var assignment from class')})
       end
+
       # assign variables from class variables
       # lookup class resource and return one or more parameter values
       # TODO: behavior when class_name is nil
@@ -271,6 +262,7 @@ class EvaluatorImpl
       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
@@ -323,6 +315,7 @@ class EvaluatorImpl
   def eval_QualifiedReference(o, scope)
     type = Types::TypeParser.singleton.interpret(o)
     fail(Issues::UNKNOWN_RESOURCE_TYPE, o, {:type_name => type.type_string }) if type.is_a?(Types::PTypeReferenceType)
+
     type
   end
 
@@ -395,7 +388,6 @@ class EvaluatorImpl
     result
   end
 
-
   # Handles binary expression where lhs and rhs are array/hash or numeric and operator is +, - , *, % / << >>
   #
   def calculate(left, right, bin_expr, scope)
@@ -418,6 +410,7 @@ class EvaluatorImpl
         unless left.is_a?(Array)
           fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
         end
+
         left + [right]
       end
     else
@@ -428,6 +421,7 @@ class EvaluatorImpl
         if operator == '%' && (left.is_a?(Float) || right.is_a?(Float))
           # Deny users the fun of seeing severe rounding errors and confusing results
           fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left}) if left.is_a?(Float)
+
           fail(Issues::OPERATOR_NOT_APPLICABLE_WHEN, left_o, {:operator => operator, :left_value => left, :right_value => right})
         end
         if right.is_a?(Time::TimeData) && !left.is_a?(Time::TimeData)
@@ -531,54 +525,54 @@ class EvaluatorImpl
     right = evaluate(o.right_expr, scope)
 
     begin
-    # Left is a type
-    if left.is_a?(Types::PAnyType)
-      case o.operator
-      when '=='
-        @@type_calculator.equals(left,right)
-
-      when '!='
-        !@@type_calculator.equals(left,right)
-
-      when '<'
-        # left can be assigned to right, but they are not equal
-        @@type_calculator.assignable?(right, left) && ! @@type_calculator.equals(left,right)
-      when '<='
-        # left can be assigned to right
-        @@type_calculator.assignable?(right, left)
-      when '>'
-        # right can be assigned to left, but they are not equal
-        @@type_calculator.assignable?(left,right) && ! @@type_calculator.equals(left,right)
-      when '>='
-        # right can be assigned to left
-        @@type_calculator.assignable?(left, right)
-      else
-        fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
-      end
-    else
-      case o.operator
-      when '=='
-        @@compare_operator.equals(left,right)
-      when '!='
-        ! @@compare_operator.equals(left,right)
-      when '<'
-        @@compare_operator.compare(left,right) < 0
-      when '<='
-        @@compare_operator.compare(left,right) <= 0
-      when '>'
-        @@compare_operator.compare(left,right) > 0
-      when '>='
-        @@compare_operator.compare(left,right) >= 0
+      # Left is a type
+      if left.is_a?(Types::PAnyType)
+        case o.operator
+        when '=='
+          @@type_calculator.equals(left,right)
+
+        when '!='
+          !@@type_calculator.equals(left,right)
+
+        when '<'
+          # left can be assigned to right, but they are not equal
+          @@type_calculator.assignable?(right, left) && ! @@type_calculator.equals(left,right)
+        when '<='
+          # left can be assigned to right
+          @@type_calculator.assignable?(right, left)
+        when '>'
+          # right can be assigned to left, but they are not equal
+          @@type_calculator.assignable?(left,right) && ! @@type_calculator.equals(left,right)
+        when '>='
+          # right can be assigned to left
+          @@type_calculator.assignable?(left, right)
+        else
+          fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
+        end
       else
-        fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
+        case o.operator
+        when '=='
+          @@compare_operator.equals(left,right)
+        when '!='
+          ! @@compare_operator.equals(left,right)
+        when '<'
+          @@compare_operator.compare(left,right) < 0
+        when '<='
+          @@compare_operator.compare(left,right) <= 0
+        when '>'
+          @@compare_operator.compare(left,right) > 0
+        when '>='
+          @@compare_operator.compare(left,right) >= 0
+        else
+          fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
+        end
       end
-    end
     rescue ArgumentError => e
       fail(Issues::COMPARISON_NOT_POSSIBLE, o, {
-        :operator => o.operator,
-        :left_value => left,
-        :right_value => right,
-        :detail => e.message}, e)
+             :operator => o.operator,
+             :left_value => left,
+             :right_value => right,
+             :detail => e.message}, e)
     end
   end
 
@@ -677,7 +671,7 @@ class EvaluatorImpl
   # Evaluates all statements and produces the last evaluated value
   #
   def eval_BlockExpression o, scope
-    o.statements.reduce(nil) {|memo, s| evaluate(s, scope)}
+    o.statements.reduce(nil) {|_memo, s| evaluate(s, scope)}
   end
 
   # Performs optimized search over case option values, lazily evaluating each
@@ -711,8 +705,8 @@ class EvaluatorImpl
             is_match?(test, evaluate(c, scope), c, co, scope)
           end
         end
-        result = evaluate(co.then_expr, scope)
-        true # the option was picked
+          result = evaluate(co.then_expr, scope)
+          true # the option was picked
         end
       end
         result # an option was picked, and produced a result
@@ -755,10 +749,10 @@ class EvaluatorImpl
       line = 0
       # Add stack frame for "top scope" logic. See Puppet::Pops::PuppetStack
       return Puppet::Pops::PuppetStack.stack(file, line, self, 'evaluate', [o.body, scope])
-      #evaluate(o.body, scope)
+      # evaluate(o.body, scope)
     rescue Puppet::Pops::Evaluator::PuppetStopIteration => ex
       # breaking out of a file level program is not allowed
-      #TRANSLATOR break() is a method that should not be translated
+      # TRANSLATOR break() is a method that should not be translated
       raise Puppet::ParseError.new(_("break() from context where this is illegal"), ex.file, ex.line)
     end
   end
@@ -771,45 +765,47 @@ class EvaluatorImpl
 
     # Get the type name
     type_name =
-    if (tmp_name = o.type_name).is_a?(Model::QualifiedName)
-      tmp_name.value # already validated as a name
-    else
-      type_name_acceptable =
-      case o.type_name
-      when Model::QualifiedReference
-        true
-      when Model::AccessExpression
-        o.type_name.left_expr.is_a?(Model::QualifiedReference)
-      end
-
-      evaluated_name = evaluate(tmp_name, scope)
-      unless type_name_acceptable
-        actual = type_calculator.generalize(type_calculator.infer(evaluated_name)).to_s
-        fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual => actual})
-      end
+      if (tmp_name = o.type_name).is_a?(Model::QualifiedName)
+        tmp_name.value # already validated as a name
+      else
+        type_name_acceptable =
+          case o.type_name
+          when Model::QualifiedReference
+            true
+          when Model::AccessExpression
+            o.type_name.left_expr.is_a?(Model::QualifiedReference)
+          end
 
-      # must be a CatalogEntry subtype
-      case evaluated_name
-      when Types::PClassType
-        unless evaluated_name.class_name.nil?
-          fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
+        evaluated_name = evaluate(tmp_name, scope)
+        unless type_name_acceptable
+          actual = type_calculator.generalize(type_calculator.infer(evaluated_name)).to_s
+          fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual => actual})
         end
-        'class'
 
-      when Types::PResourceType
-        unless evaluated_name.title().nil?
-          fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
-        end
-        evaluated_name.type_name # assume validated
+        # must be a CatalogEntry subtype
+        case evaluated_name
+        when Types::PClassType
+          unless evaluated_name.class_name.nil?
+            fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
+          end
 
-      when Types::PTypeReferenceType
-        fail(Issues::UNKNOWN_RESOURCE_TYPE, o.type_string, {:type_name => evaluated_name.to_s})
+          'class'
 
-      else
-        actual = type_calculator.generalize(type_calculator.infer(evaluated_name)).to_s
-        fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=>actual})
+        when Types::PResourceType
+          unless evaluated_name.title().nil?
+            fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
+          end
+
+          evaluated_name.type_name # assume validated
+
+        when Types::PTypeReferenceType
+          fail(Issues::UNKNOWN_RESOURCE_TYPE, o.type_string, {:type_name => evaluated_name.to_s})
+
+        else
+          actual = type_calculator.generalize(type_calculator.infer(evaluated_name)).to_s
+          fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=>actual})
+        end
       end
-    end
 
     # This is a runtime check - the model is valid, but will have runtime issues when evaluated
     # and storeconfigs is not set.
@@ -834,6 +830,7 @@ class EvaluatorImpl
       if titles.nil?
         fail(Issues::MISSING_TITLE, body.title)
       end
+
       titles = [titles].flatten
 
       # Check types of evaluated titles and duplicate entries
@@ -846,11 +843,12 @@ class EvaluatorImpl
           fail(Issues::ILLEGAL_TITLE_TYPE_AT, body.title, {:index => index, :actual => actual})
 
         elsif title == EMPTY_STRING
-         fail(Issues::EMPTY_STRING_TITLE_AT, body.title, {:index => index})
+          fail(Issues::EMPTY_STRING_TITLE_AT, body.title, {:index => index})
 
         elsif titles_to_body[title]
           fail(Issues::DUPLICATE_TITLE, o, {:title => title})
         end
+
         titles_to_body[title] = body
       end
 
@@ -868,6 +866,7 @@ class EvaluatorImpl
           if param_memo.include? p.name
             fail(Issues::DUPLICATE_ATTRIBUTE, o, {:attribute => p.name})
           end
+
           param_memo[p.name] = p
         end
         param_memo
@@ -924,12 +923,12 @@ class EvaluatorImpl
   def eval_ResourceDefaultsExpression(o, scope)
     type = evaluate(o.type_ref, scope)
     type_name =
-    if type.is_a?(Types::PResourceType) && !type.type_name.nil? && type.title.nil?
-      type.type_name # assume it is a valid name
-    else
-      actual = type_calculator.generalize(type_calculator.infer(type))
-      fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_ref, {:actual => actual})
-    end
+      if type.is_a?(Types::PResourceType) && !type.type_name.nil? && type.title.nil?
+        type.type_name # assume it is a valid name
+      else
+        actual = type_calculator.generalize(type_calculator.infer(type))
+        fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_ref, {:actual => actual})
+      end
     evaluated_parameters = o.operations.map {|op| evaluate(op, scope) }
     create_resource_defaults(o, scope, type_name, evaluated_parameters)
     # Produce the type
@@ -971,11 +970,13 @@ class EvaluatorImpl
     unless o.functor_expr.is_a? Model::NamedAccessExpression
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function accessor', :container => o})
     end
+
     receiver = unfold([], [o.functor_expr.left_expr], scope)
     name = o.functor_expr.right_expr
     unless name.is_a? Model::QualifiedName
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end
+
     name = name.value # the string function name
 
     obj = receiver[0]
@@ -1088,7 +1089,9 @@ class EvaluatorImpl
     # may occur for some evaluation use cases.
     case name
     when String
+      # do nothing
     when Numeric
+      # do nothing
     else
       fail(Issues::ILLEGAL_VARIABLE_EXPRESSION, o.expr)
     end
@@ -1101,7 +1104,6 @@ class EvaluatorImpl
     o.segments.collect {|expr| string(evaluate(expr, scope), scope)}.join
   end
 
-
   # If the wrapped expression is a QualifiedName, it is taken as the name of a variable in scope.
   # Note that this is different from the 3.x implementation, where an initial qualified name
   # is accepted. (e.g. `"---${var + 1}---"` is legal. This implementation requires such concrete
@@ -1125,7 +1127,7 @@ class EvaluatorImpl
   end
 
   def string_Symbol(o, scope)
-    if :undef == o  # optimized comparison 1.44 vs 1.95
+    if :undef == o # optimized comparison 1.44 vs 1.95
       EMPTY_STRING
     else
       o.to_s
@@ -1211,37 +1213,38 @@ class EvaluatorImpl
     case x
     when Array
       y = case y
-      when Array then y
-      when Hash  then y.to_a
-      else
-        [y]
-      end
+          when Array then y
+          when Hash  then y.to_a
+          else            [y]
+          end
       x + y # new array with concatenation
     when Hash
       y = case y
-      when Hash then y
-      when Array
-        # Hash[[a, 1, b, 2]] => {}
-        # Hash[a,1,b,2] => {a => 1, b => 2}
-        # Hash[[a,1], [b,2]] => {[a,1] => [b,2]}
-        # Hash[[[a,1], [b,2]]] => {a => 1, b => 2}
-        # Use type calculator to determine if array is Array[Array[?]], and if so use second form
-        # of call
-        t = @@type_calculator.infer(y)
-        if t.element_type.is_a? Types::PArrayType
-          Hash[y]
-        else
-          Hash[*y]
-        end
-      else
-        raise ArgumentError.new(_('Can only append Array or Hash to a Hash'))
-      end
+          when Hash then y
+          when Array
+            # Hash[[a, 1, b, 2]] => {}
+            # Hash[a,1,b,2] => {a => 1, b => 2}
+            # Hash[[a,1], [b,2]] => {[a,1] => [b,2]}
+            # Hash[[[a,1], [b,2]]] => {a => 1, b => 2}
+            # Use type calculator to determine if array is Array[Array[?]], and if so use second form
+            # of call
+            t = @@type_calculator.infer(y)
+            if t.element_type.is_a? Types::PArrayType
+              Hash[y]
+            else
+              Hash[*y]
+            end
+          else
+            raise ArgumentError.new(_('Can only append Array or Hash to a Hash'))
+          end
       x.merge y # new hash with overwrite
     when URI
       raise ArgumentError.new(_('An URI can only be merged with an URI or String')) unless y.is_a?(String) || y.is_a?(URI)
+
       x + y
     when Types::PBinaryType::Binary
       raise ArgumentError.new(_('Can only append Binary to a Binary')) unless y.is_a?(Types::PBinaryType::Binary)
+
       Types::PBinaryType::Binary.from_binary_string(x.binary_buffer + y.binary_buffer)
     else
       concatenate([x], y)
@@ -1259,19 +1262,17 @@ class EvaluatorImpl
     case x
     when Array
       y = case y
-      when Array then y
-      when Hash then y.to_a
-      else
-        [y]
-      end
+          when Array then y
+          when Hash  then y.to_a
+          else            [y]
+          end
       y.each {|e| result.delete(e) }
     when Hash
       y = case y
-      when Array then y
-      when Hash then y.keys
-      else
-        [y]
-      end
+          when Array then y
+          when Hash  then y.keys
+          else            [y]
+          end
       y.each {|e| result.delete(e) }
     else
       raise ArgumentError.new(_("Can only delete from an Array or Hash."))
@@ -1310,6 +1311,7 @@ class EvaluatorImpl
 
   def unwind_parentheses(o)
     return o unless o.is_a?(Model::ParenthesizedExpression)
+
     unwind_parentheses(o.expr)
   end
   private :unwind_parentheses

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # This module is an integral part of the evaluator. It deals with the concern of validating
 # external syntax in text produced by heredoc and templates.
 #
@@ -43,5 +44,4 @@ module Puppet::Pops::Evaluator::ExternalSyntaxSupport
     end
     result
   end
-
 end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Literal values for
 #
 #   * String
@@ -18,7 +19,7 @@
 #   * String with interpolation
 #
 class Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator
-  #include Puppet::Pops::Utils
+  # include Puppet::Pops::Utils
 
   COMMA_SEPARATOR = ', '
 

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Evaluator
 # Literal values for
@@ -16,7 +17,6 @@ module Evaluator
 # QualifiedReference  # i.e. File, FooBar
 #
 class LiteralEvaluator
-
   COMMA_SEPARATOR = ', '
 
   def initialize

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # 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
@@ -64,6 +65,7 @@ class Puppet::Pops::Evaluator::PuppetProc < Proc
     parameters.reduce(0) do |memo, param|
       count = memo + 1
       break -count unless param[0] == :req
+
       count
     end
   end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Evaluator
 # The RelationshipOperator implements the semantics of the -> <- ~> <~ operators creating relationships or notification
@@ -10,7 +11,6 @@ module Evaluator
 # module. Later when more is cleaned up this can be simplified further.
 #
 class RelationshipOperator
-
   # Provides access to the Puppet 3.x runtime (scope, etc.)
   # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
   #
@@ -18,6 +18,7 @@ class RelationshipOperator
 
   class IllegalRelationshipOperandError < RuntimeError
     attr_reader :operand
+
     def initialize operand
       @operand = operand
     end
@@ -25,6 +26,7 @@ class RelationshipOperator
 
   class NotCatalogTypeError < RuntimeError
     attr_reader :type
+
     def initialize type
       @type = type
     end
@@ -98,6 +100,7 @@ class RelationshipOperator
     unless @type_calculator.assignable?(@catalog_type, o)
       raise NotCatalogTypeError.new(o)
     end
+
     # TODO must check if this is an abstract PResourceType (i.e. without a type_name) - which should fail ?
     # e.g. File -> File (and other similar constructs) - maybe the catalog protects against this since references
     # may be to future objects...
@@ -155,7 +158,7 @@ class RelationshipOperator
       # The result is the transformed source RHS unless it is empty, in which case the transformed LHS is returned.
       # This closes the gap created by an empty set of references in a chain of relationship
       # such that X -> [ ] -> Y results in  X -> Y.
-      #result = real[1].empty? ? real[0] : real[1]
+      # result = real[1].empty? ? real[0] : real[1]
       if real[1].empty?
         # right side empty, simply use the left (whatever it may be)
         result = real[0]
@@ -170,7 +173,6 @@ class RelationshipOperator
         result = right
       end
       result
-
     rescue NotCatalogTypeError => e
       fail(Issues::NOT_CATALOG_TYPE, relationship_expression, {:type => @type_calculator.string(e.type)})
     rescue IllegalRelationshipOperandError => e