bolt 0.20.3 → 0.20.5

data/vendored/puppet/lib/puppet/functions/hiera.rb

@@ -14,7 +14,7 @@ require 'hiera/puppet_function'
 #     * If this argument isn't provided and this function results in a lookup failure, Puppet
 #     fails with a compilation error.
 # 3. The optional name of an arbitrary
-# [hierarchy level](https://docs.puppetlabs.com/hiera/latest/hierarchy.html) to insert at the
+# [hierarchy level](https://puppet.com/docs/hiera/latest/hierarchy.html) to insert at the
 # top of the hierarchy. This lets you temporarily modify the hierarchy for a single lookup.
 #     * If Hiera doesn't find a matching key in the overriding hierarchy level, it continues
 #     searching the rest of the hierarchy.
@@ -56,7 +56,7 @@ require 'hiera/puppet_function'
 # ```
 #
 # You can optionally generate the default value with a
-# [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) that
+# [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) that
 # takes one parameter.
 #
 # @example Using `hiera` with a lambda
@@ -72,13 +72,13 @@ require 'hiera/puppet_function'
 # # "Key 'users' not found".
 # ```
 #
-# The returned value's data type depends on the types of the results. In the example 
+# The returned value's data type depends on the types of the results. In the example
 # above, Hiera matches the 'users' key and returns it as a hash.
 #
 # See
-# [the 'Using the lookup function' documentation](https://docs.puppet.com/puppet/latest/hiera_use_function.html) for how to perform lookup of data.
+# [the 'Using the lookup function' documentation](https://puppet.com/docs/puppet/latest/hiera_automatic.html) for how to perform lookup of data.
 # Also see
-# [the 'Using the deprecated hiera functions' documentation](https://docs.puppet.com/puppet/latest/hiera_use_hiera_functions.html)
+# [the 'Using the deprecated hiera functions' documentation](https://puppet.com/docs/puppet/latest/hiera_automatic.html)
 # for more information about the Hiera 3 functions.
 #
 # @since 4.0.0

data/vendored/puppet/lib/puppet/functions/hiera_array.rb

@@ -3,7 +3,7 @@ require 'hiera/puppet_function'
 # Finds all matches of a key throughout the hierarchy and returns them as a single flattened
 # array of unique values. If any of the matched values are arrays, they're flattened and
 # included in the results. This is called an
-# [array merge lookup](https://docs.puppetlabs.com/hiera/latest/lookup_types.html#array-merge).
+# [array merge lookup](https://puppet.com/docs/hiera/latest/lookup_types.html#array-merge).
 #
 # This function is deprecated in favor of the `lookup` function. While this function
 # continues to work, it does **not** support:
@@ -17,7 +17,7 @@ require 'hiera/puppet_function'
 #     * If this argument isn't provided and this function results in a lookup failure, Puppet
 #     fails with a compilation error.
 # 3. The optional name of an arbitrary
-# [hierarchy level](https://docs.puppetlabs.com/hiera/latest/hierarchy.html) to insert at the
+# [hierarchy level](https://puppet.com/docs/hiera/latest/hierarchy.html) to insert at the
 # top of the hierarchy. This lets you temporarily modify the hierarchy for a single lookup.
 #     * If Hiera doesn't find a matching key in the overriding hierarchy level, it continues
 #     searching the rest of the hierarchy.
@@ -46,7 +46,7 @@ require 'hiera/puppet_function'
 # ```
 #
 # You can optionally generate the default value with a
-# [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) that
+# [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) that
 # takes one parameter.
 #
 # @example Using `hiera_array` with a lambda
@@ -65,9 +65,9 @@ require 'hiera/puppet_function'
 # value is a hash, Puppet raises a type mismatch error.
 #
 # See
-# [the 'Using the lookup function' documentation](https://docs.puppet.com/puppet/latest/hiera_use_function.html) for how to perform lookup of data.
+# [the 'Using the lookup function' documentation](https://puppet.com/docs/puppet/latest/hiera_automatic.html) for how to perform lookup of data.
 # Also see
