puppet 4.10.0 → 5.0.0

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

@@ -1,4 +1,3 @@
-require 'rgen/ecore/ecore'
 require 'puppet/parser/scope'
 require 'puppet/pops/evaluator/compare_operator'
 require 'puppet/pops/evaluator/relationship_operator'
@@ -264,7 +263,7 @@ class EvaluatorImpl
   end
 
   def eval_Factory(o, scope)
-    evaluate(o.current, scope)
+    evaluate(o.model, scope)
   end
 
   # Evaluates any object not evaluated to something else to itself.
@@ -358,7 +357,7 @@ class EvaluatorImpl
     name = lvalue(o.left_expr, scope)
     value = evaluate(o.right_expr, scope)
 
-    if o.operator == :'='
+    if o.operator == '='
       assign(name, value, o, scope)
     else
       fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
@@ -366,8 +365,8 @@ class EvaluatorImpl
     value
   end
 
-  ARITHMETIC_OPERATORS = [:'+', :'-', :'*', :'/', :'%', :'<<', :'>>']
-  COLLECTION_OPERATORS = [:'+', :'-', :'<<']
+  ARITHMETIC_OPERATORS = ['+', '-', '*', '/', '%', '<<', '>>'].freeze
+  COLLECTION_OPERATORS = ['+', '-', '<<'].freeze
 
   # Handles binary expression where lhs and rhs are array/hash or numeric and operator is +, - , *, % / << >>
   #
@@ -376,7 +375,7 @@ class EvaluatorImpl
     right = evaluate(o.right_expr, scope)
 
     begin
-      result = calculate(left, right, o.operator, o.left_expr, o.right_expr, scope)
+      result = calculate(left, right, o, scope)
     rescue ArgumentError => e
       fail(Issues::RUNTIME_ERROR, o, {:detail => e.message}, e)
     end
@@ -386,19 +385,21 @@ class EvaluatorImpl
 
   # Handles binary expression where lhs and rhs are array/hash or numeric and operator is +, - , *, % / << >>
   #
-  def calculate(left, right, operator, left_o, right_o, scope)
+  def calculate(left, right, bin_expr, scope)
+    operator = bin_expr.operator
     unless ARITHMETIC_OPERATORS.include?(operator)
-      fail(Issues::UNSUPPORTED_OPERATOR, left_o.eContainer, {:operator => o.operator})
+      fail(Issues::UNSUPPORTED_OPERATOR, bin_expr, {:operator => operator})
     end
 
+    left_o = bin_expr.left_expr
     if (left.is_a?(Array) || left.is_a?(Hash)) && COLLECTION_OPERATORS.include?(operator)
       # Handle operation on collections
       case operator
-      when :'+'
+      when '+'
         concatenate(left, right)
-      when :'-'
+      when '-'
         delete(left, right)
-      when :'<<'
+      when '<<'
         unless left.is_a?(Array)
           fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
         end
@@ -407,20 +408,20 @@ class EvaluatorImpl
     else
       # Handle operation on numeric
       left = coerce_numeric(left, left_o, scope)
-      right = coerce_numeric(right, right_o, scope)
+      right = coerce_numeric(right, bin_expr.right_expr, scope)
       begin
-        if operator == :'%' && (left.is_a?(Float) || right.is_a?(Float))
+        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)
-          if operator == :'+' || operator == :'*' && right.is_a?(Time::Timespan)
+          if operator == '+' || operator == '*' && right.is_a?(Time::Timespan)
             # Switch places. Let the TimeData do the arithmetic
             x = left
             left = right
             right = x
-          elsif operator == :'-' && right.is_a?(Time::Timespan)
+          elsif operator == '-' && right.is_a?(Time::Timespan)
             left = Time::Timespan.new((left * Time::NSECS_PER_SEC).to_i)
           else
             fail(Issues::OPERATOR_NOT_APPLICABLE_WHEN, left_o, {:operator => operator, :left_value => left, :right_value => right})
@@ -430,10 +431,17 @@ class EvaluatorImpl
       rescue NoMethodError => e
         fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
       rescue ZeroDivisionError => e
-        fail(Issues::DIV_BY_ZERO, right_o)
+        fail(Issues::DIV_BY_ZERO, bin_expr.right_expr)
       end
