puppet 5.0.0 → 6.0.0

data/lib/puppet/functions/lookup.rb

@@ -29,7 +29,7 @@
 #     first key, it will try again with the subsequent ones, only resorting to a
 #     default value if none of them succeed.
 # 2. `<VALUE TYPE>` (data type) --- A
-# [data type](https://docs.puppetlabs.com/puppet/latest/reference/lang_data_type.html)
+# [data type](https://puppet.com/docs/puppet/latest/lang_data_type.html)
 # that must match the retrieved value; if not, the lookup (and catalog
 # compilation) will fail. Defaults to `Data` (accepts any normal value).
 # 3. `<MERGE BEHAVIOR>` (string or hash; see **"Merge Behaviors"** below) ---
@@ -91,12 +91,13 @@
 # merged hash. If the same key exists in multiple source hashes, Puppet will
 # recursively merge hash or array values (with duplicate values removed from
 # arrays). For conflicting scalar values, the highest-priority value will win.
-# * `{'strategy' => 'first|unique|hash'}` --- Same as the string versions of these
-# merge behaviors.
+# * `{'strategy' => 'first'}`, `{'strategy' => 'unique'}`,
+# or `{'strategy' => 'hash'}` --- Same as the string versions of these merge behaviors.
 # * `{'strategy' => 'deep', <DEEP OPTION> => <VALUE>, ...}` --- Same as `'deep'`,
 # but can adjust the merge with additional options. The available options are:
 #     * `'knockout_prefix'` (string or undef) --- A string prefix to indicate a
-#     value should be _removed_ from the final result. Defaults to `undef`, which
+#     value should be _removed_ from the final result. If a value is exactly equal
+#     to the prefix, it will knockout the entire element. Defaults to `undef`, which
 #     disables this feature.
 #     * `'sort_merged_arrays'` (boolean) --- Whether to sort all arrays that are
 #     merged together. Defaults to `false`.
@@ -206,7 +207,8 @@ Puppet::Functions.create_function(:lookup, Puppet::Functions::InternalFunction)
   end
 
   def do_lookup(scope, name, value_type, default_value, has_default, override, default_values_hash, merge, &block)
-    Puppet::Pops::Lookup.lookup(name, value_type, default_value, has_default, merge, Puppet::Pops::Lookup::Invocation.new(scope, override, default_values_hash), &block)
+    Puppet::Pops::Lookup.lookup(name, value_type, default_value, has_default, merge,
+      Puppet::Pops::Lookup::Invocation.new(scope, override, default_values_hash), &block)
   end
 
   def hash_args(options_hash)

data/lib/puppet/functions/lstrip.rb

@@ -0,0 +1,58 @@
+# Strips leading spaces from a String
+#
+# This function is compatible with the stdlib function with the same name.
+#
+# The function does the following:
+# * For a `String` the conversion removes all leading ASCII white space characters such as space, tab, newline, and return.
+#   It does not remove other space-like characters like hard space (Unicode U+00A0). (Tip, `/^[[:space:]]/` regular expression
+#   matches all space-like characters).
+# * For an `Iterable[Variant[String, Numeric]]` (for example an `Array`) each value is processed and the conversion is not recursive.
+# * If the value is `Numeric` it is simply returned (this is for backwards compatibility).
+# * An error is raised for all other data types.
+#
+# @example Removing leading space from a String
+# ```puppet
+# "\n\thello".lstrip()
+# camelcase("\n\thello")
+# ```
+# Would both result in `"hello"`
+#
+# @example Removing leading space from strings in an Array
+# ```puppet
+# ["\n\thello", "\n\thi"].lstrip()
+# lstrip(["\n\thello", "\n\thi"])
+# ```
+# Would both result in `['hello', 'hi']`
+#
+Puppet::Functions.create_function(:lstrip) do
+
+  dispatch :on_numeric do
+    param 'Numeric', :arg
+  end
+
+  dispatch :on_string do
+    param 'String', :arg
+  end
+
+  dispatch :on_iterable do
+    param 'Iterable[Variant[String, Numeric]]', :arg
+  end
+
+  # unit function - since the old implementation skipped Numeric values
+  def on_numeric(n)
+    n
+  end
+
+  def on_string(s)
+    s.lstrip
+  end
+
+  def on_iterable(a)
+    a.map {|x| do_lstrip(x) }
+  end
+
+  def do_lstrip(x)
+    # x can only be a String or Numeric because type constraints have been automatically applied
+    x.is_a?(String) ? x.lstrip : x
+  end
+end

