bolt 0.24.0 → 0.25.0

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

@@ -1,72 +0,0 @@
-# Returns the data type of a given value with a given degree of generality.
-#
-# ```puppet
-# type InferenceFidelity = Enum[generalized, reduced, detailed]
-#
-# function type(Any $value, InferenceFidelity $fidelity = 'detailed') # returns Type
-# ```
-#
-# @example Using `type`
-#
-# ``` puppet
-# notice type(42) =~ Type[Integer]
-# ```
-#
-# Would notice `true`.
-#
-# By default, the best possible inference is made where all details are retained.
-# This is good when the type is used for further type calculations but is overwhelmingly
-# rich in information if it is used in a error message.
-#
-# The optional argument `$fidelity` may be given as (from lowest to highest fidelity):
-#
-# * `generalized` - reduces to common type and drops size constraints
-# * `reduced` - reduces to common type in collections
-# * `detailed` - (default) all details about inferred types is retained
-#
-# @example Using `type()` with different inference fidelity:
-#
-# ``` puppet
-# notice type([3.14, 42], 'generalized')
-# notice type([3.14, 42], 'reduced'')
-# notice type([3.14, 42], 'detailed')
-# notice type([3.14, 42])
-# ```
-#
-# Would notice the four values:
-#
-# 1. 'Array[Numeric]'
-# 2. 'Array[Numeric, 2, 2]'
-# 3. 'Tuple[Float[3.14], Integer[42,42]]]'
-# 4. 'Tuple[Float[3.14], Integer[42,42]]]'
-#
-# @since 4.4.0
-#
-Puppet::Functions.create_function(:type) do
-  dispatch :type_detailed do
-    param 'Any', :value
-    optional_param 'Enum[detailed]', :inference_method
-  end
-
-  dispatch :type_parameterized do
-    param 'Any', :value
-    param 'Enum[reduced]', :inference_method
-  end
-
-  dispatch :type_generalized do
-    param 'Any', :value
-    param 'Enum[generalized]', :inference_method
-  end
-
-  def type_detailed(value, _ = nil)
-    Puppet::Pops::Types::TypeCalculator.infer_set(value)
-  end
-
-  def type_parameterized(value, _)
-    Puppet::Pops::Types::TypeCalculator.infer(value)
-  end
-
-  def type_generalized(value, _)
-    Puppet::Pops::Types::TypeCalculator.infer(value).generalize
-  end
-end

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

