bolt 0.24.0 → 0.25.0

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

@@ -1,58 +0,0 @@
-# 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,136 +0,0 @@
-# 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:
-#
-# 1. An array, hash, or other iterable object that the function will iterate over.
-# 2. A lambda, which the function calls for each element in the first argument. It can
-# request one or two parameters.
-#
-# @example Using the `map` function
-#
-# `$transformed_data = $data.map |$parameter| { <PUPPET CODE BLOCK> }`
-#
-# or
-#
-# `$transformed_data = map($data) |$parameter| { <PUPPET CODE BLOCK> }`
-#
-# When the first argument (`$data` in the above example) is an array, Puppet passes each
-# value in turn to the lambda.
-#
-# @example Using the `map` function with an array and a one-parameter lambda
-#
-# ```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
-# # 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
-# parameter.
-#
-# @example Using the `map` function with an array and a two-parameter lambda
-#
-# ```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
-# # 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
-#
-Puppet::Functions.create_function(:map) do
-  dispatch :map_Hash_2 do
-    param 'Hash[Any, Any]', :hash
-    block_param 'Callable[2,2]', :block
-  end
-
-  dispatch :map_Hash_1 do
-    param 'Hash[Any, Any]', :hash
-    block_param 'Callable[1,1]', :block
-  end
-
-  dispatch :map_Enumerable_2 do
-    param 'Iterable', :enumerable
-    block_param 'Callable[2,2]', :block
-  end
-
-  dispatch :map_Enumerable_1 do
-    param 'Iterable', :enumerable
-    block_param 'Callable[1,1]', :block
-  end
-
-  def map_Hash_1(hash)
-    result = []
-    begin
-      hash.map {|x, y| result << yield([x, y]) }
-    rescue StopIteration
-    end
-    result
-  end
-
-  def map_Hash_2(hash)
-    result = []
-    begin
-      hash.map {|x, y| result << yield(x, y) }
-    rescue StopIteration
-    end
-    result
-  end
-
-  def map_Enumerable_1(enumerable)
-    result = []
-    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    begin
-      loop { result << yield(enum.next) }
-    rescue StopIteration
-    end
-    result
-  end
-
-  def map_Enumerable_2(enumerable)
-    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    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
-
-      result
-    end
-  end
-end

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

@@ -1,131 +0,0 @@
-# Matches a regular expression against a string and returns an array containing the match
-# and any matched capturing groups.
-#
-# The first argument is a string or array of strings. The second argument is either a
-# regular expression, regular expression represented as a string, or Regex or Pattern
-# data type that the function matches against the first argument.
-#
-# The returned array contains the entire match at index 0, and each captured group at
-# subsequent index values. If the value or expression being matched is an array, the
-# function returns an array with mapped match results.
-#
-# If the function doesn't find a match, it returns 'undef'.
-#
-# @example Matching a regular expression in a string
-#
-# ```puppet
-# $matches = "abc123".match(/[a-z]+[1-9]+/)
-# # $matches contains [abc123]
-# ```
-#
-# @example Matching a regular expressions with grouping captures in a string
-#
-# ```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
-#
-# ```puppet
-# $matches = ["abc123","def456"].match(/([a-z]+)([1-9]+)/)
-# # $matches contains [[abc123, abc, 123], [def456, def, 456]]
-# ```
-#
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:match) do
-  dispatch :match do
-    param 'String', :string
-    param 'Variant[Any, Type]', :pattern
-  end
-
-  dispatch :enumerable_match do
-    param 'Array[String]', :string
-    param 'Variant[Any, Type]', :pattern
-  end
-
-  def initialize(closure_scope, loader)
-    super
-
-    # Make this visitor shared among all instantiations of this function since it is faster.
-    # This can be used because it is not possible to replace
-    # a puppet runtime (where this function is) without a reboot. If you model a function in a module after
-    # this class, use a regular instance variable instead to enable reloading of the module without reboot
-    #
-    @@match_visitor   ||= Puppet::Pops::Visitor.new(self, "match", 1, 1)
-  end
-
-  # Matches given string against given pattern and returns an Array with matches.
-  # @param string [String] the string to match
-  # @param pattern [String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::PRegexpType, Array] the pattern
-  # @return [Array<String>] matches where first match is the entire match, and index 1-n are captures from left to right
-  #
-  def match(string, pattern)
-    @@match_visitor.visit_this_1(self, pattern, string)
-  end
-
-  # Matches given Array[String] against given pattern and returns an Array with mapped match results.
-  #
-  # @param array [Array<String>] the array of strings to match
-  # @param pattern [String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::PRegexpType, Array] the pattern
-  # @return [Array<Array<String, nil>>] Array with matches (see {#match}), non matching entries produce a nil entry
-  #
-  def enumerable_match(array, pattern)
-    array.map {|s| match(s, pattern) }
-  end
-
-  protected
-
-  def match_Object(obj, s)
-    msg = _("match() expects pattern of T, where T is String, Regexp, Regexp[r], Pattern[p], or Array[T]. Got %{klass}") % { klass: obj.class }
-    raise ArgumentError, msg
-  end
-
-  def match_String(pattern_string, s)
-    do_match(s, Regexp.new(pattern_string))
-  end
-
-  def match_Regexp(regexp, s)
-    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)
-  end
-
-  def match_PPatternType(pattern_t, s)
-    # Since we want the actual match result (not just a boolean), an iteration over
-    # Pattern's regular expressions is needed. (They are of PRegexpType)
-    result = nil
-    pattern_t.patterns.find {|pattern| result = match(s, pattern) }
-    result
-  end
-
-  # Returns the first matching entry
-  def match_Array(array, s)
-    result = nil
-    array.flatten.find {|entry| result = match(s, entry) }
-    result
-  end
-
-  private
-
-  def do_match(s, regexp)
-    if result = regexp.match(s)
-      result.to_a
-    end
-  end
-end

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

@@ -1,183 +0,0 @@
-# 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