data/lib/puppet/functions/map.rb

@@ -1,4 +1,4 @@
-# Applies a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+# Applies a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 # to every value in a data structure and returns an array containing the results.
 #
 # This function takes two mandatory arguments, in this order:
@@ -20,24 +20,24 @@
 #
 # @example Using the `map` function with an array and a one-parameter lambda
 #
-# ~~~ puppet
+# ```puppet
 # # For the array $data, return an array containing each value multiplied by 10
 # $data = [1,2,3]
 # $transformed_data = $data.map |$items| { $items * 10 }
 # # $transformed_data contains [10,20,30]
-# ~~~
+# ```
 #
 # When the first argument is a hash, Puppet passes each key and value pair to the lambda
 # as an array in the form `[key, value]`.
 #
 # @example Using the `map` function with a hash and a one-parameter lambda
 #
-# ~~~ puppet
+# ```puppet
 # # For the hash $data, return an array containing the keys
 # $data = {'a'=>1,'b'=>2,'c'=>3}
 # $transformed_data = $data.map |$items| { $items[0] }
 # # $transformed_data contains ['a','b','c']
-# ~~~
+# ```
 #
 # When the first argument is an array and the lambda has two parameters, Puppet passes the
 # array's indexes (enumerated from 0) in the first parameter and its values in the second
@@ -45,24 +45,24 @@
 #
 # @example Using the `map` function with an array and a two-parameter lambda
 #
-# ~~~ puppet
+# ```puppet
 # # For the array $data, return an array containing the indexes
 # $data = [1,2,3]
 # $transformed_data = $data.map |$index,$value| { $index }
 # # $transformed_data contains [0,1,2]
-# ~~~
+# ```
 #
 # When the first argument is a hash, Puppet passes its keys to the first parameter and its
 # values to the second parameter.
 #
 # @example Using the `map` function with a hash and a two-parameter lambda
 #
-# ~~~ puppet
+# ```puppet
 # # For the hash $data, return an array containing each value
 # $data = {'a'=>1,'b'=>2,'c'=>3}
 # $transformed_data = $data.map |$key,$value| { $value }
 # # $transformed_data contains [1,2,3]
-# ~~~
+# ```
 #
 # @since 4.0.0
 #
@@ -88,16 +88,25 @@ Puppet::Functions.create_function(:map) do
   end
 
   def map_Hash_1(hash)
-    hash.map {|x, y| yield([x, y]) }
+    result = []
+    begin
+      hash.map {|x, y| result << yield([x, y]) }
+    rescue StopIteration
+    end
+    result
   end
 
   def map_Hash_2(hash)
-    hash.map {|x, y| yield(x, y) }
+    result = []
+    begin
+      hash.map {|x, y| result << yield(x, y) }
+    rescue StopIteration
+    end
+    result
   end
 
   def map_Enumerable_1(enumerable)
     result = []
-    index = 0
     enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
     begin
       loop { result << yield(enum.next) }
@@ -107,16 +116,21 @@ Puppet::Functions.create_function(:map) do
   end
 
   def map_Enumerable_2(enumerable)
-    result = []
-    index = 0
     enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    begin
-      loop do
-        result << yield(index, enum.next)
-        index = index +1
+    if enum.hash_style?
+      enum.map { |entry| yield(*entry) }
+    else
+      result = []
+      begin
+        index = 0
+        loop do
+          result << yield(index, enum.next)
+          index = index + 1
+        end
+      rescue StopIteration
       end