@@ -1,132 +0,0 @@
-# Produces a unique set of values from an `Iterable` argument.
-#
-# * If the argument is a `String`, the unique set of characters are returned as a new `String`.
-# * If the argument is a `Hash`, the resulting hash associates a set of keys with a set of unique values.
-# * For all other types of `Iterable` (`Array`, `Iterator`) the result is an `Array` with
-#   a unique set of entries.
-# * Comparison of all `String` values are case sensitive.
-# * An optional code block can be given - if present it is given each candidate value and its return is used instead of the given value. This
-#   enables transformation of the value before comparison. The result of the lambda is only used for comparison.
-# * The optional code block when used with a hash is given each value (not the keys).
-#
-# @example Using unique with a String
-#
-# ```puppet
-# # will produce 'abc'
-# "abcaabb".unique
-# ```
-#
-# @example Using unique with an Array
-#
-# ```puppet
-# # will produce ['a', 'b', 'c']
-# ['a', 'b', 'c', 'a', 'a', 'b'].unique
-# ```
-#
-# @example Using unique with a Hash
-#
-# ```puppet
-# # will produce { ['a', 'b'] => [10], ['c'] => [20]}
-# {'a' => 10, 'b' => 10, 'c' => 20}.unique
-#
-# # will produce { 'a' => 10, 'c' => 20 } (use first key with first value)
-# Hash.new({'a' => 10, 'b' => 10, 'c' => 20}.unique.map |$k, $v| { [ $k[0] , $v[0]] })
-#
-# # will produce { 'b' => 10, 'c' => 20 } (use last key with first value)
-# Hash.new({'a' => 10, 'b' => 10, 'c' => 20}.unique.map |$k, $v| { [ $k[-1] , $v[0]] })
-# ```
-#
-# @example Using unique with an Iterable
-#
-# ```
-# # will produce [3, 2, 1]
-# [1,2,2,3,3].reverse_each.unique
-# ```
-#
-# @example Using unique with a lambda
-#
-# ```puppet
-# # will produce [['sam', 'smith'], ['sue', 'smith']]
-# [['sam', 'smith'], ['sam', 'brown'], ['sue', 'smith']].unique |$x| { $x[0] }
-#
-# # will produce [['sam', 'smith'], ['sam', 'brown']]
-# [['sam', 'smith'], ['sam', 'brown'], ['sue', 'smith']].unique |$x| { $x[1] }
-#
-# # will produce ['aBc', 'bbb'] (using a lambda to make comparison using downcased (%d) strings)
-# ['aBc', 'AbC', 'bbb'].unique |$x| { String($x,'%d') }
-#
-# # will produce {[a] => [10], [b, c, d, e] => [11, 12, 100]}
-# {a => 10, b => 11, c => 12, d => 100, e => 11}.unique |$v| { if $v > 10 { big } else { $v } } 
-# ```
-#
-# Note that for `Hash` the result is slightly different than for the other data types. For those the result contains the
-# *first-found* unique value, but for `Hash` it contains associations from a set of keys to the set of values clustered by the
-# equality lambda (or the default value equality if no lambda was given). This makes the `unique` function more versatile for hashes
-# in general, while requiring that the simple computation of "hash's unique set of values" is performed as `$hsh.map |$k, $v| { $v }.unique`.
-# (A unique set of hash keys is in general meaningless (since they are unique by definition) - although if processed with a different
-# lambda for equality that would be different. First map the hash to an array of its keys if such a unique computation is wanted). 
-# If the more advanced clustering is wanted for one of the other data types, simply transform it into a `Hash` as shown in the
-# following example.
-#
-# @example turning a string or array into a hash with index keys
-#
-# ```puppet
-# # Array ['a', 'b', 'c'] to Hash with index results in
-# # {0 => 'a', 1 => 'b', 2 => 'c'}
-# Hash(['a', 'b', 'c'].map |$i, $v| { [$i, $v]})
-#
-# # String "abc" to Hash with index results in
-# # {0 => 'a', 1 => 'b', 2 => 'c'}
-# Hash(Array("abc").map |$i,$v| { [$i, $v]})
-# "abc".to(Array).map |$i,$v| { [$i, $v]}.to(Hash)
-# ```
-#
-# @since Puppet 5.0.0
-#
-Puppet::Functions.create_function(:unique) do
-  dispatch :unique_string do
-    param 'String', :string
-    optional_block_param 'Callable[String]', :block
-  end
-
-  dispatch :unique_hash do
-    param 'Hash', :hash
-    optional_block_param 'Callable[Any]', :block
-  end
-
-  dispatch :unique_array do
-    param 'Array', :array
-    optional_block_param 'Callable[Any]', :block
-  end
-
-  dispatch :unique_iterable do
-    param 'Iterable', :iterable
-    optional_block_param 'Callable[Any]', :block
-  end
-
-  def unique_string(string, &block)
-    string.split('').uniq(&block).join('')
-  end
-
-  def unique_hash(hash, &block)
-    block = lambda {|v| v } unless block_given?
-    result = Hash.new {|h, k| h[k] = {:keys =>[], :values =>[]} }
-    hash.each_pair do |k,v|
-      rc = result[ block.call(v) ]
-      rc[:keys] << k
-      rc[:values] << v
-    end
-    # reduce the set of possibly duplicated value entries
-    inverted = {}
-    result.each_pair {|k,v| inverted[v[:keys]] = v[:values].uniq }
-    inverted
-  end
-
-  def unique_array(array,&block)
-    array.uniq(&block)
-  end
-
-  def unique_iterable(iterable, &block)
-    Puppet::Pops::Types::Iterable.on(iterable).uniq(&block)
-  end
-end

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

