puppet 4.7.1 → 4.8.0

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

@@ -92,13 +92,23 @@ class CompareOperator
     end
   end
 
+  def cmp_Timespan(a, b)
+    raise ArgumentError.new('Timespans are only comparable to Timespans, Integers, and Floats') unless b.is_a?(Time::Timespan) ||  b.is_a?(Integer) || b.is_a?(Float)
+    a <=> b
+  end
+
+  def cmp_Timestamp(a, b)
+    raise ArgumentError.new('Timestamps are only comparable to Timestamps, Integers, and Floats') unless b.is_a?(Time::Timestamp) ||  b.is_a?(Integer) || b.is_a?(Float)
+    a <=> b
+  end
+
   def cmp_Version(a, b)
     raise ArgumentError.new('Versions not comparable to non Versions') unless b.is_a?(Semantic::Version)
     a <=> b
   end
 
   def cmp_Object(a, b)
-    raise ArgumentError.new('Only Strings, Numbers, and Versions are comparable')
+    raise ArgumentError.new('Only Strings, Numbers, Timespans, Timestamps, and Versions are comparable')
   end
 
 
@@ -137,6 +147,19 @@ class CompareOperator
     end
   end
 
+  def include_Binary(a, b, scope)
+    case b
+    when Puppet::Pops::Types::PBinaryType::Binary
+      a.binary_buffer.include?(b.binary_buffer)
+    when String
+      a.binary_buffer.include?(b)
+    when Numeric
+      a.binary_buffer.bytes.include?(b)
+    else
+      false
+    end
+  end
+
   def include_Array(a, b, scope)
     case b
     when Regexp

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

@@ -117,6 +117,10 @@ class EvaluatorImpl
       # 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)
@@ -407,7 +411,20 @@ class EvaluatorImpl
       begin
         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})
+          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)
+            # Switch places. Let the TimeData do the arithmetic
+            x = left
+            left = right
+            right = x
+          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})
+          end
         end
         result = left.send(operator, right)
       rescue NoMethodError => e
@@ -618,9 +635,7 @@ class EvaluatorImpl
   # Evaluates all statements and produces the last evaluated value
   #
   def eval_BlockExpression o, scope
-    r = nil
-    o.statements.each {|s| r = evaluate(s, scope)}
-    r
+    o.statements.reduce(nil) {|memo, s| evaluate(s, scope)}
   end
 
   # Performs optimized search over case option values, lazily evaluating each
@@ -693,7 +708,16 @@ class EvaluatorImpl
   end
 
   def eval_Program(o, scope)
-    evaluate(o.body, scope)
+    begin
+      file = o.locator.file
+      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)
+    rescue Puppet::Pops::Evaluator::PuppetStopIteration => ex
+      # breaking out of a file level program is not allowed
+      raise Puppet::ParseError.new("break() from context where this is illegal", ex.file, ex.line)
+    end
   end
 
   # Produces Array[PAnyType], an array of resource references

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

@@ -16,7 +16,7 @@ require 'rgen/ecore/ecore'
 #   * Default is not accepted as being literal
 #   * Regular Expression is not accepted as being literal
 #   * Hash with non String keys
-#   * String with interpolatin
+#   * String with interpolation
 #
 class Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator
   #include Puppet::Pops::Utils

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

@@ -15,7 +15,7 @@ class Runtime3Converter
   # @return [Array] The converted values
   #
   def self.map_args(args, scope, undef_value)
-    @@instance.map_args(args, scope, undef_value)
+    @instance.map_args(args, scope, undef_value)
   end
 
   # Converts 4x supported values to a 3x values. Same as calling Runtime3Converter.instance.convert(...)
@@ -26,13 +26,13 @@ class Runtime3Converter
   # @return [Object] The converted value
   #
   def self.convert(o, scope, undef_value)
-    @@instance.convert(o, scope, undef_value)
+    @instance.convert(o, scope, undef_value)
   end
 
   # Returns the singleton instance of this class.
   # @return [Runtime3Converter] The singleton instance
   def self.instance
-    @@instance
+    @instance
   end
 
   # Converts 4x supported values to a 3x values.
@@ -58,79 +58,41 @@ class Runtime3Converter
   end
 
   def convert_NilClass(o, scope, undef_value)