-    rescue StopIteration
+
+      result
     end
-    result
   end
 end

data/lib/puppet/functions/match.rb

@@ -13,24 +13,24 @@
 #
 # @example Matching a regular expression in a string
 #
-# ~~~ ruby
+# ```puppet
 # $matches = "abc123".match(/[a-z]+[1-9]+/)
 # # $matches contains [abc123]
-# ~~~
+# ```
 #
 # @example Matching a regular expressions with grouping captures in a string
 #
-# ~~~ ruby
+# ```puppet
 # $matches = "abc123".match(/([a-z]+)([1-9]+)/)
 # # $matches contains [abc123, abc, 123]
-# ~~~
+# ```
 #
 # @example Matching a regular expression with grouping captures in an array of strings
 #
-# ~~~ ruby
+# ```puppet
 # $matches = ["abc123","def456"].match(/([a-z]+)([1-9]+)/)
 # # $matches contains [[abc123, abc, 123], [def456, def, 456]]
-# ~~~
+# ```
 #
 # @since 4.0.0
 #
@@ -90,6 +90,17 @@ Puppet::Functions.create_function(:match) do
     do_match(s, regexp)
   end
 
+  def match_PTypeAliasType(alias_t, s)
+    match(s, alias_t.resolved_type)
+  end
+
+  def match_PVariantType(var_t, s)
+    # Find first matching type (or error out if one of the variants is not acceptable)
+    result = nil
+    var_t.types.find {|t| result = match(s, t) }
+    result
+  end
+
   def match_PRegexpType(regexp_t, s)
     raise ArgumentError, _("Given Regexp Type has no regular expression") unless regexp_t.pattern
     do_match(s, regexp_t.regexp)

data/lib/puppet/functions/max.rb

