bolt 0.24.0 → 0.25.0

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

@@ -1,89 +0,0 @@
-# Converts a String, Array or Hash (recursively) into lower case.
-#
-# This function is compatible with the stdlib function with the same name.
-#
-# The function does the following:
-# * For a `String`, its lower 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 lower 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 downcase 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 lower case
-# ```puppet
-# 'HELLO'.downcase()
-# downcase('HEllO')
-# ```
-# Would both result in "hello"
-#
-# @example Converting an Array to lower case
-# ```puppet
-# ['A', 'B'].downcase()
-# downcase(['A', 'B'])
-# ```
-# Would both result in ['a', 'b']
-#
-# @example Converting a Hash to lower case
-# ```puppet
-# {'A' => 'HEllO', 'B' => 'GOODBYE'}.downcase()
-# ```
-# Would result in `{'a' => 'hello', 'b' => 'goodbye'}`
-#
-# @example Converting a recursive structure
-# ```puppet
-# ['A', 'B', ['C', ['D']], {'X' => 'Y'}].downcase
-# ```
-# Would result in `['a', 'b', ['c', ['d']], {'x' => 'y'}]`
-#
-Puppet::Functions.create_function(:downcase) 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.downcase
-  end
-
-  def on_array(a)
-    a.map {|x| do_downcase(x) }
-  end
-
-  def on_hash(h)
-    result = {}
-    h.each_pair {|k,v| result[do_downcase(k)] = do_downcase(v) }
-    result
-  end
-
-  def do_downcase(x)
-    x.is_a?(String) ? x.downcase : call_function('downcase', x)
-  end
-end

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

@@ -1,169 +0,0 @@
-# Runs a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
-# repeatedly using each value in a data structure, then returns the values unchanged.
-#
-# 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 `each` function
-#
-# `$data.each |$parameter| { <PUPPET CODE BLOCK> }`
-#
-# or
-#
-# `each($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, then returns the original values.
-#
-# @example Using the `each` function with an array and a one-parameter lambda
-#
-# ```puppet
-# # For the array $data, run a lambda that creates a resource for each item.
-# $data = ["routers", "servers", "workstations"]
-# $data.each |$item| {
-#  notify { $item:
-#    message => $item
-#  }
-# }
-# # Puppet creates one resource for each of the three items in $data. Each resource is
-# # named after the item's value and uses the item's value in a parameter.
-# ```
-#
-# 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]` and returns the original hash.
-#
-# @example Using the `each` 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 that creates a
-# # resource for each item.
-# $data = {"rtr" => "Router", "svr" => "Server", "wks" => "Workstation"}
-# $data.each |$items| {
-#  notify { $items[0]:
-#    message => $items[1]
-#  }
-# }
-# # Puppet creates one resource for each of the three items in $data, each named after the
-# # item's key and containing a parameter using the item's value.
-# ```
-#
-# 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 `each` function with an array and a two-parameter lambda
-#
-# ```puppet
-# # For the array $data, run a lambda using each item's index and value that creates a
-# # resource for each item.
-# $data = ["routers", "servers", "workstations"]
-# $data.each |$index, $value| {
-#  notify { $value:
-#    message => $index
-#  }
-# }
-# # Puppet creates one resource for each of the three items in $data, each named after the
-# # item's value and containing a parameter using the item's index.
-# ```
-#
-# 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 `each` function with a hash and a two-parameter lambda
-#
-# ```puppet
-# # For the hash $data, run a lambda using each item's key and value to create a resource
-# # for each item.
-# $data = {"rtr" => "Router", "svr" => "Server", "wks" => "Workstation"}
-# $data.each |$key, $value| {
-#  notify { $key:
-#    message => $value
-#  }
-# }
-# # Puppet creates one resource for each of the three items in $data, each named after the
-# # item's key and containing a parameter using the item's value.
-# ```
-#
-# For an example that demonstrates how to create multiple `file` resources using `each`,
-# see the Puppet
-# [iteration](https://puppet.com/docs/puppet/latest/lang_iteration.html)
-# documentation.
-#
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:each) do
-  dispatch :foreach_Hash_2 do
-    param 'Hash[Any, Any]', :hash
-    block_param 'Callable[2,2]', :block
-  end
-
-  dispatch :foreach_Hash_1 do
-    param 'Hash[Any, Any]', :hash
-    block_param 'Callable[1,1]', :block
-  end
-
-  dispatch :foreach_Enumerable_2 do
-    param 'Iterable', :enumerable
-    block_param 'Callable[2,2]', :block
-  end
-
-  dispatch :foreach_Enumerable_1 do
-    param 'Iterable', :enumerable
-    block_param 'Callable[1,1]', :block
-  end
-
-  def foreach_Hash_1(hash)
-    enumerator = hash.each_pair
-    begin
-      hash.size.times do
-        yield(enumerator.next)
-      end
-    rescue StopIteration
-    end
-    # produces the receiver
-    hash
-  end
-
-  def foreach_Hash_2(hash)
-    enumerator = hash.each_pair
-    begin
-      hash.size.times do
-        yield(*enumerator.next)
-      end
-    rescue StopIteration
-    end
-    # produces the receiver
-    hash
-  end
-
-  def foreach_Enumerable_1(enumerable)
-    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-      begin
-        loop { yield(enum.next) }
-      rescue StopIteration
-      end
-    # produces the receiver
-    enumerable
-  end
-
-  def foreach_Enumerable_2(enumerable)
-    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    if enum.hash_style?
-      enum.each { |entry| yield(*entry) }
-    else
-      begin
-        index = 0
-        loop do
-          yield(index, enum.next)
-          index += 1
-        end
-      rescue StopIteration
-      end
-    end
-    # produces the receiver
-    enumerable
-  end
-end

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

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

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