-      if result == Float::INFINITY || result == -Float::INFINITY
-        fail(Issues::RESULT_IS_INFINITY, left_o, {:operator => operator})
+      case result
+      when Float
+        if result == Float::INFINITY || result == -Float::INFINITY
+          fail(Issues::RESULT_IS_INFINITY, left_o, {:operator => operator})
+        end
+      when Integer
+        if result < MIN_INTEGER || result > MAX_INTEGER
+          fail(Issues::NUMERIC_OVERFLOW, bin_expr, {:value => result})
+        end
       end
       result
     end
@@ -492,22 +500,22 @@ class EvaluatorImpl
     # Left is a type
     if left.is_a?(Types::PAnyType)
       case o.operator
-      when :'=='
+      when '=='
         @@type_calculator.equals(left,right)
 
-      when :'!='
+      when '!='
         !@@type_calculator.equals(left,right)
 
-      when :'<'
+      when '<'
         # left can be assigned to right, but they are not equal
         @@type_calculator.assignable?(right, left) && ! @@type_calculator.equals(left,right)
-      when :'<='
+      when '<='
         # left can be assigned to right
         @@type_calculator.assignable?(right, left)
-      when :'>'
+      when '>'
         # right can be assigned to left, but they are not equal
         @@type_calculator.assignable?(left,right) && ! @@type_calculator.equals(left,right)
-      when :'>='
+      when '>='
         # right can be assigned to left
         @@type_calculator.assignable?(left, right)
       else
@@ -515,17 +523,17 @@ class EvaluatorImpl
       end
     else
       case o.operator
-      when :'=='
+      when '=='
         @@compare_operator.equals(left,right)
-      when :'!='
+      when '!='
         ! @@compare_operator.equals(left,right)
-      when :'<'
+      when '<'
         @@compare_operator.compare(left,right) < 0
-      when :'<='
+      when '<='
         @@compare_operator.compare(left,right) <= 0
-      when :'>'
+      when '>'
         @@compare_operator.compare(left,right) > 0
-      when :'>='
+      when '>='
         @@compare_operator.compare(left,right) >= 0
       else
         fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
@@ -567,13 +575,13 @@ class EvaluatorImpl
       # evaluate as instance? of type check
       matched = pattern.instance?(left)
       # convert match result to Boolean true, or false
-      return o.operator == :'=~' ? !!matched : !matched
+      return o.operator == '=~' ? !!matched : !matched
     end
 
     if pattern.is_a?(SemanticPuppet::VersionRange)
       # evaluate if range includes version
       matched = Types::PSemVerRangeType.include?(pattern, left)
-      return o.operator == :'=~' ? matched : !matched
+      return o.operator == '=~' ? matched : !matched
     end
 
     begin
@@ -589,7 +597,7 @@ class EvaluatorImpl
     set_match_data(matched,scope) # creates ephemeral
 
     # convert match result to Boolean true, or false
-    o.operator == :'=~' ? !!matched : !matched
+    o.operator == '=~' ? !!matched : !matched
   end
 
   # Evaluates Puppet DSL `in` expression
@@ -861,7 +869,7 @@ class EvaluatorImpl
       actual = type_calculator.generalize(type_calculator.infer(hashed_params)).to_s
       fail(Issues::TYPE_MISMATCH, o.expr, {:expected => 'Hash', :actual => actual})
     end
-    hashed_params.map { |k,v| create_resource_parameter(o, scope, k, v, :'=>') }
+    hashed_params.map { |k,v| create_resource_parameter(o, scope, k, v, '=>') }
   end
 
   # Sets default parameter values for a type, produces the type
@@ -1169,11 +1177,11 @@ class EvaluatorImpl
           Hash[*y]
         end
       else
-        raise ArgumentError.new("Can only append Array or Hash to a Hash")
+        raise ArgumentError.new(_("Can only append Array or Hash to a Hash"))
       end
       x.merge y # new hash with overwrite
     else
-      raise ArgumentError.new("Can only append to an Array or a Hash.")
+      raise ArgumentError.new(_("Can only append to an Array or a Hash."))
     end
   end
 
@@ -1203,7 +1211,7 @@ class EvaluatorImpl
       end
       y.each {|e| result.delete(e) }
     else
-      raise ArgumentError.new("Can only delete from an Array or Hash.")
+      raise ArgumentError.new(_("Can only delete from an Array or Hash."))
     end
     result
   end

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