-    undef_value
-  end
-
-  def convert2_NilClass(o, scope, undef_value)
-    :undef
+    @inner ? :undef : undef_value
   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
   end
-  alias convert2_String :convert_String
 
   def convert_Object(o, scope, undef_value)
     o
   end
-  alias :convert2_Object :convert_Object
 
   def convert_Array(o, scope, undef_value)
-    o.map {|x| convert2(x, scope, undef_value) }
+    ic = @inner_converter
+    o.map {|x| ic.convert(x, scope, undef_value) }
   end
-  alias :convert2_Array :convert_Array
 
   def convert_Hash(o, scope, undef_value)
     result = {}
-    o.each {|k,v| result[convert2(k, scope, undef_value)] = convert2(v, scope, undef_value) }
+    ic = @inner_converter
+    o.each {|k,v| result[ic.convert(k, scope, undef_value)] = ic.convert(v, scope, undef_value) }
     result
   end
-  alias :convert2_Hash :convert_Hash
 
   def convert_Iterator(o, scope, undef_value)
     raise Puppet::Error, 'Use of an Iterator is not supported here'
   end
-  alias :convert2_Iterator :convert_Iterator
-
-  def convert_Regexp(o, scope, undef_value)
-    # Puppet 3x cannot handle parameter values that are reqular expressions. Turn into regexp string in
-    # source form
-    o.inspect
-  end
-  alias :convert2_Regexp :convert_Regexp
-
-  def convert_SemVer(o, scope, undef_value)
-    # Puppet 3x cannot handle SemVers. Use the string form
-    o.to_s
-  end
-  alias :convert2_SemVer :convert_SemVer
-
-  def convert_SemVerRange(o, scope, undef_value)
-    # Puppet 3x cannot handle SemVerRanges. Use the string form
-    o.to_s
-  end
-  alias :convert2_SemVerRange :convert_SemVerRange
 
   def convert_Symbol(o, scope, undef_value)
-    case o
-      # Support :undef since it may come from a 3x structure
-      when :undef
-        undef_value  # 3x wants undef as either empty string or :undef
-      else
-        o   # :default, and all others are verbatim since they are new in future evaluator
-    end
-  end
-
-  # The :undef symbol should not be converted when nested in arrays or hashes
-  def convert2_Symbol(o, scope, undef_value)
-    o
+    o == :undef && !@inner ? undef_value : o
   end
 
   def convert_PAnyType(o, scope, undef_value)
     o
   end
-  alias :convert2_PAnyType :convert_PAnyType
 
   def convert_PCatalogEntryType(o, scope, undef_value)
     # Since 4x does not support dynamic scoping, all names are absolute and can be
@@ -142,7 +104,6 @@ class Runtime3Converter
     t = Runtime3ResourceSupport.find_resource_type(scope, t) unless t == 'class' || t == 'node'
     Puppet::Resource.new(t, title)
   end
-  alias :convert2_PCatalogEntryType :convert_PCatalogEntryType
 
   # Produces an array with [type, title] from a PCatalogEntryType
   # This method is used to produce the arguments for creation of reference resource instances
@@ -170,24 +131,54 @@ class Runtime3Converter
     end
   end
 
-  private
+  protected
 
-  def initialize
-    @convert_visitor  = Puppet::Pops::Visitor.new(self, 'convert', 2, 2)
-    @convert2_visitor = Puppet::Pops::Visitor.new(self, 'convert2', 2, 2)
+  def initialize(inner = false)
+    @inner = inner
+    @inner_converter = inner ? self : self.class.new(true)
+    @convert_visitor = Puppet::Pops::Visitor.new(self, 'convert', 2, 2)
   end
 
-  @@instance = self.new
+  @instance = self.new
+end
 
-  # Converts a nested 4x supported value to a 3x value.
-  #
-  # @param o [Object]The value to convert
-  # @param scope [Puppet::Parser::Scope] The scope to use when converting
-  # @param undef_value [Object] The value that nil is converted to
-  # @return [Object] The converted value
-  #
-  def convert2(o, scope, undef_value)
-    @convert2_visitor.visit_this_2(self, o, scope, undef_value)
+# A Ruby function written for the 3.x API cannot be expected to handle extended data types. This
+# converter ensures that they are converted to String format
+# @api private
+class Runtime3FunctionArgumentConverter < Runtime3Converter
+
+  def convert_Regexp(o, scope, undef_value)
+    # Puppet 3x cannot handle parameter values that are reqular expressions. Turn into regexp string in
+    # source form
+    o.inspect
+  end
+
+  def convert_Version(o, scope, undef_value)
+    # Puppet 3x cannot handle SemVers. Use the string form
+    o.to_s
+  end
+
+  def convert_VersionRange(o, scope, undef_value)
+    # Puppet 3x cannot handle SemVerRanges. Use the string form
+    o.to_s
   end