@@ -1,77 +0,0 @@
-# Returns `true` if the given argument is an empty collection of values.
-#
-# This function can answer if one of the following is empty:
-# * `Array`, `Hash` - having zero entries
-# * `String`, `Binary` - having zero length
-#
-# For backwards compatibility with the stdlib function with the same name the
-# following data types are also accepted by the function instead of raising an error.
-# Using these is deprecated and will raise a warning:
-#
-# * `Numeric` - `false` is returned for all `Numeric` values.
-# * `Undef` - `true` is returned for all `Undef` values.
-#
-# @example Using `empty`
-#
-# ```puppet
-# notice([].empty)
-# notice(empty([]))
-# # would both notice 'true'
-# ```
-#
-# @since Puppet 5.5.0 - support for Binary
-#
-Puppet::Functions.create_function(:empty) do
-  dispatch :collection_empty do
-    param 'Collection', :coll
-  end
-
-  dispatch :string_empty do
-    param 'String', :str
-  end
-
-  dispatch :numeric_empty do
-    param 'Numeric', :num
-  end
-
-  dispatch :binary_empty do
-    param 'Binary', :bin
-  end
-
-  dispatch :undef_empty do
-    param 'Undef', :x
-  end
-
-  def collection_empty(coll)
-    coll.empty?
-  end
-
-  def string_empty(str)
-    str.empty?
-  end
-
-  # For compatibility reasons - return false rather than error on floats and integers
-  # (Yes, it is strange)
-  #
-  def numeric_empty(num)
-    deprecation_warning_for('Numeric')
-    false
-  end
-
-  def binary_empty(bin)
-    bin.length == 0
-  end
-
-  # For compatibility reasons - return true rather than error on undef
-  # (Yes, it is strange, but undef was passed as empty string in 3.x API)
-  #
-  def undef_empty(x)
-    true
-  end
-
-  def deprecation_warning_for(arg_type)
-    file, line = Puppet::Pops::PuppetStack.top_of_stack
-    msg = _("Calling function empty() with %{arg_type} value is deprecated.") % { arg_type: arg_type }
-    Puppet.warn_once('deprecations', "empty-from-#{file}-#{line}", msg, file, line)
-  end
-end

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

@@ -1,48 +0,0 @@
-# Evaluates an Embedded Puppet (EPP) template file and returns the rendered text
-# result as a String.
-#
-# `epp('<MODULE NAME>/<TEMPLATE FILE>', <PARAMETER HASH>)`
-#
-# The first argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
-# reference, which loads `<TEMPLATE FILE>` from `<MODULE NAME>`'s `templates`
-# directory. In most cases, the last argument is optional; if used, it should be a
-# [hash](/puppet/latest/reference/lang_data_hash.html) that contains parameters to
-# pass to the template.
-#
-# - See the [template](/puppet/latest/reference/lang_template.html) documentation
-# for general template usage information.
-# - See the [EPP syntax](/puppet/latest/reference/lang_template_epp.html)
-# documentation for examples of EPP.
-#
-# For example, to call the apache module's `templates/vhost/_docroot.epp`
-# template and pass the `docroot` and `virtual_docroot` parameters, call the `epp`
-# function like this:
-#
-# `epp('apache/vhost/_docroot.epp', { 'docroot' => '/var/www/html',
-# 'virtual_docroot' => '/var/www/example' })`
-#
-# This function can also accept an absolute path, which can load a template file
-# from anywhere on disk.
-#
-# Puppet produces a syntax error if you pass more parameters than are declared in
-# the template's parameter tag. When passing parameters to a template that
-# contains a parameter tag, use the same names as the tag's declared parameters.
-#
-# Parameters are required only if they are declared in the called template's
-# parameter tag without default values. Puppet produces an error if the `epp`
-# function fails to pass any required parameter.
-#
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:epp, Puppet::Functions::InternalFunction) do
-
-  dispatch :epp do
-    scope_param
-    param 'String', :path
-    optional_param 'Hash[Pattern[/^\w+$/], Any]', :parameters
-  end
-
-  def epp(scope, path, parameters = nil)
-    Puppet::Pops::Evaluator::EppEvaluator.epp(scope, path, scope.compiler.environment, parameters)
-  end
-end

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

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

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

