bolt 0.24.0 → 0.25.0

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

@@ -1,144 +0,0 @@
-# Applies a [lambda](https://puppet.com/docs/puppet/latest/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 a truthy value (not `false` or `undef`).
-#
-# 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
-# @since 6.0.0 does not filter if truthy value is returned from block
-#
-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]) }
-    # 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) }
-    # 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)
-          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) }
-      result
-    else
-      result = []
-      begin
-        index = 0
-        loop do
-          it = enum.next
-          if yield(index, it)
-            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

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

@@ -1,37 +0,0 @@
-# Returns the largest `Integer` less or equal to the argument.
-# Takes a single numeric value as an argument.
-#
-# This function is backwards compatible with the same function in stdlib
-# and accepts a `Numeric` value. A `String` that can be converted
-# to a floating point number can also be used in this version - but this
-# is deprecated.
-#
-# In general convert string input to `Numeric` before calling this function
-# to have full control over how the conversion is done.
-#
-Puppet::Functions.create_function(:floor) do
-  dispatch :on_numeric do
-    param 'Numeric', :val
-  end
-
-  dispatch :on_string do
-    param 'String', :val
-  end
-
-  def on_numeric(x)
-    x.floor
-  end
-
-  def on_string(x)
-    Puppet.warn_once('deprecations', 'floor_function_numeric_coerce_string',
-      _("The floor() function's auto conversion of String to Float is deprecated - change to convert input before calling"))
-
-    begin
-      Float(x).floor
-    rescue TypeError, ArgumentError => _e
-      # TRANSLATORS: 'floor' is a name and should not be translated
-      raise(ArgumentError, _('floor(): cannot convert given value to a floating point value.'))
-    end
-  end
-
-end

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

@@ -1,150 +0,0 @@
-# Digs into a value with dot notation to get a value from within a structure.
-#
-# **To dig into a given value**, call the function with (at least) two arguments:
-#
-# * The **first** argument must be an Array, or Hash. Value can also be `undef`
-#   (which also makes the result `undef` unless a _default value_ is given).
-# * The **second** argument must be a _dot notation navigation string_.
-# * The **optional third** argument can be any type of value and it is used
-#   as the _default value_ if the function would otherwise return `undef`.
-# * An **optional lambda** for error handling taking one `Error` argument.
-#
-# **Dot notation navigation string** -
-# The dot string consists of period `.` separated segments where each
-# segment is either the index into an array or the value of a hash key.
-# If a wanted key contains a period it must be quoted to avoid it being
-# taken as a segment separator. Quoting can be done with either
-# single quotes `'` or double quotes `"`. If a segment is
-# a decimal number it is converted to an Integer index. This conversion
-# can be prevented by quoting the value.
-#
-# @example Navigating into a value
-# ```puppet
-# #get($facts, 'os.family')
-# $facts.get('os.family')
-# ```
-# Would both result in the value of $facts['os']['family']
-#
-# @example Getting the value from an expression
-# ```puppet
-# get([1,2,[{'name' =>'waldo'}]], '2.0.name')
-# ```
-# Would result in 'waldo'
-#
-# @example Using a default value
-# ```puppet
-# get([1,2,[{'name' =>'waldo'}]], '2.1.name', 'not waldo')
-#
-# ```
-# Would result in 'not waldo'
-#
-# @example Quoting a key with period
-# ```puppet
-# $x = [1, 2, { 'readme.md' => "This is a readme."}]
-# $x.get('2."readme.md"')
-# ```
-#
-# @example Quoting a numeric string
-# ```puppet
-# $x = [1, 2, { '10' => "ten"}]
-# $x.get('2."0"')
-# ```
-#
-# **Error Handling** - There are two types of common errors that can
-# be handled by giving the function a code block to execute.
-# (A third kind or error; when the navigation string has syntax errors
-# (for example an empty segment or unbalanced quotes) will always raise
-# an error).
-#
-# The given block will be given an instance of the `Error` data type,
-# and it has methods to extract `msg`, `issue_code`, `kind`, and
-# `details`.
-#
-# The `msg` will be a preformatted message describing the error.
-# This is the error message that would have surfaced if there was
-# no block to handle the error.
-#
-# The `kind` is the string `'SLICE_ERROR'` for both kinds of errors,
-# and the `issue_code` is either the string `'EXPECTED_INTEGER_INDEX'`
-# for an attempt to index into an array with a String,
-# or `'EXPECTED_COLLECTION'` for an attempt to index into something that
-# is not a Collection.
-#
-# The `details` is a Hash that for both issue codes contain the
-# entry `'walked_path'` which is an Array with each key in the
-# progression of the dig up to the place where the error occurred.
-#
-# For an `EXPECTED_INTEGER_INDEX`-issue the detail `'index_type'` is
-# set to the data type of the index value and for an
-# `'EXPECTED_COLLECTION'`-issue the detail `'value_type'` is set
-# to the type of the value.
-#
-# The logic in the error handling block can inspect the details,
-# and either call `fail()` with a custom error message or produce
-# the wanted value.
-#
-# If the block produces `undef` it will not be replaced with a
-# given default value.
-#
-# @example Ensure `undef` result on error
-# ```puppet
-# $x = 'blue'
-# $x.get('0.color', 'green') |$error| { undef } # result is undef
-#
-# $y = ['blue']
-# $y.get('color', 'green') |$error| { undef } # result is undef
-# ```
-#
-# @example Accessing information in the Error
-# ```puppet
-# $x = [1, 2, ['blue']]
-# $x.get('2.color') |$error| {
-#   notice("Walked path is ${error.details['walked_path']}")
-# }
-# ```
-# Would notice `Walked path is [2, color]`
-#
-# Also see:
-# * `getvar()` that takes the first segment to be the name of a variable
-#   and then delegates to this function.
-# * `dig()` function which is similar but uses an
-#   array of navigation values instead of a dot notation string.
-#
-# @since 6.0.0
-#
-Puppet::Functions.create_function(:get, Puppet::Functions::InternalFunction) do
-  dispatch :get_from_value do
-    param 'Any', :value
-    param 'String', :dotted_string
-    optional_param 'Any', :default_value
-    optional_block_param 'Callable[1,1]', :block
-  end
-
-  # Gets a result from given value and a navigation string
-  #
-  def get_from_value(value, navigation, default_value = nil, &block)
-    return default_value if value.nil?
-    return value if navigation.empty?
-
-    # Note: split_key always processes the initial segment as a string even if it could be an integer.
-    # This since it is designed for lookup keys. For a numeric first segment
-    # like '0.1' the wanted result is [0,1], not ["0", 1]. The workaround here is to
-    # prefix the navigation with "x." thus giving split_key a first segment that is a string.
-    # The fake segment is then dropped.
-    segments = split_key("x." + navigation) {|err| _("Syntax error in dotted-navigation string")}
-    segments.shift
-
-    begin
-      result = call_function('dig', value, *segments)
-      return result.nil? ? default_value : result
-    rescue Puppet::ErrorWithData => e
-      if block_given?
-        yield(e.error_data)
-      else
-        raise e
-      end
-    end
-  end
-  # reuse the split_key parser used also by lookup
-  include Puppet::Pops::Lookup::SubLookup
-end

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