@@ -3,13 +3,7 @@
 #
 require 'puppet/plugins/syntax_checkers'
 module Puppet::Pops::Evaluator::ExternalSyntaxSupport
-  # TODO: This can be simplified if the Factory directly supported hash_of/type_of
-  TYPES = Puppet::Pops::Types::TypeFactory
-  SERVICE_TYPE = Puppet::Plugins::SyntaxCheckers::SYNTAX_CHECKERS_TYPE
-  SERVICE_NAME = Puppet::Plugins::SyntaxCheckers::SYNTAX_CHECKERS_KEY
-
   def assert_external_syntax(scope, result, syntax, reference_expr)
-    @@HASH_OF_SYNTAX_CHECKERS ||= TYPES.hash_of(TYPES.type_of(SERVICE_TYPE))
     # ignore 'unspecified syntax'
     return if syntax.nil? || syntax == ''
 
@@ -20,8 +14,7 @@ module Puppet::Pops::Evaluator::ExternalSyntaxSupport
     # Call checker and give it the location information from the expression
     # (as opposed to where the heredoc tag is (somewhere on the line above)).
     acceptor = Puppet::Pops::Validation::Acceptor.new()
-    source_pos = Puppet::Pops::Utils.find_closest_positioned(reference_expr)
-    checker.check(result, syntax, acceptor, source_pos)
+    checker.check(result, syntax, acceptor, reference_expr)
 
     if acceptor.error_count > 0
       checker_message = "Invalid produced text having syntax: '#{syntax}'."
@@ -34,7 +27,7 @@ module Puppet::Pops::Evaluator::ExternalSyntaxSupport
   # Returns nil if there is no registered checker.
   #
   def checker_for_syntax(scope, syntax)
-    checkers_hash = scope.compiler.injector.lookup(scope, @@HASH_OF_SYNTAX_CHECKERS, SERVICE_NAME) || {}
+    checkers_hash = Puppet.lookup(:plugins)[Puppet::Plugins::SyntaxCheckers::SYNTAX_CHECKERS_KEY]
     checkers_hash[lookup_keys_for_syntax(syntax).find {|x| checkers_hash[x] }]
   end
 

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

@@ -1,5 +1,3 @@
-require 'rgen/ecore/ecore'
-
 # Literal values for
 #
 #   * String

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

@@ -56,7 +56,7 @@ class Puppet::Pops::Evaluator::PuppetProc < Proc
     end
   end
 
-  # @return [Fixnum] the arity of the block
+  # @return [Integer] the arity of the block
   # @overrides Block.arity
   # @api public
   def arity

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

@@ -103,14 +103,14 @@ class RelationshipOperator
     o
   end
 
-  RELATIONSHIP_OPERATORS = [:'->', :'~>', :'<-', :'<~']
-  REVERSE_OPERATORS      = [:'<-', :'<~']
+  RELATIONSHIP_OPERATORS = ['->', '~>', '<-', '<~'].freeze
+  REVERSE_OPERATORS      = ['<-', '<~'].freeze
   RELATION_TYPE = {
-    :'->' => :relationship,
-    :'<-' => :relationship,
-    :'~>' => :subscription,
-    :'<~' => :subscription
-  }
+    '->' => :relationship,
+    '<-' => :relationship,
+    '~>' => :subscription,
+    '<~' => :subscription
+  }.freeze
 
   # Evaluate a relationship.
   # TODO: The error reporting is not fine grained since evaluation has already taken place
@@ -151,8 +151,25 @@ class RelationshipOperator
       # Add the relationships to the catalog
       source.each {|s| target.each {|t| add_relationship(s, t, RELATION_TYPE[relationship_expression.operator], scope) }}
 
-      # Produce the transformed source RHS (if this is a chain, this does not need to be done again)
-      real.slice(1)
+      # 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]
+      if real[1].empty?
+        # right side empty, simply use the left (whatever it may be)
+        result = real[0]
+      else
+        right = real[1]
+        if right.size == 1 && right[0].is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
+          # the collector when evaluated later may result in an empty set, if so, the
+          # lazy relationship forming logic needs to have access to the left value.
+          adapter = Puppet::Pops::Adapters::EmptyAlternativeAdapter.adapt(right[0])
+          adapter.empty_alternative = real[0]
+        end
+        result = right
+      end
+      result
+
     rescue NotCatalogTypeError => e
       fail(Issues::NOT_CATALOG_TYPE, relationship_expression, {:type => @type_calculator.string(e.type)})
     rescue IllegalRelationshipOperandError => e

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

