bolt 0.24.0 → 0.25.0

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

@@ -1,24 +0,0 @@
-# Returns an `Integer` value rounded to the nearest value.
-# Takes a single `Numeric` value as an argument.
-#
-# @example 'rounding a value'
-#
-# ```puppet
-# notice(round(2.9)) # would notice 3
-# notice(round(2.1)) # would notice 2
-# notice(round(-2.9)) # would notice -3
-# ```
-#
-Puppet::Functions.create_function(:round) do
-  dispatch :on_numeric do
-    param 'Numeric', :val
-  end
-
-  def on_numeric(x)
-    if x > 0
-      Integer(x + 0.5)
-    else
-      Integer(x - 0.5)
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-# Strips trailing 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 trailing 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 trailing space from a String
-# ```puppet
-# "hello\n\t".lstrip()
-# camelcase("hello\n\t")
-# ```
-# Would both result in `"hello"`
-#
-# @example Removing trailing space from strings in an Array
-# ```puppet
-# ["hello\n\t", "hi\n\t"].lstrip()
-# lstrip(["hello\n\t", "hi\n\t"])
-# ```
-# Would both result in `['hello', 'hi']`
-#
-Puppet::Functions.create_function(:rstrip) 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.rstrip
-  end
-
-  def on_iterable(a)
-    a.map {|x| do_rstrip(x) }
-  end
-
-  def do_rstrip(x)
-    # x can only be a String or Numeric because type constraints have been automatically applied
-    x.is_a?(String) ? x.rstrip : x
-  end
-end

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

@@ -1,44 +0,0 @@
-# Scans a string and returns an array of one or more converted values based on the given format string.
-# See the documentation of Ruby's String#scanf method for details about the supported formats (which
-# are similar but not identical to the formats used in Puppet's `sprintf` function.)
-#
-# This function takes two mandatory arguments: the first is the string to convert, and the second is
-# the format string. The result of the scan is an array, with each successfully scanned and transformed value.
-# The scanning stops if a scan is unsuccessful, and the scanned result up to that point is returned. If there
-# was no successful scan, the result is an empty array.
-#
-#    "42".scanf("%i")
-#
-# You can also optionally pass a lambda to scanf, to do additional validation or processing.
-#
-#
-#     "42".scanf("%i") |$x| {
-#       unless $x[0] =~ Integer {
-#         fail "Expected a well formed integer value, got '$x[0]'"
-#       }
-#       $x[0]
-#     }
-#
-#
-#
-#
-#
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:scanf) do
-  require 'scanf'
-
-  dispatch :scanf do
-    param 'String', :data
-    param 'String', :format
-    optional_block_param
-  end
-
-  def scanf(data, format)
-    result = data.scanf(format)
-    if block_given?
-      result = yield(result)
-    end
-    result
-  end
-end

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

@@ -1,15 +0,0 @@
-# The same as length() - returns the size of an Array, Hash, String, or Binary value.
-#
-# @since 6.0.0 - also supporting Binary
-#
-Puppet::Functions.create_function(:size) do
-  dispatch :generic_size do
-    param 'Variant[Collection, String, Binary]', :arg
-  end
-
-
-  def generic_size(arg)
-    call_function('length', arg)
-  end
-
-end

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