@@ -1,87 +0,0 @@
-# Digs into a variable with dot notation to get a value from a structure.
-#
-# **To get the value from a variable** (that may or may not exist), call the function with
-# one or two arguments:
-#
-# * The **first** argument must be a string, and must start with a variable name without leading `$`,
-#   for example `get('facts')`. The variable name can be followed
-#   by a _dot notation navigation string_ to dig out a value in the array or hash value
-#   of the variable.
-# * The **optional second** argument can be any type of value and it is used as the
-#   _default value_ if the function would otherwise return `undef`.
-# * An **optional lambda** for error handling taking one `Error` argument.
-#
-# **Dot notation navigation string** -
-# The dot string consists of period `.` separated segments where each
-# segment is either the index into an array or the value of a hash key.
-# If a wanted key contains a period it must be quoted to avoid it being
-# taken as a segment separator. Quoting can be done with either
-# single quotes `'` or double quotes `"`. If a segment is
-# a decimal number it is converted to an Integer index. This conversion
-# can be prevented by quoting the value.
-#
-# @example Getting the value of a variable
-# ```puppet
-# getvar('facts') # results in the value of $facts
-# ```
-#
-# @example Navigating into a variable
-# ```puppet
-# getvar('facts.os.family') # results in the value of $facts['os']['family']
-# ```
-#
-# @example Using a default value
-# ```puppet
-# $x = [1,2,[{'name' =>'waldo'}]]
-# getvar('x.2.1.name', 'not waldo')
-# # results in 'not waldo'
-# ```
-#
-# For further examples and how to perform error handling, see the `get()` function
-# which this function delegates to after having resolved the variable value.
-#
-# @since 6.0.0 - the ability to dig into the variable's value with dot notation.
-#
-Puppet::Functions.create_function(:getvar, Puppet::Functions::InternalFunction) do
-  dispatch :get_from_navigation do
-    scope_param
-     param 'Pattern[/\A(?:::)?(?:[a-z]\w*::)*[a-z_]\w*(?:\.|\Z)/]', :get_string
-    optional_param 'Any', :default_value
-    optional_block_param 'Callable[1,1]', :block
-  end
-
-  argument_mismatch :invalid_variable_error do
-    param 'String', :get_string
-    optional_param 'Any', :default_value
-    optional_block_param 'Callable', :block
-  end
-
-  def invalid_variable_error(navigation, default_value=nil, &block)
-    _("The given string does not start with a valid variable name")
-  end
-
-  # Gets a result from a navigation string starting with $var
-  #
-  def get_from_navigation(scope, navigation, default_value = nil, &block)
-    # asserted to start with a valid variable name - dig out the variable
-    matches = navigation.match(/^((::)?(\w+::)*\w+)(.*)\z/)
-    navigation = matches[4]
-    if navigation[0] == '.'
-      navigation = navigation[1..-1]
-    else
-      unless navigation.empty?
-        raise ArgumentError, _("First character after var name in get string must be a '.' - got %{char}") % {char: navigation[0]}
-      end
-    end
-    get_from_var_name(scope, matches[1], navigation, default_value, &block)
-  end
-
-  # Gets a result from a $var name and a navigation string
-  #
-  def get_from_var_name(scope, var_string, navigation, default_value = nil, &block)
-    catch(:undefined_variable) do
-      return call_function_with_scope(scope,'get', scope.lookupvar(var_string), navigation, default_value, &block)
-    end
-    default_value
-  end
-end