bolt 0.19.1 → 0.20.0

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,79 +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)
-    deprecation_warning_for('Undef')
-    true
-  end
-
-  def deprecation_warning_for(arg_type)
-    stacktrace = Puppet::Pops::PuppetStack.stacktrace()
-    file, line = stacktrace[0] # defaults to nil
-    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,96 +0,0 @@
-# The `eyaml_lookup_key` is a hiera 5 `lookup_key` data provider function.
-# See [the configuration guide documentation](https://docs.puppet.com/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 = YAML.load(content, path)
-        if data.is_a?(Hash)
-          Puppet::Pops::Lookup::HieraConfig.symkeys_to_string(data)
-        else
-          Puppet.warning(_("%{path}: file does not contain a valid yaml hash") % { path: path })
-          {}
-        end
-      rescue YAML::SyntaxError => ex
-        # Psych errors includes the absolute path to the file, so no need to add that
-        # to the message
-        raise Puppet::DataBinding::LookupError, "Unable to parse #{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

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

@@ -1,143 +0,0 @@
-# Applies a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
-# to every value in a data structure and returns an array or hash containing any elements
-# for which the lambda evaluates to `true`.
-#
-# 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 `filter` function
-#
-# `$filtered_data = $data.filter |$parameter| { <PUPPET CODE BLOCK> }`
-#
-# or
-#
-# `$filtered_data = filter($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 and returns an array containing the results.
-#
-# @example Using the `filter` function with an array and a one-parameter lambda
-#
-# ```puppet
-# # For the array $data, return an array containing the values that end with "berry"
-# $data = ["orange", "blueberry", "raspberry"]
-# $filtered_data = $data.filter |$items| { $items =~ /berry$/ }
-# # $filtered_data = [blueberry, raspberry]
-# ```
-#
-# 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 a hash containing the results.
-#
-# @example Using the `filter` function with a hash and a one-parameter lambda
-#
-# ```puppet
-# # For the hash $data, return a hash containing all values of keys that end with "berry"
-# $data = { "orange" => 0, "blueberry" => 1, "raspberry" => 2 }
-# $filtered_data = $data.filter |$items| { $items[0] =~ /berry$/ }
-# # $filtered_data = {blueberry => 1, raspberry => 2}
-#
-# 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 `filter` function with an array and a two-parameter lambda
-#
-# ```puppet
-# # For the array $data, return an array of all keys that both end with "berry" and have
-# # an even-numbered index
-# $data = ["orange", "blueberry", "raspberry"]
-# $filtered_data = $data.filter |$indexes, $values| { $indexes % 2 == 0 and $values =~ /berry$/ }
-# # $filtered_data = [raspberry]
-# ```
-#
-# 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 `filter` function with a hash and a two-parameter lambda
-#
-# ```puppet
-# # For the hash $data, return a hash of all keys that both end with "berry" and have 
-# # values less than or equal to 1
-# $data = { "orange" => 0, "blueberry" => 1, "raspberry" => 2 }
-# $filtered_data = $data.filter |$keys, $values| { $keys =~ /berry$/ and $values <= 1 }
-# # $filtered_data = {blueberry => 1}
-# ```
-#
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:filter) do
-  dispatch :filter_Hash_2 do
-    param 'Hash[Any, Any]', :hash
-    block_param 'Callable[2,2]', :block
-  end
-
-  dispatch :filter_Hash_1 do
-    param 'Hash[Any, Any]', :hash
-    block_param 'Callable[1,1]', :block
-  end
-
-  dispatch :filter_Enumerable_2 do
-    param 'Iterable', :enumerable
-    block_param 'Callable[2,2]', :block
-  end
-
-  dispatch :filter_Enumerable_1 do
-    param 'Iterable', :enumerable
-    block_param 'Callable[1,1]', :block
-  end
-
-  def filter_Hash_1(hash)
-    result = hash.select {|x, y| yield([x, y]) == true }
-    # Ruby 1.8.7 returns Array
-    result = Hash[result] unless result.is_a? Hash
-    result
-  end
-
-  def filter_Hash_2(hash)
-    result = hash.select {|x, y| yield(x, y) == true }
-    # Ruby 1.8.7 returns Array
-    result = Hash[result] unless result.is_a? Hash
-    result
-  end
-
-  def filter_Enumerable_1(enumerable)
-    result = []
-    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    begin
-      loop do
-        it = enum.next
-        if yield(it) == true
-          result << it
-        end
-      end
-    rescue StopIteration
-    end
-    result
-  end
-
-  def filter_Enumerable_2(enumerable)
-    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    if enum.hash_style?
-      result = {}
-      enum.each { |k, v| result[k] = v if yield(k, v) == true }
-      result
-    else
-      result = []
-      begin
-        index = 0
-        loop do
-          it = enum.next
-          if yield(index, it) == true
-            result << it
-          end
-          index += 1
-        end
-      rescue StopIteration
-      end
-      result
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-# Finds an existing file from a module and returns its path.
-#
-# The argument to this function should be a String as a `<MODULE NAME>/<FILE>`
-# reference, which will search for `<FILE>` relative to a module's `files`
-# directory. (For example, the reference `mysql/mysqltuner.pl` will search for the
-# file `<MODULES DIRECTORY>/mysql/files/mysqltuner.pl`.)
-#
-# This function can also accept:
-# 
-# * An absolute String path, which will check for the existence of a file from anywhere on disk.
-# * Multiple String arguments, which will return the path of the **first** file
-#   found, skipping non existing files.
-# * An array of string paths, which will return the path of the **first** file
-#   found from the given paths in the array, skipping non existing files.
-#
-# The function returns `undef` if none of the given paths were found
-#
-# @since 4.8.0
-#
-Puppet::Functions.create_function(:find_file, Puppet::Functions::InternalFunction) do
-  dispatch :find_file do
-    scope_param
-    repeated_param 'String', :paths
-  end
-
-  dispatch :find_file_array do
-    scope_param
-    repeated_param 'Array[String]', :paths_array
-  end
-
-  def find_file_array(scope, array)
-    find_file(scope, *array)
-  end
-
-  def find_file(scope, *args)
-    args.each do |file|
-      found = Puppet::Parser::Files.find_file(file, scope.compiler.environment)
-      if found && Puppet::FileSystem.exist?(found)
-        return found
-      end
-    end
-    nil
-  end
-end

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

