bolt 0.24.0 → 0.25.0

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

@@ -1,61 +0,0 @@
-# Returns the absolute value of a Numeric value, for example -34.56 becomes
-# 34.56. Takes a single `Integer` or `Float` value as an argument.
-#
-# *Deprecated behavior*
-#
-# For backwards compatibility reasons this function also works when given a
-# number in `String` format such that it first attempts to covert it to either a `Float` or
-# an `Integer` and then taking the absolute value of the result. Only strings representing
-# a number in decimal format is supported - an error is raised if
-# value is not decimal (using base 10). Leading 0 chars in the string
-# are ignored. A floating point value in string form can use some forms of
-# scientific notation but not all.
-#
-# Callers should convert strings to `Numeric` before calling
-# this function to have full control over the conversion.
-#
-# @example Converting to Numeric before calling
-# ```puppet
-# abs(Numeric($str_val))
-# ```
-# 
-# It is worth noting that `Numeric` can convert to absolute value
-# directly as in the following examples:
-#
-# @example Absolute value and String to Numeric
-# ```puppet
-# Numeric($strval, true)     # Converts to absolute Integer or Float
-# Integer($strval, 10, true) # Converts to absolute Integer using base 10 (decimal)
-# Integer($strval, 16, true) # Converts to absolute Integer using base 16 (hex)
-# Float($strval, true)       # Converts to absolute Float
-# ```puppet
-#
-Puppet::Functions.create_function(:abs) do
-  dispatch :on_numeric do
-    param 'Numeric', :val
-  end
-
-  dispatch :on_string do
-    param 'String', :val
-  end
-
-  def on_numeric(x)
-    x.abs
-  end
-
-  def on_string(x)
-    Puppet.warn_once('deprecations', 'abs_function_numeric_coerce_string',
-      _("The abs() function's auto conversion of String to Numeric is deprecated - change to convert input before calling"))
-
-    # These patterns for conversion are backwards compatible with the stdlib
-    # version of this function.
-    #
-    if x =~ %r{^-?(?:\d+)(?:\.\d+){1}$}
-      x.to_f.abs
-    elsif x =~ %r{^-?\d+$}
-      x.to_i.abs
-    else
-      raise(ArgumentError, 'abs(): Requires float or integer to work with - was given non decimal string')
-    end
-  end
-end

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

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

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