@@ -1,44 +0,0 @@
-# Unwraps a Sensitive value and returns the wrapped object.
-#
-# @example Usage of unwrap
-#
-# ```puppet
-# $plaintext = 'hunter2'
-# $pw = Sensitive.new($plaintext)
-# notice("Wrapped object is $pw") #=> Prints "Wrapped object is Sensitive [value redacted]"
-# $unwrapped = $pw.unwrap
-# notice("Unwrapped object is $unwrapped") #=> Prints "Unwrapped object is hunter2"
-# ```
-#
-# You can optionally pass a block to unwrap in order to limit the scope where the
-# unwrapped value is visible.
-#
-# @example Unwrapping with a block of code
-#
-# ```puppet
-# $pw = Sensitive.new('hunter2')
-# notice("Wrapped object is $pw") #=> Prints "Wrapped object is Sensitive [value redacted]"
-# $pw.unwrap |$unwrapped| {
-#   $conf = inline_template("password: ${unwrapped}\n")
-#   Sensitive.new($conf)
-# } #=> Returns a new Sensitive object containing an interpolated config file
-# # $unwrapped is now out of scope
-# ```
-#
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:unwrap) do
-  dispatch :unwrap do
-    param 'Sensitive', :arg
-    optional_block_param
-  end
-
-  def unwrap(arg)
-    unwrapped = arg.unwrap
-    if block_given?
-      yield(unwrapped)
-    else
-      unwrapped
-    end
-  end
-end

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

@@ -1,89 +0,0 @@
-# Converts a String, Array or Hash (recursively) into upper case.
-#
-# This function is compatible with the stdlib function with the same name.
-#
-# The function does the following:
-# * For a `String`, its upper case version is returned. This is done using Ruby system locale which handles some, but not all
-#   special international up-casing rules (for example German double-s ß is upcased to "SS", whereas upper case double-s
-#   is downcased to ß).
-# * For `Array` and `Hash` the conversion to upper case is recursive and each key and value must be convertible by
-#   this function.
-# * When a `Hash` is converted, some keys could result in the same key - in those cases, the
-#   latest key-value wins. For example if keys "aBC", and "abC" where both present, after upcase there would only be one
-#   key "ABC".
-# * If the value is `Numeric` it is simply returned (this is for backwards compatibility).
-# * An error is raised for all other data types.
-#
-# Please note: This function relies directly on Ruby's String implementation and as such may not be entirely UTF8 compatible.
-# To ensure best compatibility please use this function with Ruby 2.4.0 or greater - https://bugs.ruby-lang.org/issues/10085.
-#
-# @example Converting a String to upper case
-# ```puppet
-# 'hello'.upcase()
-# upcase('hello')
-# ```
-# Would both result in "HELLO"
-#
-# @example Converting an Array to upper case
-# ```puppet
-# ['a', 'b'].upcase()
-# upcase(['a', 'b'])
-# ```
-# Would both result in ['A', 'B']
-#
-# @example Converting a Hash to upper case
-# ```puppet
-# {'a' => 'hello', 'b' => 'goodbye'}.upcase()
-# ```
-# Would result in `{'A' => 'HELLO', 'B' => 'GOODBYE'}`
-#
-# @example Converting a recursive structure
-# ```puppet
-# ['a', 'b', ['c', ['d']], {'x' => 'y'}].upcase
-# ```
-# Would result in `['A', 'B', ['C', ['D']], {'X' => 'Y'}]`
-#
-Puppet::Functions.create_function(:upcase) do
-  local_types do
-    type 'StringData = Variant[String, Numeric, Array[StringData], Hash[StringData, StringData]]'
-  end
-
-  dispatch :on_numeric do
-    param 'Numeric', :arg
-  end
-
-  dispatch :on_string do
-    param 'String', :arg
-  end
-
-  dispatch :on_array do
-    param 'Array[StringData]', :arg
-  end
-
-  dispatch :on_hash do
-    param 'Hash[StringData, StringData]', :arg
-  end
-
-  # unit function - since the old implementation skipped Numeric values
-  def on_numeric(n)
-    n
-  end
-
-  def on_string(s)
-    s.upcase
-  end
-
-  def on_array(a)
-    a.map {|x| do_upcase(x) }
-  end
-
-  def on_hash(h)
-    result = {}
-    h.each_pair {|k,v| result[do_upcase(k)] = do_upcase(v) }
-    result
-  end
-
-  def do_upcase(x)
-    x.is_a?(String) ? x.upcase : call_function('upcase', x)
-  end
-end

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