@@ -1,124 +0,0 @@
-# Slices an array or hash into pieces of a given size.
-#
-# This function takes two mandatory arguments: the first should be an array or hash, and the second specifies
-# the number of elements to include in each slice.
-#
-# When the first argument is a hash, each key value pair is counted as one. For example, a slice size of 2 will produce
-# an array of two arrays with key, and value.
-#
-# @example Slicing a Hash
-#
-# ```puppet
-# $a.slice(2) |$entry|          { notice "first ${$entry[0]}, second ${$entry[1]}" }
-# $a.slice(2) |$first, $second| { notice "first ${first}, second ${second}" }
-# ```
-# The function produces a concatenated result of the slices.
-#
-# @example Slicing an Array
-#
-# ```puppet
-# slice([1,2,3,4,5,6], 2) # produces [[1,2], [3,4], [5,6]]
-# slice(Integer[1,6], 2)  # produces [[1,2], [3,4], [5,6]]
-# slice(4,2)              # produces [[0,1], [2,3]]
-# slice('hello',2)        # produces [[h, e], [l, l], [o]]
-# ```
-#
-# @example Passing a lambda to a slice (optional)
-#
-# ```puppet
-#  $a.slice($n) |$x| { ... }
-#  slice($a) |$x| { ... }
-# ```
-#
-# The lambda should have either one parameter (receiving an array with the slice), or the same number
-# of parameters as specified by the slice size (each parameter receiving its part of the slice).
-# If there are fewer remaining elements than the slice size for the last slice, it will contain the remaining
-# elements. If the lambda has multiple parameters, excess parameters are set to undef for an array, or
-# to empty arrays for a hash.
-#
-# @example Getting individual values of a slice
-#
-# ```puppet
-#     $a.slice(2) |$first, $second| { ... }
-# ```
-#
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:slice) do
-  dispatch :slice_Hash do
-    param 'Hash[Any, Any]', :hash
-    param 'Integer[1, default]', :slice_size
-    optional_block_param
-  end
-
-  dispatch :slice_Enumerable do
-    param 'Iterable', :enumerable
-    param 'Integer[1, default]', :slice_size
-    optional_block_param
-  end
-
-  def slice_Hash(hash, slice_size, &pblock)
-    result = slice_Common(hash, slice_size, [], block_given? ? pblock : nil)
-    block_given? ? hash : result
-  end
-
-  def slice_Enumerable(enumerable, slice_size, &pblock)
-    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    result = slice_Common(enum, slice_size, nil, block_given? ? pblock : nil)
-    block_given? ? enumerable : result
-  end
-
-  def slice_Common(o, slice_size, filler, pblock)
-    serving_size = asserted_slice_serving_size(pblock, slice_size)
-
-    enumerator = o.each_slice(slice_size)
-    result = []
-    if serving_size == 1
-      begin
-        if pblock
-          loop do
-            pblock.call(enumerator.next)
-          end
-        else
-          loop do
-            result << enumerator.next
-          end
-        end
-      rescue StopIteration
-      end
-    else
-      begin
-        loop do
-          a = enumerator.next
-          if a.size < serving_size
-            a = a.dup.fill(filler, a.length...serving_size)
-          end
-          pblock.call(*a)
-        end
-      rescue StopIteration
-      end
-    end
-    if pblock
-      o
-    else
-      result
-    end
-  end
-
-  def asserted_slice_serving_size(pblock, slice_size)
-    if pblock
-      arity = pblock.arity
-      serving_size = arity < 0 ? slice_size : arity
-    else
-      serving_size = 1
-    end
-    if serving_size == 0
-      raise ArgumentError, _("slice(): block must define at least one parameter. Block has 0.")
-    end
-    unless serving_size == 1 || serving_size == slice_size
-      raise ArgumentError, _("slice(): block must define one parameter, or the same number of parameters as the given size of the slice (%{slice_size}). Block has %{serving_size}; %{parameter_names}") %
-          { slice_size: slice_size, serving_size: serving_size, parameter_names: pblock.parameter_names.join(', ') }
-    end
-    serving_size
-  end
-end

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

@@ -1,74 +0,0 @@
-# Sorts an Array numerically or lexicographically or the characters of a String lexicographically.
-# Please note: This function is based on Ruby String comparison and as such may not be entirely UTF8 compatible.
-# To ensure compatibility please use this function with Ruby 2.4.0 or greater - https://bugs.ruby-lang.org/issues/10085.
-#
-# This function is compatible with the function sort() in stdlib.
-# * Comparison of characters in a string always uses a system locale and may not be what is expected for a particular locale
-# * Sorting is based on Ruby's <=> operator unless a lambda is given that performs the comparison.
-#   * comparison of strings is case dependent (use lambda with `compare($a,$b)` to ignore case)
-#   * comparison of mixed data types raises an error (if there is the need to sort mixed data types use a lambda)
-#
-# Also see the `compare()` function for information about comparable data types in general.
-#
-# @example Sorting a String
-#
-# ```puppet
-# notice(sort("xadb")) # notices 'abdx'
-# ```
-#
-# @example Sorting an Array
-#
-# ```puppet
-# notice(sort([3,6,2])) # notices [2, 3, 6]
-# ```
-#
-# @example Sorting with a lambda
-#
-# ```puppet
-# notice(sort([3,6,2]) |$a,$b| { compare($a, $b) }) # notices [2, 3, 6]
-# notice(sort([3,6,2]) |$a,$b| { compare($b, $a) }) # notices [6, 3, 2]
-# ```
-#
-# @example Case independent sorting with a lambda
-#
-# ```puppet
-# notice(sort(['A','b','C']))                                    # notices ['A', 'C', 'b']
-# notice(sort(['A','b','C']) |$a,$b| { compare($a, $b) })        # notices ['A', 'b', 'C']
-# notice(sort(['A','b','C']) |$a,$b| { compare($a, $b, true) })  # notices ['A', 'b', 'C']
-# notice(sort(['A','b','C']) |$a,$b| { compare($a, $b, false) }) # notices ['A','C', 'b']
-# ```
-#
-# @example Sorting Array with Numeric and String so that numbers are before strings
-#
-# ```puppet
-# notice(sort(['b', 3, 'a', 2]) |$a, $b| {
-#   case [$a, $b] {
-#     [String, Numeric] : { 1 }
-#     [Numeric, String] : { -1 }
-#     default:            { compare($a, $b) }
-#   }
-# })
-# ```
-# Would notice [2,3,'a','b']
-#
-# @since 6.0.0 - supporting a lambda to do compare
-#
-Puppet::Functions.create_function(:sort) do
-  dispatch :sort_string do
-    param 'String', :string_value
-    optional_block_param 'Callable[2,2]', :block
-  end
-
-  dispatch :sort_array do
-    param 'Array', :array_value
-    optional_block_param 'Callable[2,2]', :block
-  end
-
-  def sort_string(s, &block)
-    sort_array(s.split(''), &block).join('')
-  end
-
-  def sort_array(a, &block)
-    a.sort(&block)
-  end
-end

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