@@ -1,104 +0,0 @@
-# Runs a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
-# repeatedly using each value in a data structure until the lambda returns a non "truthy" value which
-# makes the function return `false`, or if the end of the iteration is reached, `true` is returned.
-#
-# 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 `all` function
-#
-# `$data.all |$parameter| { <PUPPET CODE BLOCK> }`
-#
-# or
-#
-# `all($data) |$parameter| { <PUPPET CODE BLOCK> }`
-#
-# @example Using the `all` function with an Array and a one-parameter lambda
-#
-# ```puppet
-# # For the array $data, run a lambda that checks that all values are multiples of 10
-# $data = [10, 20, 30]
-# notice $data.all |$item| { $item % 10 == 0 }
-# ```
-#
-# Would notice `true`.
-#
-# 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 `all` function with a `Hash` and a one-parameter lambda
-#
-# ```puppet
-# # For the hash $data, run a lambda using each item as a key-value array
-# $data = { 'a_0'=> 10, 'b_1' => 20 }
-# notice $data.all |$item| { $item[1] % 10 == 0  }
-# ```
-#
-# Would notice `true` if all values in the hash are multiples of 10.
-#
-# When the lambda accepts two arguments, the first argument gets the index in an array
-# or the key from a hash, and the second argument the value.
-#
-#
-# @example Using the `all` function with a hash and a two-parameter lambda
-#
-# ```puppet
-# # Check that all values are a multiple of 10 and keys start with 'abc'
-# $data = {abc_123 => 10, abc_42 => 20, abc_blue => 30}
-# notice $data.all |$key, $value| { $value % 10 == 0  and $key =~ /^abc/ }
-# ```
-#
-# Would notice true.
-#
-# For an general examples that demonstrates iteration, see the Puppet
-# [iteration](https://puppet.com/docs/puppet/latest/lang_iteration.html)
-# documentation.
-#
-# @since 5.2.0
-#
-Puppet::Functions.create_function(:all) do
-  dispatch :all_Hash_2 do
-    param 'Hash[Any, Any]', :hash
-    block_param 'Callable[2,2]', :block
-  end
-
-  dispatch :all_Hash_1 do
-    param 'Hash[Any, Any]', :hash
-    block_param 'Callable[1,1]', :block
-  end
-
-  dispatch :all_Enumerable_2 do
-    param 'Iterable', :enumerable
-    block_param 'Callable[2,2]', :block
-  end
-
-  dispatch :all_Enumerable_1 do
-    param 'Iterable', :enumerable
-    block_param 'Callable[1,1]', :block
-  end
-
-  def all_Hash_1(hash)
-    hash.each_pair.all? { |x| yield(x) }
-  end
-
-  def all_Hash_2(hash)
-    hash.each_pair.all? { |x,y| yield(x,y) }
-  end
-
-  def all_Enumerable_1(enumerable)
-    Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable).all? { |e| yield(e) }
-  end
-
-  def all_Enumerable_2(enumerable)
-    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    if enum.hash_style?
-      enum.all? { |entry| yield(*entry) }
-    else
-      enum.each_with_index { |e, i| return false unless yield(i, e) }
-      true
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-# Handles annotations on objects. The function can be used in four different ways.
-#
-# With two arguments, an `Annotation` type and an object, the function returns the annotation
-# for the object of the given type, or `undef` if no such annotation exists.
-#
-# @example Using `annotate` with two arguments
-#
-# ```puppet
-# $annotation = Mod::NickNameAdapter.annotate(o)
-#
-# $annotation = annotate(Mod::NickNameAdapter.annotate, o)
-# ```
-#
-# With three arguments, an `Annotation` type, an object, and a block, the function returns the
-# annotation for the object of the given type, or annotates it with a new annotation initialized
-# from the hash returned by the given block when no such annotation exists. The block will not
-# be called when an annotation of the given type is already present.
-#
-# @example Using `annotate` with two arguments and a block
-#
-# ```puppet
-# $annotation = Mod::NickNameAdapter.annotate(o) || { { 'nick_name' => 'Buddy' } }
-#
-# $annotation = annotate(Mod::NickNameAdapter.annotate, o) || { { 'nick_name' => 'Buddy' } }
-# ```
-#
-# With three arguments, an `Annotation` type, an object, and an `Hash`, the function will annotate
-# the given object with a new annotation of the given type that is initialized from the given hash.
-# An existing annotation of the given type is discarded.
-#
-# @example Using `annotate` with three arguments where third argument is a Hash
-#
-# ```puppet
-# $annotation = Mod::NickNameAdapter.annotate(o, { 'nick_name' => 'Buddy' })
-#
-# $annotation = annotate(Mod::NickNameAdapter.annotate, o, { 'nick_name' => 'Buddy' })
-# ```
-#
-# With three arguments, an `Annotation` type, an object, and an the string `clear`, the function will
-# clear the annotation of the given type in the given object. The old annotation is returned if
-# it existed.
-#
-# @example Using `annotate` with three arguments where third argument is the string 'clear'
-#
-# ```puppet
-# $annotation = Mod::NickNameAdapter.annotate(o, clear)
-#
-# $annotation = annotate(Mod::NickNameAdapter.annotate, o, clear)
-# ```
-#
-# With three arguments, the type `Pcore`, an object, and a Hash of hashes keyed by `Annotation` types,
-# the function will annotate the given object with all types used as keys in the given hash. Each annotation
-# is initialized with the nested hash for the respective type. The annotated object is returned.
-#
-# @example Add multiple annotations to a new instance of `Mod::Person` using the `Pcore` type.
-#
-# ```puppet
-#   $person = Pcore.annotate(Mod::Person({'name' => 'William'}), {
-#     Mod::NickNameAdapter >= { 'nick_name' => 'Bill' },
-#     Mod::HobbiesAdapter => { 'hobbies' => ['Ham Radio', 'Philatelist'] }
-#   })
-# ```
-#
-# @since 5.0.0
-#
-Puppet::Functions.create_function(:annotate) do
-  dispatch :annotate do
-    param 'Type[Annotation]', :type
-    param 'Any', :value
-    optional_block_param 'Callable[0, 0]', :block
-  end
-
-  dispatch :annotate_new do
-    param 'Type[Annotation]', :type
-    param 'Any', :value
-    param 'Variant[Enum[clear],Hash[Pcore::MemberName,Any]]', :annotation_hash
-  end
-
-  dispatch :annotate_multi do
-    param 'Type[Pcore]', :type
-    param 'Any', :value
-    param 'Hash[Type[Annotation], Hash[Pcore::MemberName,Any]]', :annotations
-  end
-
-  # @param type [Annotation] the annotation type
-  # @param value [Object] the value to annotate
-  # @param block [Proc] optional block to produce the annotation hash
-  #
-  def annotate(type, value, &block)
-    type.implementation_class.annotate(value, &block)
-  end
-
-  # @param type [Annotation] the annotation type
-  # @param value [Object] the value to annotate
-  # @param annotation_hash [Hash{String => Object}] the annotation hash
-  #
-  def annotate_new(type, value, annotation_hash)
-    type.implementation_class.annotate_new(value, annotation_hash)
-  end
-
-  # @param type [Type] the Pcore type
-  # @param value [Object] the value to annotate
-  # @param annotations [Hash{Annotation => Hash{String => Object}}] hash of annotation hashes
-  #
-  def annotate_multi(type, value, annotations)
-    type.implementation_class.annotate(value, annotations)
-  end
-end

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