+
+  def convert_Binary(o, scope, undef_value)
+    # Puppet 3x cannot handle Binary. Use the string form
+    o.to_s
+  end
+
+  def convert_Timespan(o, scope, undef_value)
+    # Puppet 3x cannot handle Timespans. Use the string form
+    o.to_s
+  end
+
+  def convert_Timestamp(o, scope, undef_value)
+    # Puppet 3x cannot handle Timestamps. Use the string form
+    o.to_s
+  end
+
+  @instance = self.new
 end
+
 end

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

@@ -59,11 +59,19 @@ module Runtime3Support
     # The error is not specific enough to allow catching it - need to check the actual message text.
     # 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
+    end
+
     if scope.bound?(name)
       if Puppet::Parser::Scope::RESERVED_VARIABLE_NAMES.include?(name)
         fail(Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
-      elsif name == "server_facts" && Puppet[:trusted_server_facts]
-        fail(Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
       else
         fail(Issues::ILLEGAL_REASSIGNMENT, o, {:name => name} )
       end
@@ -240,7 +248,7 @@ module Runtime3Support
   # @param name [String] the name of the function (without the 'function_' prefix used by scope)
   # @param args [Array] arguments, may be empty
   # @param scope [Object] the (runtime specific) scope where evaluation takes place
-  # @raise ArgumentError 'unknown function' if the function does not exist
+  # @raise [ArgumentError] 'unknown function' if the function does not exist
   #
   def external_call_function(name, args, scope, &block)
     # Call via 4x API if the function exists there
@@ -261,7 +269,7 @@ module Runtime3Support
 
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
     # NOTE: Passing an empty string last converts nil/:undef to empty string
-    mapped_args = Runtime3Converter.map_args(args, scope, '')
+    mapped_args = Runtime3FunctionArgumentConverter.map_args(args, scope, '')
     result = scope.send("function_#{name}", mapped_args, &block)
     # Prevent non r-value functions from leaking their result (they are not written to care about this)
     Puppet::Parser::Functions.rvalue?(name) ? result : nil
@@ -281,7 +289,7 @@ module Runtime3Support
 
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
     # NOTE: Passing an empty string last converts nil/:undef to empty string
-    mapped_args = Runtime3Converter.map_args(args, scope, '')
+    mapped_args = Runtime3FunctionArgumentConverter.map_args(args, scope, '')
     result = Puppet::Pops::PuppetStack.stack(file, line, scope, "function_#{name}", [mapped_args], &block)
     # Prevent non r-value functions from leaking their result (they are not written to care about this)
     Puppet::Parser::Functions.rvalue?(name) ? result : nil
@@ -299,7 +307,8 @@ module Runtime3Support
   end
 
   def convert(value, scope, undef_value)
-    Runtime3Converter.convert(value, scope, undef_value)
+    converter = scope.environment.rich_data? ? Runtime3Converter.instance : Runtime3FunctionArgumentConverter.instance
+    converter.convert(value, scope, undef_value)
   end
 
   def create_resources(o, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)

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

@@ -1,3 +1,5 @@
+module Puppet::Pops
+  module Functions
 # Defines a connection between a implementation method and the signature that
 # the method will handle.
 #
@@ -5,7 +7,7 @@
 # constructed using the DSL defined in {Puppet::Functions}.
 #
 # @api private
-class Puppet::Pops::Functions::Dispatch < Puppet::Pops::Evaluator::CallableSignature
+class Dispatch < Evaluator::CallableSignature
   # @api public
   attr_reader :type
   # TODO: refactor to parameter_names since that makes it API
@@ -42,7 +44,10 @@ class Puppet::Pops::Functions::Dispatch < Puppet::Pops::Evaluator::CallableSigna
 
   # @api private
   def invoke(instance, calling_scope, args, &block)
-    instance.send(@method_name, *weave(calling_scope, args), &block)
+    result = instance.send(@method_name, *weave(calling_scope, args), &block)
+    return_type = @type.return_type
+    Types::TypeAsserter.assert_instance_of(nil, return_type, result) { "value returned from function '#{@method_name}'" } unless return_type.nil?
+    result
   end
 
   # @api private
@@ -83,3 +88,5 @@ class Puppet::Pops::Functions::Dispatch < Puppet::Pops::Evaluator::CallableSigna
     end
   end
 end
+end
+end

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

@@ -32,7 +32,9 @@ class Puppet::Pops::Functions::Dispatcher
     actual = tc.infer_set(block_given? ? args + [block] : args)
     found = @dispatchers.find { |d| tc.callable?(d.type, actual) }
     if found
-      found.invoke(instance, calling_scope, args, &block)
+      catch(:next) do
+        found.invoke(instance, calling_scope, args, &block)
+      end
     else
       raise ArgumentError, Puppet::Pops::Types::TypeMismatchDescriber.describe_signatures(instance.class.name, @dispatchers, actual)
     end

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

@@ -41,7 +41,24 @@ class Puppet::Pops::Functions::Function
   #
   # @api public
   def call(scope, *args, &block)
-    self.class.dispatcher.dispatch(self, scope, args, &block)
+    begin
+      result = catch(:return) do
+        return self.class.dispatcher.dispatch(self, scope, args, &block)
+      end
+      return result.value
+    rescue Puppet::Pops::Evaluator::Next => jumper
+      begin
+        throw :next, jumper.value
+      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION => uncaught
+        raise Puppet::ParseError.new("next() from context where this is illegal", jumper.file, jumper.line)
+      end
+    rescue Puppet::Pops::Evaluator::Return => jumper
+      begin
+        throw :return, jumper
+      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION => uncaught
+        raise Puppet::ParseError.new("return() from context where this is illegal", jumper.file, jumper.line)
+      end
+    end
   end
 
   # Allows the implementation of a function to call other functions by name. The callable functions
@@ -109,7 +126,7 @@ class Puppet::Pops::Functions::Function
     # Call via 3x API
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
     # NOTE: Passing an empty string last converts nil/:undef to empty string
-    result = scope.send(func_3x, Puppet::Pops::Evaluator::Runtime3Converter.map_args(args, loader_scope, ''), &block)
+    result = scope.send(func_3x, Puppet::Pops::Evaluator::Runtime3FunctionArgumentConverter.map_args(args, loader_scope, ''), &block)
 
     # Prevent non r-value functions from leaking their result (they are not written to care about this)
     Puppet::Parser::Functions.rvalue?(function_name) ? result : nil

data/lib/puppet/pops/issues.rb

@@ -255,6 +255,10 @@ module Issues
     "Operator '#{operator}' is not applicable to #{label.a_an(left_value)}."
   end
 
+  OPERATOR_NOT_APPLICABLE_WHEN = hard_issue :OPERATOR_NOT_APPLICABLE_WHEN, :operator, :left_value, :right_value do
+    "Operator '#{operator}' is not applicable to #{label.a_an(left_value)} when right side is #{label.a_an(right_value)}."
+  end
+
   COMPARISON_NOT_POSSIBLE = hard_issue :COMPARISON_NOT_POSSIBLE, :operator, :left_value, :right_value, :detail do
     "Comparison of: #{label(left_value)} #{operator} #{label(right_value)}, is not possible. Caused by '#{detail}'."
   end
@@ -430,6 +434,11 @@ module Issues
     "#{label.a_an_uc(left_value)}[] cannot use #{actual} where #{expected_text} expected"
   end
 
+  BAD_STRING_SLICE_KEY_TYPE = issue :BAD_STRING_SLICE_KEY_TYPE, :left_value, :actual_type do
+    actual_type_text = "#{label.article(actual_type)} #{actual_type}"
+    "A substring operation does not accept #{actual_type_text} as a character index. Expected an Integer"
+  end
+
   BAD_NOT_UNDEF_SLICE_TYPE = issue :BAD_NOT_UNDEF_SLICE_TYPE, :base_type, :actual do
     "#{base_type}[] argument must be a Type or a String. Got #{actual}"
   end