@@ -1,64 +0,0 @@
-# Returns a flat Array produced from its possibly deeply nested given arguments.
-#
-# One or more arguments of any data type can be given to this function.
-# The result is always a flat array representation where any nested arrays are recursively flattened.
-#
-# @example Typical use of `flatten()`
-#
-# ```puppet
-# flatten(['a', ['b', ['c']]])
-# # Would return: ['a','b','c']
-# ```
-#
-# To flatten other kinds of iterables (for example hashes, or intermediate results like from a `reverse_each`)
-# first convert the result to an array using `Array($x)`, or `$x.convert_to(Array)`. See the `new` function
-# for details and options when performing a conversion.
-#
-# @example Flattening a Hash
-#
-# ```puppet
-# $hsh = { a => 1, b => 2}
-#
-# # -- without conversion
-# $hsh.flatten()
-# # Would return [{a => 1, b => 2}]
-#
-# # -- with conversion
-# $hsh.convert_to(Array).flatten()
-# # Would return [a,1,b,2]
-#
-# flatten(Array($hsh))
-# # Would also return [a,1,b,2]
-# ```
-#
-# @example Flattening and concatenating at the same time
-#
-# ```puppet
-# $a1 = [1, [2, 3]]
-# $a2 = [[4,[5,6]]
-# $x = 7
-# flatten($a1, $a2, $x)
-# # would return [1,2,3,4,5,6,7]
-# ```
-#
-# @example Transforming to Array if not already an Array
-#
-# ```puppet
-# flatten(42)
-# # Would return [42]
-#
-# flatten([42])
-# # Would also return [42]
-# ```
-#
-# @since 5.5.0 support for flattening and concatenating at the same time
-#
-Puppet::Functions.create_function(:flatten) do
-  dispatch :flatten_args do
-    repeated_param 'Any', :args
-  end
-
-  def flatten_args(*args)
-    args.flatten()
-  end
-end