bolt 0.19.1 → 0.20.0

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

@@ -1,23 +0,0 @@
-# Makes iteration continue with the next value, optionally with a given value for this iteration.
-# If a value is not given it defaults to `undef`
-#
-# @since 4.7.0
-#
-Puppet::Functions.create_function(:next) do
-  dispatch :next_impl do
-    optional_param 'Any', :value
-  end
-
-  def next_impl(value = nil)
-    stacktrace = Puppet::Pops::PuppetStack.stacktrace()
-    if stacktrace.size > 0
-      file, line = stacktrace[0]
-    else
-      file = nil
-      line = nil
-    end
-
-    exc = Puppet::Pops::Evaluator::Next.new(value, file, line)
-    raise exc
-  end
-end

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

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

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

@@ -1,164 +0,0 @@
-# Applies a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
-# to every value in a data structure from the first argument, carrying over the returned
-# value of each iteration, and returns the result of the lambda's final iteration. This
-# lets you create a new value or data structure by combining values from the first
-# argument's data structure.
-#
-# 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 takes
-# two mandatory parameters:
-#     1. A memo value that is overwritten after each iteration with the iteration's result.
-#     2. A second value that is overwritten after each iteration with the next value in the
-#     function's first argument.
-#
-# @example Using the `reduce` function
-#
-# `$data.reduce |$memo, $value| { ... }`
-#
-# or
-#
-# `reduce($data) |$memo, $value| { ... }`
-#
-# You can also pass an optional "start memo" value as an argument, such as `start` below:
-#
-# `$data.reduce(start) |$memo, $value| { ... }`
-#
-# or
-#
-# `reduce($data, start) |$memo, $value| { ... }`
-#
-# When the first argument (`$data` in the above example) is an array, Puppet passes each
-# of the data structure's values in turn to the lambda's parameters. When the first
-# argument is a hash, Puppet converts each of the hash's values to an array in the form
-# `[key, value]`.
-#
-# If you pass a start memo value, Puppet executes the lambda with the provided memo value
-# and the data structure's first value. Otherwise, Puppet passes the structure's first two
-# values to the lambda.
-#
-# Puppet calls the lambda for each of the data structure's remaining values. For each
-# call, it passes the result of the previous call as the first parameter ($memo in the
-# above examples) and the next value from the data structure as the second parameter
-# ($value).
-#
-# If the structure has one value, Puppet returns the value and does not call the lambda.
-#
-# @example Using the `reduce` function
-#
-# ```puppet
-# # Reduce the array $data, returning the sum of all values in the array.
-# $data = [1, 2, 3]
-# $sum = $data.reduce |$memo, $value| { $memo + $value }
-# # $sum contains 6
-#
-# # Reduce the array $data, returning the sum of a start memo value and all values in the
-# # array.
-# $data = [1, 2, 3]
-# $sum = $data.reduce(4) |$memo, $value| { $memo + $value }
-# # $sum contains 10
-#
-# # Reduce the hash $data, returning the sum of all values and concatenated string of all
-# # keys.
-# $data = {a => 1, b => 2, c => 3}
-# $combine = $data.reduce |$memo, $value| {
-#   $string = "${memo[0]}${value[0]}"
-#   $number = $memo[1] + $value[1]
-#   [$string, $number]
-# }
-# # $combine contains [abc, 6]
-# ```
-#
-# @example Using the `reduce` function with a start memo and two-parameter lambda
-#
-# ```puppet
-# # Reduce the array $data, returning the sum of all values in the array and starting
-# # with $memo set to an arbitrary value instead of $data's first value.
-# $data = [1, 2, 3]
-# $sum = $data.reduce(4) |$memo, $value| { $memo + $value }
-# # At the start of the lambda's first iteration, $memo contains 4 and $value contains 1.
-# # After all iterations, $sum contains 10.
-#
-# # Reduce the hash $data, returning the sum of all values and concatenated string of
-# # all keys, and starting with $memo set to an arbitrary array instead of $data's first
-# # key-value pair.
-# $data = {a => 1, b => 2, c => 3}
-# $combine = $data.reduce( [d, 4] ) |$memo, $value| {
-#   $string = "${memo[0]}${value[0]}"
-#   $number = $memo[1] + $value[1]
-#   [$string, $number]
-# }
-# # At the start of the lambda's first iteration, $memo contains [d, 4] and $value
-# # contains [a, 1].
-# # $combine contains [dabc, 10]
-# ```
-#
-# @example Using the `reduce` function to reduce a hash of hashes
-#
-# ```puppet
-# # Reduce a hash of hashes $data, merging defaults into the inner hashes.
-# $data = {
-#   'connection1' => {
-#     'username' => 'user1',
-#     'password' => 'pass1',
-#   },
-#   'connection_name2' => {
-#     'username' => 'user2',
-#     'password' => 'pass2',
-#   },
-# }
-#
-# $defaults = {
-#   'maxActive' => '20',
-#   'maxWait'   => '10000',
-#   'username'  => 'defaultuser',
-#   'password'  => 'defaultpass',
-# }
-#
-# $merged = $data.reduce( {} ) |$memo, $x| {
-#   $memo + { $x[0] => $defaults + $data[$x[0]] }
-# }
-# # At the start of the lambda's first iteration, $memo is set to {}, and $x is set to
-# # the first [key, value] tuple. The key in $data is, therefore, given by $x[0]. In
-# # subsequent rounds, $memo retains the value returned by the expression, i.e.
-# # $memo + { $x[0] => $defaults + $data[$x[0]] }.
-# ```
-#
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:reduce) do
-
-  dispatch :reduce_without_memo do
-    param 'Iterable', :enumerable
-    block_param 'Callable[2,2]', :block
-  end
-
-  dispatch :reduce_with_memo do
-    param 'Iterable', :enumerable
-    param 'Any', :memo
-    block_param 'Callable[2,2]', :block
-  end
-
-  def reduce_without_memo(enumerable)
-    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    enum.reduce do |memo, x|
-      begin
-        yield(memo, x)
-      rescue StopIteration
-        return memo
-      end
-    end
-  end
-
-  def reduce_with_memo(enumerable, given_memo)
-    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    enum.reduce(given_memo) do |memo, x|
-      begin
-        yield(memo, x)
-      rescue StopIteration
-        return memo
-      end
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-# Performs regexp replacement on a string or array of strings.
-#
-# @param target [String, Array[String]]
-#      The string or array of strings to operate on.  If an array, the replacement will be
-#      performed on each of the elements in the array, and the return value will be an array.
-# @param pattern [String, Regexp, Type[Regexp]]
-#      The regular expression matching the target string.  If you want it anchored at the start
-#      and or end of the string, you must do that with ^ and $ yourself.
-# @param replacement [String, Hash[String, String]]
-#      Replacement string. Can contain backreferences to what was matched using \\0 (whole match),
-#      \\1 (first set of parentheses), and so on.
-#      If the second argument is a Hash, and the matched text is one of its keys, the corresponding value is the replacement string.
-# @param flags [Optional[Pattern[/^[GEIM]*$/]], Pattern[/^G?$/]]
-#      Optional. String of single letter flags for how the regexp is interpreted (E, I, and M cannot be used
-#      if pattern is a precompiled regexp):
-#        - *E*         Extended regexps
-#        - *I*         Ignore case in regexps
-#        - *M*         Multiline regexps
-#        - *G*         Global replacement; all occurrences of the regexp in each target string will be replaced.  Without this, only the first occurrence will be replaced.
-# @param encoding [Enum['N','E','S','U']]
-#      Optional. How to handle multibyte characters when compiling the regexp (must not be used when pattern is a
-#      precompiled regexp). A single-character string with the following values:
-#        - *N*         None
-#        - *E*         EUC
-#        - *S*         SJIS
-#        - *U*         UTF-8
-# @return [Array[String], String] The result of the substitution. Result type is the same as for the target parameter.
-#
-# @example Get the third octet from the node's IP address:
-#
-# ```puppet
-# $i3 = regsubst($ipaddress,'^(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)$','\\3')
-# ```
-#
-# @example Put angle brackets around each octet in the node's IP address:
-#
-# ```puppet
-# $x = regsubst($ipaddress, /([0-9]+)/, '<\\1>', 'G')
-# ```
-#
-Puppet::Functions.create_function(:regsubst) do
-  dispatch :regsubst_string do
-    param          'Variant[Array[String],String]',       :target
-    param          'String',                              :pattern
-    param          'Variant[String,Hash[String,String]]', :replacement
-    optional_param 'Optional[Pattern[/^[GEIM]*$/]]',      :flags
-    optional_param "Enum['N','E','S','U']",               :encoding
-  end
-
-  dispatch :regsubst_regexp do
-    param          'Variant[Array[String],String]',       :target
-    param          'Variant[Regexp,Type[Regexp]]',        :pattern
-    param          'Variant[String,Hash[String,String]]', :replacement
-    optional_param 'Pattern[/^G?$/]',                     :flags
-  end
-
-  def regsubst_string(target, pattern, replacement, flags = nil, encoding = nil)
-    re_flags = 0
-    operation = :sub
-    if !flags.nil?
-      flags.split(//).each do |f|
-        case f
-        when 'G' then operation = :gsub
-        when 'E' then re_flags |= Regexp::EXTENDED
-        when 'I' then re_flags |= Regexp::IGNORECASE
-        when 'M' then re_flags |= Regexp::MULTILINE
-        end
-      end
-    end
-    inner_regsubst(target, Regexp.compile(pattern, re_flags, encoding), replacement, operation)
-  end
-
-  def regsubst_regexp(target, pattern, replacement, flags = nil)
-    pattern = (pattern.pattern || '') if pattern.is_a?(Puppet::Pops::Types::PRegexpType)
-    inner_regsubst(target, pattern, replacement, flags == 'G' ? :gsub : :sub)
-  end
-
-  def inner_regsubst(target, re, replacement, op)
-    target.respond_to?(op) ? target.send(op, re, replacement) : target.collect { |e| e.send(op, re, replacement) }
-  end
-  private :inner_regsubst
-end

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

@@ -1,77 +0,0 @@
-# Requires the specified classes.
-# Evaluate one or more classes, adding the required class as a dependency.
-#
-# The relationship metaparameters work well for specifying relationships
-# between individual resources, but they can be clumsy for specifying
-# relationships between classes.  This function is a superset of the
-# 'include' function, adding a class relationship so that the requiring
-# class depends on the required class.
-#
-# Warning: using require in place of include can lead to unwanted dependency cycles.
-#
-# For instance the following manifest, with 'require' instead of 'include' would produce a nasty
-# dependence cycle, because notify imposes a before between File[/foo] and Service[foo]:
-#
-# ```puppet
-# class myservice {
-#   service { foo: ensure => running }
-# }
-#
-# class otherstuff {
-#    include myservice
-#    file { '/foo': notify => Service[foo] }
-# }
-# ```
-#
-# Note that this function only works with clients 0.25 and later, and it will
-# fail if used with earlier clients.
-#
-# You must use the class's full name;
-# relative names are not allowed. In addition to names in string form,
-# you may also directly use Class and Resource Type values that are produced when evaluating
-# resource and relationship expressions.
-#
-# - Since 4.0.0 Class and Resource types, absolute names
-# - Since 4.7.0 Returns an Array[Type[Class]] with references to the required classes
-#
-Puppet::Functions.create_function(:require, Puppet::Functions::InternalFunction) do
-  dispatch :require_impl do
-    scope_param
-    # The function supports what the type system sees as Ruby runtime objects, and
-    # they cannot be parameterized to find what is actually valid instances.
-    # The validation is instead done in the function body itself via a call to
-    # `transform_and_assert_classnames` on the calling scope.
-    required_repeated_param 'Any', :names
-  end
-
-  def require_impl(scope, *classes)
-    if Puppet[:tasks]
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
-        {:operation => 'require'})
-    end
-
-    # Make call patterns uniform and protected against nested arrays, also make
-    # names absolute if so desired.
-    classes = scope.transform_and_assert_classnames(classes.flatten)
-
-    result = classes.map {|name| Puppet::Pops::Types::TypeFactory.host_class(name) }
-
-    # This is the same as calling the include function (but faster) since it again
-    # would otherwise need to perform the optional absolute name transformation
-    # (for no reason since they are already made absolute here).
-    #
-    scope.compiler.evaluate_classes(classes, scope, false)
-    krt = scope.environment.known_resource_types
-
-    classes.each do |klass|
-      # lookup the class in the scopes
-      klass = (classobj = krt.find_hostclass(klass)) ? classobj.name : nil
-      raise Puppet::ParseError.new(_("Could not find class %{klass}") % { klass: klass }) unless klass
-      ref = Puppet::Resource.new(:class, klass)
-      resource = scope.resource
-      resource.set_parameter(:require, [resource[:require]].flatten.compact << ref)
-    end
-    result
-  end
-end

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