@@ -1,97 +0,0 @@
-# The `eyaml_lookup_key` is a hiera 5 `lookup_key` data provider function.
-# See [the configuration guide documentation](https://puppet.com/docs/puppet/latest/hiera_config_yaml_5.html#configuring-a-hierarchy-level-hiera-eyaml) for
-# how to use this function.
-#
-# @since 5.0.0
-#
-Puppet::Functions.create_function(:eyaml_lookup_key) do
-  unless Puppet.features.hiera_eyaml?
-    raise Puppet::DataBinding::LookupError, 'Lookup using eyaml lookup_key function is only supported when the hiera_eyaml library is present'
-  end
-
-  require 'hiera/backend/eyaml/encryptor'
-  require 'hiera/backend/eyaml/utils'
-  require 'hiera/backend/eyaml/options'
-  require 'hiera/backend/eyaml/parser/parser'
-
-  dispatch :eyaml_lookup_key do
-    param 'String[1]', :key
-    param 'Hash[String[1],Any]', :options
-    param 'Puppet::LookupContext', :context
-  end
-
-  def eyaml_lookup_key(key, options, context)
-    return context.cached_value(key) if context.cache_has_key(key)
-
-    # Can't do this with an argument_mismatch dispatcher since there is no way to declare a struct that at least
-    # contains some keys but may contain other arbitrary keys.
-    unless options.include?('path')
-      #TRANSLATORS 'eyaml_lookup_key':, 'path', 'paths' 'glob', 'globs', 'mapped_paths', and lookup_key should not be translated
-      raise ArgumentError,
-        _("'eyaml_lookup_key': one of 'path', 'paths' 'glob', 'globs' or 'mapped_paths' must be declared in hiera.yaml"\
-              " when using this lookup_key function")
-    end
-
-    # nil key is used to indicate that the cache contains the raw content of the eyaml file
-    raw_data = context.cached_value(nil)
-    if raw_data.nil?
-      raw_data = load_data_hash(options, context)
-      context.cache(nil, raw_data)
-    end
-    context.not_found unless raw_data.include?(key)
-    context.cache(key, decrypt_value(raw_data[key], context, options))
-  end
-
-  def load_data_hash(options, context)
-    path = options['path']
-    context.cached_file_data(path) do |content|
-      begin
-        data = Puppet::Util::Yaml.safe_load(content, [Symbol], path)
-        if data.is_a?(Hash)
-          Puppet::Pops::Lookup::HieraConfig.symkeys_to_string(data)
-        else
-          msg = _("%{path}: file does not contain a valid yaml hash") % { path: path }
-          raise Puppet::DataBinding::LookupError, msg if Puppet[:strict] == :error && data != false
-          Puppet.warning(msg)
-          {}
-        end
-      rescue Puppet::Util::Yaml::YamlLoadError => ex
-        # YamlLoadErrors include the absolute path to the file, so no need to add that
-        raise Puppet::DataBinding::LookupError, _("Unable to parse %{message}") % { message: ex.message }
-      end
-    end
-  end
-
-  def decrypt_value(value, context, options)
-    case value
-    when String
-      decrypt(value, context, options)
-    when Hash
-      result = {}
-      value.each_pair { |k, v| result[context.interpolate(k)] = decrypt_value(v, context, options) }
-      result
-    when Array
-      value.map { |v| decrypt_value(v, context, options) }
-    else
-      value
-    end
-  end
-
-  def decrypt(data, context, options)
-    if encrypted?(data)
-      # Options must be set prior to each call to #parse since they end up as static variables in
-      # the Options class. They cannot be set once before #decrypt_value is called, since each #decrypt
-      # might cause a new lookup through interpolation. That lookup in turn, might use a different eyaml
-      # config.
-      #
-      Hiera::Backend::Eyaml::Options.set(options)
-      tokens = Hiera::Backend::Eyaml::Parser::ParserFactory.hiera_backend_parser.parse(data)
-      data = tokens.map(&:to_plain_text).join.chomp
-    end
-    context.interpolate(data)
-  end
-
-  def encrypted?(data)
-    /.*ENC\[.*?\]/ =~ data ? true : false
-  end
-end