@@ -0,0 +1,183 @@
+# Returns the highest value among a variable number of arguments.
+# Takes at least one argument.
+#
+# This function is (with one exception) compatible with the stdlib function
+# with the same name and performs deprecated type conversion before
+# comparison as follows:
+#
+# * If a value converted to String is an optionally '-' prefixed,
+#   string of digits, one optional decimal point, followed by optional
+#   decimal digits - then the comparison is performed on the values
+#   converted to floating point.
+# * If a value is not considered convertible to float, it is converted
+#   to a `String` and the comparison is a lexical compare where min is
+#   the lexicographical later value.
+# * A lexicographical compare is performed in a system locale - international
+#   characters may therefore not appear in what a user thinks is the correct order.
+# * The conversion rules apply to values in pairs - the rule must hold for both
+#   values - a value may therefore be compared using different rules depending
+#   on the "other value".
+# * The returned result found to be the "highest" is the original unconverted value.
+#
+# The above rules have been deprecated in Puppet 6.0.0 as they produce strange results when
+# given values of mixed data types. In general, either convert values to be
+# all `String` or all `Numeric` values before calling the function, or call the
+# function with a lambda that performs type conversion and comparison. This because one
+# simply cannot compare `Boolean` with `Regexp` and with any arbitrary `Array`, `Hash` or
+# `Object` and getting a meaningful result.
+#
+# The one change in the function's behavior is when the function is given a single
+# array argument. The stdlib implementation would return that array as the result where
+# it now instead returns the max value from that array.
+#
+# @example 'max of values - stdlib compatible'
+#
+# ```puppet
+# notice(max(1)) # would notice 1
+# notice(max(1,2)) # would notice 2
+# notice(max("1", 2)) # would notice 2
+# notice(max("0777", 512)) # would notice "0777", since "0777" is not converted from octal form
+# notice(max(0777, 512)) # would notice 512, since 0777 is decimal 511
+# notice(max('aa', 'ab')) # would notice 'ab'
+# notice(max(['a'], ['b'])) # would notice ['b'], since "['b']" is after "['a']"
+# ```
+#
+# @example find 'max' value in an array - stdlib compatible
+#
+# ```puppet
+# $x = [1,2,3,4]
+# notice(max(*$x)) # would notice 4
+# ```
+#
+# @example find 'max' value in an array directly - since Puppet 6.0.0
+#
+# ```puppet
+# $x = [1,2,3,4]
+# notice(max($x)) # would notice 4
+# notice($x.max) # would notice 4
+# ```
+# This example shows that a single array argument is used as the set of values
+# as opposed to being a single returned value.
+#
+# When calling with a lambda, it must accept two variables and it must return
+# one of -1, 0, or 1 depending on if first argument is before/lower than, equal to,
+# or higher/after the second argument.
+#
+# @example 'max of values using a lambda - since Puppet 6.0.0'
+#
+# ```puppet
+# notice(max("2", "10", "100") |$a, $b| { compare($a, $b) })
+# ```
+#
+# Would notice "2" as higher since it is lexicographically higher/after the other values. Without the
+# lambda the stdlib compatible (deprecated) behavior would have been to return "100" since number conversion
+# kicks in.
+#
+Puppet::Functions.create_function(:max) do
+  dispatch :on_numeric do
+    repeated_param 'Numeric', :values
+  end
+
+  dispatch :on_string do
+    repeated_param 'String', :values
+  end
+
+  dispatch :on_single_numeric_array do
+    param 'Array[Numeric]', :values
+    optional_block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :on_single_string_array do
+    param 'Array[String]', :values
+    optional_block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :on_single_any_array do
+    param 'Array', :values
+    optional_block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :on_any_with_block do
+    repeated_param 'Any', :values
+    block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :on_any do
+    repeated_param 'Any', :values
+  end
+
+
+  # All are Numeric - ok now, will be ok later
+  def on_numeric(*args)
+    assert_arg_count(args)
+    args.max
+  end
+
+  # All are String, may convert to numeric (which is deprecated)
+  def on_string(*args)
+    assert_arg_count(args)
+
+    args.max do|a,b|
+      if a.to_s =~ %r{\A^-?\d+([._eE]\d+)?\z} && b.to_s =~ %r{\A-?\d+([._eE]\d+)?\z}
+        Puppet.warn_once('deprecations', 'max_function_numeric_coerce_string',
+          _("The max() function's auto conversion of String to Numeric is deprecated - change to convert input before calling, or use lambda"))
+        a.to_f <=> b.to_f
+      else
+        # case sensitive as in the stdlib function
+        a <=> b
+      end
+    end
+  end
+
+  def on_any_with_block(*args, &block)
+    args.max {|x,y| block.call(x,y) }
+  end
+
+  def on_single_numeric_array(array, &block)
+    if block_given?
+      on_any_with_block(*array, &block)
+    else
+      on_numeric(*array)
+    end
+  end
+
+  def on_single_string_array(array, &block)
+    if block_given?
+      on_any_with_block(*array, &block)
+    else
+      on_string(*array)
+    end
+  end
+
+  def on_single_any_array(array, &block)
+    if block_given?
+      on_any_with_block(*array, &block)
+    else
+      on_any(*array)
+    end
+  end
+
+  # Mix of data types - while only some compares are actually bad it will deprecate
+  # the entire call
+  #
+  def on_any(*args)
+    assert_arg_count(args)
+    args.max do |a, b|
+      as = a.to_s
+      bs = b.to_s
+      if as =~ %r{\A^-?\d+([._eE]\d+)?\z} && bs =~ %r{\A-?\d+([._eE]\d+)?\z}
+        Puppet.warn_once('deprecations', 'max_function_numeric_coerce_string',
+          _("The max() function's auto conversion of String to Numeric is deprecated - change to convert input before calling, or use lambda"))
+        a.to_f <=> b.to_f
+      else
+        Puppet.warn_once('deprecations', 'max_function_string_coerce_any',
+          _("The max() function's auto conversion of Any to String is deprecated - change to convert input before calling, or use lambda"))
+        as <=> bs
+      end
+    end
+  end
+
+  def assert_arg_count(args)
+    raise(ArgumentError, 'max(): Wrong number of arguments need at least one') if args.empty?
+  end
+end