@@ -1,109 +0,0 @@
-# Runs a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
-# repeatedly using each value in a data structure until the lambda returns a "truthy" value which
-# makes the function return `true`, or if the end of the iteration is reached, false is returned.
-#
-# 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 `any` function
-#
-# `$data.any |$parameter| { <PUPPET CODE BLOCK> }`
-#
-# or
-#
-# `any($data) |$parameter| { <PUPPET CODE BLOCK> }`
-#
-# @example Using the `any` function with an Array and a one-parameter lambda
-#
-# ```puppet
-# # For the array $data, run a lambda that checks if an unknown hash contains those keys
-# $data = ["routers", "servers", "workstations"]
-# $looked_up = lookup('somekey', Hash)
-# notice $data.any |$item| { $looked_up[$item] }
-# ```
-#
-# Would notice `true` if the looked up hash had a value that is neither `false` nor `undef` for at least
-# one of the keys. That is, it is equivalent to the expression
-# `$looked_up[routers] || $looked_up[servers] || $looked_up[workstations]`.
-#
-# 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 `any` function with a `Hash` and a one-parameter lambda
-#
-# ```puppet
-# # For the hash $data, run a lambda using each item as a key-value array.
-# $data = {"rtr" => "Router", "svr" => "Server", "wks" => "Workstation"}
-# $looked_up = lookup('somekey', Hash)
-# notice $data.any |$item| { $looked_up[$item[0]] }
-# ```
-#
-# Would notice `true` if the looked up hash had a value for one of the wanted key that is
-# neither `false` nor `undef`.
-#
-# When the lambda accepts two arguments, the first argument gets the index in an array
-# or the key from a hash, and the second argument the value.
-#
-#
-# @example Using the `any` function with an array and a two-parameter lambda
-#
-# ```puppet
-# # Check if there is an even numbered index that has a non String value
-# $data = [key1, 1, 2, 2]
-# notice $data.any |$index, $value| { $index % 2 == 0 and $value !~ String }
-# ```
-#
-# Would notice true as the index `2` is even and not a `String`
-#
-# For an general examples that demonstrates iteration, see the Puppet
-# [iteration](https://puppet.com/docs/puppet/latest/lang_iteration.html)
-# documentation.
-#
-# @since 5.2.0
-#
-Puppet::Functions.create_function(:any) do
-  dispatch :any_Hash_2 do
-    param 'Hash[Any, Any]', :hash
-    block_param 'Callable[2,2]', :block
-  end
-
-  dispatch :any_Hash_1 do
-    param 'Hash[Any, Any]', :hash
-    block_param 'Callable[1,1]', :block
-  end
-
-  dispatch :any_Enumerable_2 do
-    param 'Iterable', :enumerable
-    block_param 'Callable[2,2]', :block
-  end
-
-  dispatch :any_Enumerable_1 do
-    param 'Iterable', :enumerable
-    block_param 'Callable[1,1]', :block
-  end
-
-  def any_Hash_1(hash)
-    hash.each_pair.any? { |x| yield(x) }
-  end
-
-  def any_Hash_2(hash)
-    hash.each_pair.any? { |x,y| yield(x, y) }
-  end
-
-  def any_Enumerable_1(enumerable)
-    Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable).any? { |e| yield(e) }
-  end
-
-  def any_Enumerable_2(enumerable)
-    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    if enum.hash_style?
-      enum.any? { |entry| yield(*entry) }
-    else
-      enum.each_with_index { |e, i| return true if yield(i, e) }
-      false
-    end
-  end
-end

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