@@ -1,49 +0,0 @@
-# Splits a string into an array using a given pattern.
-# The pattern can be a string, regexp or regexp type.
-#
-# @example Splitting a String value
-#
-# ```puppet
-# $string     = 'v1.v2:v3.v4'
-# $array_var1 = split($string, /:/)
-# $array_var2 = split($string, '[.]')
-# $array_var3 = split($string, Regexp['[.:]'])
-#
-# #`$array_var1` now holds the result `['v1.v2', 'v3.v4']`,
-# # while `$array_var2` holds `['v1', 'v2:v3', 'v4']`, and
-# # `$array_var3` holds `['v1', 'v2', 'v3', 'v4']`.
-# ```
-#
-# Note that in the second example, we split on a literal string that contains
-# a regexp meta-character (`.`), which must be escaped.  A simple
-# way to do that for a single character is to enclose it in square
-# brackets; a backslash will also escape a single character.
-#
-Puppet::Functions.create_function(:split) do
-  dispatch :split_String do
-    param 'String', :str
-    param 'String', :pattern
-  end
-
-  dispatch :split_Regexp do
-    param 'String', :str
-    param 'Regexp', :pattern
-  end
-
-  dispatch :split_RegexpType do
-    param 'String', :str
-    param 'Type[Regexp]', :pattern
-  end
-
-  def split_String(str, pattern)
-    str.split(Regexp.compile(pattern))
-  end
-
-  def split_Regexp(str, pattern)
-    str.split(pattern)
-  end
-
-  def split_RegexpType(str, pattern)
-    str.split(pattern.regexp)
-  end
-end

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

@@ -1,98 +0,0 @@
-# Provides stepping with given interval over elements in an iterable and optionally runs a
-# [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) for each
-# element.
-#
-# This function takes two to three arguments:
-#
-# 1. An 'Iterable' that the function will iterate over.
-# 2. An `Integer` step factor. This must be a positive integer.
-# 3. An optional lambda, which the function calls for each element in the interval. It must
-#    request one parameter.
-#
-# @example Using the `step` function
-#
-# ```puppet
-# $data.step(<n>) |$parameter| { <PUPPET CODE BLOCK> }
-# ```
-#
-# or
-#
-# ```puppet
-# $stepped_data = $data.step(<n>)
-# ```
-#
-# or
-#
-# ```puppet
-# step($data, <n>) |$parameter| { <PUPPET CODE BLOCK> }
-# ```
-#
-# or
-#
-# ```puppet
-# $stepped_data = step($data, <n>)
-# ```
-#
-# When no block is given, Puppet returns an `Iterable` that yields the first element and every nth successor
-# element, from its first argument. This allows functions on iterables to be chained.
-# When a block is given, Puppet iterates and calls the block with the first element and then with
-# every nth successor element. It then returns `undef`.
-#
-# @example Using the `step` function with an array, a step factor, and a one-parameter block
-#
-# ```puppet
-# # For the array $data, call a block with the first element and then with each 3rd successor element
-# $data = [1,2,3,4,5,6,7,8]
-# $data.step(3) |$item| {
-#  notice($item)
-# }
-# # Puppet notices the values '1', '4', '7'.
-# ```
-
-# When no block is given, Puppet returns a new `Iterable` which allows it to be directly chained into
-# another function that takes an `Iterable` as an argument.
-#
-# @example Using the `step` function chained with a `map` function.
-#
-# ```puppet
-# # For the array $data, return an array, set to the first element and each 5th successor element, in reverse
-# # order multiplied by 10
-# $data = Integer[0,20]
-# $transformed_data = $data.step(5).map |$item| { $item * 10 }
-# $transformed_data contains [0,50,100,150,200]
-# ```
-#
-# @example The same example using `step` function chained with a `map` in alternative syntax
-#
-# ```puppet
-# # For the array $data, return an array, set to the first and each 5th
-# # successor, in reverse order, multiplied by 10
-# $data = Integer[0,20]
-# $transformed_data = map(step($data, 5)) |$item| { $item * 10 }
-# $transformed_data contains [0,50,100,150,200]
-# ```
-#
-# @since 4.4.0
-#
-Puppet::Functions.create_function(:step) do
-  dispatch :step do
-    param 'Iterable', :iterable
-    param 'Integer[1]', :step
-  end
-
-  dispatch :step_block do
-    param 'Iterable', :iterable
-    param 'Integer[1]', :step
-    block_param 'Callable[1,1]', :block
-  end
-
-  def step(iterable, step)
-    # produces an Iterable
-    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).step(step)
-  end
-
-  def step_block(iterable, step, &block)
-    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).step(step, &block)
-    nil
-  end
-end