@@ -1,25 +0,0 @@
-# Returns the values of a hash as an Array
-#
-# @example Using `values`
-#
-# ```puppet
-# $hsh = {"apples" => 3, "oranges" => 4 }
-# $hsh.values()
-# values($hsh)
-# # both results in the array [3, 4]
-# ```
-#
-# * Note that a hash in the puppet language accepts any data value (including `undef`) unless
-#   it is constrained with a `Hash` data type that narrows the allowed data types.
-# * For an empty hash, an empty array is returned.
-# * The order of the values is the same as the order in the hash (typically the order in which they were added).
-#
-Puppet::Functions.create_function(:values) do
-  dispatch :values do
-    param 'Hash', :hsh
-  end
-
-  def values(hsh)
-    hsh.values
-  end
-end

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

@@ -1,36 +0,0 @@
-require 'puppet/util/package'
-
-# Compares two version numbers.
-#
-# Prototype:
-#
-#     \$result = versioncmp(a, b)
-#
-# Where a and b are arbitrary version strings.
-#
-# This function returns:
-#
-# * `1` if version a is greater than version b
-# * `0` if the versions are equal
-# * `-1` if version a is less than version b
-#
-# @example Using versioncmp
-#
-#     if versioncmp('2.6-1', '2.4.5') > 0 {
-#         notice('2.6-1 is > than 2.4.5')
-#     }
-#
-# This function uses the same version comparison algorithm used by Puppet's
-# `package` type.
-#
-Puppet::Functions.create_function(:versioncmp) do
-
-  dispatch :versioncmp do
-    param 'String', :a
-    param 'String', :b
-  end
-
-  def versioncmp(a, b)
-    Puppet::Util::Package.versioncmp(a, b)
-  end
-end

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

@@ -1,14 +0,0 @@
-# Logs a message on the server at level `warning`.
-Puppet::Functions.create_function(:warning, Puppet::Functions::InternalFunction) do
-  # @param values The values to log.
-  # @return [Undef]
-  dispatch :warning do
-    scope_param
-    repeated_param 'Any', :values
-    return_type 'Undef'
-  end
-
-  def warning(scope, *values)
-    Puppet::Util::Log.log_func(scope, :warning, values)
-  end
-end

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

@@ -1,32 +0,0 @@
-# Calls a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
-# with the given arguments and returns the result.
-#
-# Since a lambda's scope is
-# [local](https://puppet.com/docs/puppet/latest/lang_lambdas.html#lambda-scope)
-# to the lambda, you can use the `with` function to create private blocks of code within a
-# class using variables whose values cannot be accessed outside of the lambda.
-#
-# @example Using `with`
-#
-# ```puppet
-# # Concatenate three strings into a single string formatted as a list.
-# $fruit = with("apples", "oranges", "bananas") |$x, $y, $z| {
-#   "${x}, ${y}, and ${z}"
-# }
-# $check_var = $x
-# # $fruit contains "apples, oranges, and bananas"
-# # $check_var is undefined, as the value of $x is local to the lambda.
-# ```
-#
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:with) do
-  dispatch :with do
-    repeated_param 'Any', :arg
-    block_param
-  end
-
-  def with(*args)
-    yield(*args)
-  end
-end