@@ -1,93 +0,0 @@
-# Returns the given value if it is of the given
-# [data type](https://puppet.com/docs/puppet/latest/lang_data.html), or
-# otherwise either raises an error or executes an optional two-parameter
-# [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html).
-#
-# The function takes two mandatory arguments, in this order:
-#
-# 1. The expected data type.
-# 2. A value to compare against the expected data type.
-#
-# @example Using `assert_type`
-#
-# ```puppet
-# $raw_username = 'Amy Berry'
-#
-# # Assert that $raw_username is a non-empty string and assign it to $valid_username.
-# $valid_username = assert_type(String[1], $raw_username)
-#
-# # $valid_username contains "Amy Berry".
-# # If $raw_username was an empty string or a different data type, the Puppet run would
-# # fail with an "Expected type does not match actual" error.
-# ```
-#
-# You can use an optional lambda to provide enhanced feedback. The lambda takes two
-# mandatory parameters, in this order:
-#
-# 1. The expected data type as described in the function's first argument.
-# 2. The actual data type of the value.
-#
-# @example Using `assert_type` with a warning and default value
-#
-# ```puppet
-# $raw_username = 'Amy Berry'
-#
-# # Assert that $raw_username is a non-empty string and assign it to $valid_username.
-# # If it isn't, output a warning describing the problem and use a default value.
-# $valid_username = assert_type(String[1], $raw_username) |$expected, $actual| {
-#   warning( "The username should be \'${expected}\', not \'${actual}\'. Using 'anonymous'." )
-#   'anonymous'
-# }
-#
-# # $valid_username contains "Amy Berry".
-# # If $raw_username was an empty string, the Puppet run would set $valid_username to
-# # "anonymous" and output a warning: "The username should be 'String[1, default]', not
-# # 'String[0, 0]'. Using 'anonymous'."
-# ```
-#
-# For more information about data types, see the
-# [documentation](https://puppet.com/docs/puppet/latest/lang_data.html).
-#
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:assert_type) do
-  dispatch :assert_type do
-    param 'Type', :type
-    param 'Any', :value
-    optional_block_param 'Callable[Type, Type]', :block
-  end
-
-  dispatch :assert_type_s do
-    param 'String', :type_string
-    param 'Any', :value
-    optional_block_param 'Callable[Type, Type]', :block
-  end
-
-  # @param type [Type] the type the value must be an instance of
-  # @param value [Object] the value to assert
-  #
-  def assert_type(type, value)
-    unless Puppet::Pops::Types::TypeCalculator.instance?(type,value)
-      inferred_type = Puppet::Pops::Types::TypeCalculator.infer_set(value)
-      if block_given?
-        # Give the inferred type to allow richer comparison in the given block (if generalized
-        # information is lost).
-        #
-        value = yield(type, inferred_type)
-      else
-        raise Puppet::Pops::Types::TypeAssertionError.new(
-          Puppet::Pops::Types::TypeMismatchDescriber.singleton.describe_mismatch('assert_type():', type, inferred_type),
-          type, inferred_type)
-      end
-    end
-    value
-  end
-
-  # @param type_string [String] the type the value must be an instance of given in String form
-  # @param value [Object] the value to assert
-  #
-  def assert_type_s(type_string, value, &proc)
-    t = Puppet::Pops::Types::TypeParser.singleton.parse(type_string)
-    block_given? ? assert_type(t, value, &proc) : assert_type(t, value)
-  end
-end