-# [the 'Using the deprecated hiera functions' documentation](https://docs.puppet.com/puppet/latest/hiera_use_hiera_functions.html)
+# [the 'Using the deprecated hiera functions' documentation](https://puppet.com/docs/puppet/latest/hiera_automatic.html)
 # for more information about the Hiera 3 functions.
 #
 # @since 4.0.0

data/vendored/puppet/lib/puppet/functions/hiera_hash.rb

@@ -9,10 +9,10 @@ require 'hiera/puppet_function'
 #
 # If any of the matched hashes share keys, the final hash uses the value from the
 # highest priority match. This is called a
-# [hash merge lookup](https://docs.puppetlabs.com/hiera/latest/lookup_types.html#hash-merge).
+# [hash merge lookup](https://puppet.com/docs/hiera/latest/lookup_types.html#hash-merge).
 #
 # The merge strategy is determined by Hiera's
-# [`:merge_behavior`](https://docs.puppetlabs.com/hiera/latest/configuring.html#mergebehavior)
+# [`:merge_behavior`](https://puppet.com/docs/hiera/latest/configuring.html#mergebehavior)
 # setting.
 #
 # The `hiera_hash` function takes up to three arguments, in this order:
@@ -22,7 +22,7 @@ require 'hiera/puppet_function'
 #     * If this argument isn't provided and this function results in a lookup failure, Puppet
 #     fails with a compilation error.
 # 3. The optional name of an arbitrary
-# [hierarchy level](https://docs.puppetlabs.com/hiera/latest/hierarchy.html) to insert at the
+# [hierarchy level](https://puppet.com/docs/hiera/latest/hierarchy.html) to insert at the
 # top of the hierarchy. This lets you temporarily modify the hierarchy for a single lookup.
 #     * If Hiera doesn't find a matching key in the overriding hierarchy level, it continues
 #     searching the rest of the hierarchy.
@@ -56,7 +56,7 @@ require 'hiera/puppet_function'
 # ```
 #
 # You can optionally generate the default value with a
-# [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) that
+# [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) that
 # takes one parameter.
 #
 # @example Using `hiera_hash` with a lambda
@@ -76,9 +76,9 @@ require 'hiera/puppet_function'
 # found in the data sources are strings or arrays, Puppet raises a type mismatch error.
 #
 # See
-# [the 'Using the lookup function' documentation](https://docs.puppet.com/puppet/latest/hiera_use_function.html) for how to perform lookup of data.
+# [the 'Using the lookup function' documentation](https://puppet.com/docs/puppet/latest/hiera_automatic.html) for how to perform lookup of data.
 # Also see
-# [the 'Using the deprecated hiera functions' documentation](https://docs.puppet.com/puppet/latest/hiera_use_hiera_functions.html)
+# [the 'Using the deprecated hiera functions' documentation](https://puppet.com/docs/puppet/latest/hiera_automatic.html)
 # for more information about the Hiera 3 functions.
 #
 # @since 4.0.0

data/vendored/puppet/lib/puppet/functions/hiera_include.rb

@@ -1,7 +1,7 @@
 require 'hiera/puppet_function'
 
 # Assigns classes to a node using an
-# [array merge lookup](https://docs.puppetlabs.com/hiera/latest/lookup_types.html#array-merge)
+# [array merge lookup](https://puppet.com/docs/hiera/latest/lookup_types.html#array-merge)
 # that retrieves the value for a user-specified key from Hiera's data.
 #
 # This function is deprecated in favor of the `lookup` function in combination with `include`.
@@ -10,7 +10,7 @@ require 'hiera/puppet_function'
 # * lookup across global, environment, and module layers
 #
 # @example Using `lookup` and `include` instead of of the deprecated `hiera_include`
-# 
+#
 # ```puppet
 # # In site.pp, outside of any node definitions and below any top-scope variables:
 # lookup('classes', Array[String], 'unique').include
@@ -32,13 +32,13 @@ require 'hiera/puppet_function'
 #     * If this argument isn't provided and this function results in a lookup failure, Puppet
 #     fails with a compilation error.
 # 3. The optional name of an arbitrary