@@ -7,6 +7,9 @@ module Puppet::Pops::Evaluator
 # Users should not create instances of this class. Instead the class methods {Runtime3Converter.convert},
 # {Runtime3Converter.map_args}, or {Runtime3Converter.instance} should be used
 class Runtime3Converter
+  MAX_INTEGER =  Puppet::Pops::MAX_INTEGER
+  MIN_INTEGER = Puppet::Pops::MIN_INTEGER
+
   # Converts 4x supported values to a 3x values. Same as calling Runtime3Converter.instance.map_args(...)
   #
   # @param args [Array] Array of values to convert
@@ -61,6 +64,19 @@ class Runtime3Converter
     @inner ? :undef : undef_value
   end
 
+  def convert_Integer(o, scope, undef_value)
+    return o unless o < MIN_INTEGER || o > MAX_INTEGER
+    range_end = o > MAX_INTEGER ? 'max' : 'min'
+    raise Puppet::Error, "Use of a Ruby Integer outside of Puppet Integer #{range_end} range, got '#{"0x%x" % o}'"
+  end
+
+  def convert_BigDecimal(o, scope, undef_value)
+    # transform to same value float value if possible without any rounding error
+    f = o.to_f
+    return f unless f != o
+    raise Puppet::Error, "Use of a Ruby BigDecimal value outside Puppet Float range, got '#{o}'"
+  end
+
   def convert_String(o, scope, undef_value)
     # although wasteful, needed because user code may mutate these strings in Resources
     o.frozen? ? o.dup : o
@@ -83,7 +99,7 @@ class Runtime3Converter
   end
 
   def convert_Iterator(o, scope, undef_value)
-    raise Puppet::Error, 'Use of an Iterator is not supported here'
+    raise Puppet::Error, _('Use of an Iterator is not supported here')
   end
 
   def convert_Symbol(o, scope, undef_value)

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

@@ -67,12 +67,10 @@ module Runtime3ResourceSupport
   end
 
   def self.find_resource_type(scope, type_name)
-    type_name = type_name.to_s.downcase
     find_builtin_resource_type(scope, type_name) || find_defined_resource_type(scope, type_name)
   end
 
   def self.find_resource_type_or_class(scope, name)
-    type_name = type_name.to_s.downcase
     find_builtin_resource_type(scope, name) || find_defined_resource_type(scope, name) || find_hostclass(scope, name)
   end
 

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

@@ -44,6 +44,30 @@ module Runtime3Support
     diagnostic_producer.accept(issue, semantic, options, except)
   end
 
+  # Optionally (based on severity) Fails the evaluation with a given issue
+  # If the given issue is configured to be of severity < :error it is only reported, and the function returns.
+  # The location the issue is reported against is found is based on the top file/line in the puppet call stack
+  #
+  # @param issue [Issue] the issue to report
+  # @param options [Hash] hash of optional named data elements for the given issue
+  # @return [!] this method may not return, nil if it does
+  # @raise [Puppet::ParseError] an evaluation error initialized from the arguments
+  #
+  def runtime_issue(issue, options={})
+    # Get position from puppet runtime stack
+    stacktrace = Puppet::Pops::PuppetStack.stacktrace()
+    if stacktrace.size > 0
+      file, line = stacktrace[0]
+    else
+      file = nil
+      line = nil
+    end
+    # Use a SemanticError as the sourcepos
+    semantic = Puppet::Pops::SemanticError.new(issue, nil, options.merge({:file => file, :line => line}))
+    optionally_fail(issue,  semantic)
+    nil
+  end
+
   # Binds the given variable name to the given value in the given scope.
   # The reference object `o` is intended to be used for origin information - the 3x scope implementation
   # only makes use of location when there is an error. This is now handled by other mechanisms; first a check
@@ -60,13 +84,7 @@ module Runtime3Support
     # TODO: Improve the messy implementation in Scope.
     #
     if name == "server_facts"