data/lib/puppet/functions/min.rb

@@ -0,0 +1,182 @@
+# Returns the lowest value among a variable number of arguments.
+# Takes at least one argument.
+#
+# This function is (with one exception) compatible with the stdlib function
+# with the same name and performs deprecated type conversion before
+# comparison as follows:
+#
+# * If a value converted to String is an optionally '-' prefixed,
+#   string of digits, one optional decimal point, followed by optional
+#   decimal digits - then the comparison is performed on the values
+#   converted to floating point.
+# * If a value is not considered convertible to float, it is converted
+#   to a `String` and the comparison is a lexical compare where min is
+#   the lexicographical earlier value.
+# * A lexicographical compare is performed in a system locale - international
+#   characters may therefore not appear in what a user thinks is the correct order.
+# * The conversion rules apply to values in pairs - the rule must hold for both
+#   values - a value may therefore be compared using different rules depending
+#   on the "other value".
+# * The returned result found to be the "lowest" is the original unconverted value.
+#
+# The above rules have been deprecated in Puppet 6.0.0 as they produce strange results when
+# given values of mixed data types. In general, either convert values to be
+# all `String` or all `Numeric` values before calling the function, or call the
+# function with a lambda that performs type conversion and comparison. This because one
+# simply cannot compare `Boolean` with `Regexp` and with any arbitrary `Array`, `Hash` or
+# `Object` and getting a meaningful result.
+#
+# The one change in the function's behavior is when the function is given a single
+# array argument. The stdlib implementation would return that array as the result where
+# it now instead returns the max value from that array.
+#
+# @example 'min of values - stdlib compatible'
+#
+# ```puppet
+# notice(min(1)) # would notice 1
+# notice(min(1,2)) # would notice 1
+# notice(min("1", 2)) # would notice 1
+# notice(min("0777", 512)) # would notice 512, since "0777" is not converted from octal form
+# notice(min(0777, 512)) # would notice 511, since 0777 is decimal 511
+# notice(min('aa', 'ab')) # would notice 'aa'
+# notice(min(['a'], ['b'])) # would notice ['a'], since "['a']" is before "['b']"
+# ```
+#
+# @example find 'min' value in an array
+#
+# ```puppet
+# $x = [1,2,3,4]
+# notice(min(*$x)) # would notice 1
+# ```
+#
+# @example find 'min' value in an array directly - since Puppet 6.0.0
+#
+# ```puppet
+# $x = [1,2,3,4]
+# notice(min($x)) # would notice 1
+# notice($x.min) # would notice 1
+# ```
+# This example shows that a single array argument is used as the set of values
+# as opposed to being a single returned value.
+#
+# When calling with a lambda, it must accept two variables and it must return
+# one of -1, 0, or 1 depending on if first argument is before/lower than, equal to,
+# or higher/after the second argument.
+#
+# @example 'min of values using a lambda'
+#
+# ```puppet
+# notice(min("2", "10", "100") |$a, $b| { compare($a, $b) })
+# ```
+#
+# Would notice "10" as lower since it is lexicographically lower/before the other values. Without the
+# lambda the stdlib compatible (deprecated) behavior would have been to return "2" since number conversion kicks in.
+#
+Puppet::Functions.create_function(:min) do
+  dispatch :on_numeric do
+    repeated_param 'Numeric', :values
+  end
+
+  dispatch :on_string do
+    repeated_param 'String', :values
+  end
+
+  dispatch :on_single_numeric_array do
+    param 'Array[Numeric]', :values
+    optional_block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :on_single_string_array do
+    param 'Array[String]', :values
+    optional_block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :on_single_any_array do
+    param 'Array', :values
+    optional_block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :on_any_with_block do
+    repeated_param 'Any', :values
+    block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :on_any do
+    repeated_param 'Any', :values
+  end
+
+
+  # All are Numeric - ok now, will be ok later
+  def on_numeric(*args)
+    assert_arg_count(args)
+    args.min
+  end
+
+  # All are String, may convert to numeric (which is deprecated)
+  def on_string(*args)
+    assert_arg_count(args)
+
+    args.min do|a,b|
+      if a.to_s =~ %r{\A^-?\d+([._eE]\d+)?\z} && b.to_s =~ %r{\A-?\d+([._eE]\d+)?\z}
+        Puppet.warn_once('deprecations', 'min_function_numeric_coerce_string',
+          _("The min() function's auto conversion of String to Numeric is deprecated - change to convert input before calling, or use lambda"))
+        a.to_f <=> b.to_f
+      else
+        # case sensitive as in the stdlib function
+        a <=> b
+      end
+    end
+  end
+
+  def on_any_with_block(*args, &block)
+    args.min {|x,y| block.call(x,y) }
+  end
+
+  def on_single_numeric_array(array, &block)
+    if block_given?
+      on_any_with_block(*array, &block)
+    else
+      on_numeric(*array)
+    end
+  end
+
+  def on_single_string_array(array, &block)
+    if block_given?
+      on_any_with_block(*array, &block)
+    else
+      on_string(*array)
+    end
+  end
+
+  def on_single_any_array(array, &block)
+    if block_given?
+      on_any_with_block(*array, &block)
+    else
+      on_any(*array)
+    end
+  end
+
+  # Mix of data types - while only some compares are actually bad it will deprecate
+  # the entire call
+  #
+  def on_any(*args)
+    assert_arg_count(args)
+    args.min do |a, b|
+      as = a.to_s
+      bs = b.to_s
+      if as =~ %r{\A^-?\d+([._eE]\d+)?\z} && bs =~ %r{\A-?\d+([._eE]\d+)?\z}
+        Puppet.warn_once('deprecations', 'min_function_numeric_coerce_string',
+          _("The min() function's auto conversion of String to Numeric is deprecated - change to convert input before calling, or use lambda"))
+        a.to_f <=> b.to_f
+      else
+        Puppet.warn_once('deprecations', 'min_function_string_coerce_any',
+          _("The min() function's auto conversion of Any to String is deprecated - change to convert input before calling, or use lambda"))
+        as <=> bs
+      end
+    end
+  end
+
+  def assert_arg_count(args)
+    raise(ArgumentError, 'min(): Wrong number of arguments need at least one') if args.empty?
+  end
+end

data/lib/puppet/functions/module_directory.rb

@@ -0,0 +1,41 @@
+# Finds an existing module and returns the path to its root directory.
+#
+# The argument to this function should be a module name String
+# For example, the reference `mysql` will search for the
+# directory `<MODULES DIRECTORY>/mysql` and return the first
+# found on the modulepath.
+#
+# This function can also accept:
+#
+# * Multiple String arguments, which will return the path of the **first** module
+#  found, skipping non existing modules.
+# * An array of module names, which will return the path of the **first** module
+#  found from the given names in the array, skipping non existing modules.
+#
+# The function returns `undef` if none of the given modules were found
+#
+# @since 5.4.0
+#
+Puppet::Functions.create_function(:module_directory, Puppet::Functions::InternalFunction) do
+  dispatch :module_directory do
+    scope_param
+    repeated_param 'String', :names
+  end
+
+  dispatch :module_directory_array do
+    scope_param
+    repeated_param 'Array[String]', :names
+  end
+
+  def module_directory_array(scope, names)
+    module_directory(scope, *names)
+  end
+
+  def module_directory(scope, *names)
+    names.each do |module_name|
+      found = scope.compiler.environment.module(module_name)
+      return found.path if found
+    end
+    nil
+  end
+end