-# [hierarchy level](https://docs.puppetlabs.com/hiera/latest/hierarchy.html) to insert at the
+# [hierarchy level](https://puppet.com/docs/hiera/latest/hierarchy.html) to insert at the
 # top of the hierarchy. This lets you temporarily modify the hierarchy for a single lookup.
 #     * If Hiera doesn't find a matching key in the overriding hierarchy level, it continues
 #     searching the rest of the hierarchy.
 #
 # The function uses an
-# [array merge lookup](https://docs.puppetlabs.com/hiera/latest/lookup_types.html#array-merge)
+# [array merge lookup](https://puppet.com/docs/hiera/latest/lookup_types.html#array-merge)
 # to retrieve the `classes` array, so every node gets every class from the hierarchy.
 #
 # @example Using `hiera_include`
@@ -66,7 +66,7 @@ require 'hiera/puppet_function'
 # ```
 #
 # You can optionally generate the default value with a
-# [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) that
+# [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) that
 # takes one parameter.
 #
 # @example Using `hiera_include` with a lambda
@@ -83,9 +83,9 @@ require 'hiera/puppet_function'
 # ```
 #
 # See
-# [the 'Using the lookup function' documentation](https://docs.puppet.com/puppet/latest/hiera_use_function.html) for how to perform lookup of data.
+# [the 'Using the lookup function' documentation](https://puppet.com/docs/puppet/latest/hiera_automatic.html) for how to perform lookup of data.
 # Also see
-# [the 'Using the deprecated hiera functions' documentation](https://docs.puppet.com/puppet/latest/hiera_use_hiera_functions.html)
+# [the 'Using the deprecated hiera functions' documentation](https://puppet.com/docs/puppet/latest/hiera_automatic.html)
 # for more information about the Hiera 3 functions.
 #
 # @since 4.0.0

data/vendored/puppet/lib/puppet/functions/hocon_data.rb

@@ -1,5 +1,5 @@
 # The `hocon_data` is a hiera 5 `data_hash` data provider function.
-# See [the configuration guide documentation](https://docs.puppet.com/puppet/latest/hiera_config_yaml_5.html#configuring-a-hierarchy-level-built-in-backends) for
+# See [the configuration guide documentation](https://puppet.com/docs/puppet/latest/hiera_config_yaml_5.html#configuring-a-hierarchy-level-built-in-backends) for
 # how to use this function.
 #
 # Note that this function is not supported without a hocon library being present.

data/vendored/puppet/lib/puppet/functions/json_data.rb

@@ -1,5 +1,5 @@
 # The `json_data` is a hiera 5 `data_hash` data provider function.
-# See [the configuration guide documentation](https://docs.puppet.com/puppet/latest/hiera_config_yaml_5.html#configuring-a-hierarchy-level-built-in-backends) for
+# See [the configuration guide documentation](https://puppet.com/docs/puppet/latest/hiera_config_yaml_5.html#configuring-a-hierarchy-level-built-in-backends) for
 # how to use this function.
 #
 # @since 4.8.0
@@ -19,8 +19,8 @@ Puppet::Functions.create_function(:json_data) do
     path = options['path']
     context.cached_file_data(path) do |content|
       begin
-        JSON.parse(content)
-      rescue JSON::ParserError => ex
+        Puppet::Util::Json.load(content)
+      rescue Puppet::Util::Json::ParseError => ex
         # Filename not included in message, so we add it here.
         raise Puppet::DataBinding::LookupError, "Unable to parse (%{path}): %{message}" % { path: path, message: ex.message }
       end

data/vendored/puppet/lib/puppet/functions/lest.rb

@@ -1,4 +1,4 @@
-# Calls a [lambda](https://docs.puppet.com/puppet/latest/reference/lang_lambdas.html)
+# Calls a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 # without arguments if the value given to `lest` is `undef`.
 # Returns the result of calling the lambda if the argument is `undef`, otherwise the
 # given argument.

data/vendored/puppet/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) ---
@@ -207,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/vendored/puppet/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/vendored/puppet/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:

data/vendored/puppet/lib/puppet/functions/match.rb

@@ -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/vendored/puppet/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