@@ -1,22 +0,0 @@
-# Makes iteration continue with the next value, optionally with a given value for this iteration.
-# If a value is not given it defaults to `undef`
-#
-# @since 4.7.0
-#
-Puppet::Functions.create_function(:return, Puppet::Functions::InternalFunction) do
-  dispatch :return_impl do
-    optional_param 'Any', :value
-  end
-
-  def return_impl(value = nil)
-    stacktrace = Puppet::Pops::PuppetStack.stacktrace()
-    if stacktrace.size > 0
-      file, line = stacktrace[0]
-    else
-      file = nil
-      line = nil
-    end
-
-    raise Puppet::Pops::Evaluator::Return.new(value, file, line)
-  end
-end

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

@@ -1,94 +0,0 @@
-# Reverses the order of the elements of something that is iterable and optionally runs a
-# [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) for each
-# element.
-#
-# This function takes one to two arguments:
-#
-# 1. An `Iterable` that the function will iterate over.
-# 2. An optional lambda, which the function calls for each element in the first argument. It must
-#    request one parameter.
-#
-# @example Using the `reverse_each` function
-#
-# ```puppet
-# $data.reverse_each |$parameter| { <PUPPET CODE BLOCK> }
-# ```
-#
-# or
-#
-# ```puppet
-# $reverse_data = $data.reverse_each
-# ```
-#
-# or
-#
-# ```puppet
-# reverse_each($data) |$parameter| { <PUPPET CODE BLOCK> }
-# ```
-#
-# or
-#
-# ```puppet
-# $reverse_data = reverse_each($data)
-# ```
-#
-# When no second argument is present, Puppet returns an `Iterable` that represents the reverse
-# order of its first argument. This allows methods on `Iterable` to be chained.
-#
-# When a lambda is given as the second argument, Puppet iterates the first argument in reverse
-# order and passes each value in turn to the lambda, then returns `undef`.
-#
-# @example Using the `reverse_each` function with an array and a one-parameter lambda
-#
-# ```puppet
-# # Puppet will log a notice for each of the three items
-# # in $data in reverse order.
-# $data = [1,2,3]
-# $data.reverse_each |$item| { notice($item) }
-# ```
-#
-# When no second argument is present, Puppet returns a new `Iterable` which allows it to
-# be directly chained into another function that takes an `Iterable` as an argument.
-#
-# @example Using the `reverse_each` function chained with a `map` function.
-#
-# ```puppet
-# # For the array $data, return an array containing each
-# # value multiplied by 10 in reverse order
-# $data = [1,2,3]
-# $transformed_data = $data.reverse_each.map |$item| { $item * 10 }
-# # $transformed_data is set to [30,20,10]
-# ```
-#
-# @example Using `reverse_each` function chained with a `map` in alternative syntax
-#
-# ```puppet
-# # For the array $data, return an array containing each
-# # value multiplied by 10 in reverse order
-# $data = [1,2,3]
-# $transformed_data = map(reverse_each($data)) |$item| { $item * 10 }
-# # $transformed_data is set to [30,20,10]
-# ```
-#
-# @since 4.4.0
-#
-Puppet::Functions.create_function(:reverse_each) do
-  dispatch :reverse_each do
-    param 'Iterable', :iterable
-  end
-
-  dispatch :reverse_each_block do
-    param 'Iterable', :iterable
-    block_param 'Callable[1,1]', :block
-  end
-
-  def reverse_each(iterable)
-    # produces an Iterable
-    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).reverse_each
-  end
-
-  def reverse_each_block(iterable, &block)
-    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).reverse_each(&block)
-    nil
-  end
-end