-      if Puppet[:trusted_server_facts] || Puppet[:strict] == :error
-        fail(Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
-      elsif Puppet[:strict] == :warning
-        file, line = extract_file_line(o)
-        msg = "Assignment to $server_facts is deprecated"
-        Puppet.warn_once(:deprecation, msg, msg, file, line)
-      end
+      fail(Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
     end
 
     if scope.bound?(name)
@@ -236,9 +254,14 @@ module Runtime3Support
   # @return [Numeric] value `v` converted to Numeric.
   #
   def coerce_numeric(v, o, scope)
+    if v.is_a?(Numeric)
+      return v
+    end
     unless n = Utils.to_n(v)
       fail(Issues::NOT_NUMERIC, o, {:value => v})
     end
+    # this point is reached if there was a conversion
+    optionally_fail(Issues::NUMERIC_COERCION, o, {:before => v, :after => n})
     n
   end
 
@@ -302,7 +325,7 @@ module Runtime3Support
       :name   => name,
       :value  => convert(value, scope, nil), # converted to 3x since 4x supports additional objects / types
       :source => scope.source, :line => line, :file => file,
-      :add    => operator == :'+>'
+      :add    => operator == '+>'
     )
   end
 
@@ -356,13 +379,14 @@ module Runtime3Support
       end
       t = Runtime3ResourceSupport.find_resource_type(scope, r.type_name)
       resource = Puppet::Parser::Resource.new(
-        t, r.title,
-        :parameters => evaluated_parameters,
-        :file => file,
-        :line => line,
-        # WTF is this? Which source is this? The file? The name of the context ?
-        :source => scope.source,
-        :scope => scope
+        t, r.title, {
+          :parameters => evaluated_parameters,
+          :file => file,
+          :line => line,
+          # WTF is this? Which source is this? The file? The name of the context ?
+          :source => scope.source,
+          :scope => scope
+        }, false # defaults should not override
       )
 
       scope.compiler.add_override(resource)
@@ -445,21 +469,7 @@ module Runtime3Support
   end
 
   def extract_file_line(o)
-    positioned = find_closest_with_offset(o)
-    unless positioned.nil?
-      locator = Adapters::SourcePosAdapter.find_locator(positioned)
-      return [locator.file, locator.line_for_offset(positioned.offset)] unless locator.nil?
-    end
-    [nil, -1]
-  end
-
-  def find_closest_with_offset(o)
-    if o.offset.nil?
-      c = o.eContainer
-      c.nil? ? nil : find_closest_with_offset(c)
-    else
-      o
-    end
+    o.is_a?(Model::Positioned) ? [o.file, o.line] : [nil, -1]
   end
 
   # Creates a diagnostic producer
@@ -498,6 +508,10 @@ module Runtime3Support
       # Store config issues, ignore or warning
       p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
       p[Issues::RT_NO_STORECONFIGS]           = Puppet[:storeconfigs] ? :ignore : :warning
+      p[Issues::CLASS_NOT_VIRTUALIZABLE]      = Puppet[:strict] == :off ? :warning : Puppet[:strict]
+      p[Issues::NUMERIC_COERCION]             = Puppet[:strict] == :off ? :ignore : Puppet[:strict]
+      p[Issues::SERIALIZATION_UNKNOWN_CONVERTED_TO_STRING] = Puppet[:strict] == :off ? :warning : Puppet[:strict]
+      p[Issues::SERIALIZATION_UNKNOWN_KEY_CONVERTED_TO_STRING] = Puppet[:strict] == :off ? :warning : Puppet[:strict]
     end
   end
 

data/lib/puppet/pops/functions/dispatch.rb

@@ -69,7 +69,6 @@ class Dispatch < Evaluator::CallableSignature
     if @injections.empty?
       args
     else
-      injector = nil # lazy lookup of injector Puppet.lookup(:injector)
       new_args = []
       @weaving.each do |knit|
         if knit.is_a?(Array)
@@ -79,12 +78,8 @@ class Dispatch < Evaluator::CallableSignature
             when :dispatcher_internal
               # currently only supports :scope injection
               scope
-            when :producer
-              injector ||= Puppet.lookup(:injector)
-              injector.lookup_producer(scope, injection_data[0], injection_data[2])
             else
-              injector ||= Puppet.lookup(:injector)
-              injector.lookup(scope, injection_data[0], injection_data[2])
+              raise_error ArgumentError, "Unknown injection #{injection_data[3]}"
             end
         else
           # Careful so no new nil arguments are added since they would override default