bolt 0.19.1 → 0.20.0

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

@@ -1,44 +0,0 @@
-# Scans a string and returns an array of one or more converted values based on the given format string.
-# See the documentation of Ruby's String#scanf method for details about the supported formats (which
-# are similar but not identical to the formats used in Puppet's `sprintf` function.)
-#
-# This function takes two mandatory arguments: the first is the string to convert, and the second is
-# the format string. The result of the scan is an array, with each successfully scanned and transformed value.
-# The scanning stops if a scan is unsuccessful, and the scanned result up to that point is returned. If there
-# was no successful scan, the result is an empty array.
-#
-#    "42".scanf("%i")
-#
-# You can also optionally pass a lambda to scanf, to do additional validation or processing.
-#
-#
-#     "42".scanf("%i") |$x| {
-#       unless $x[0] =~ Integer {
-#         fail "Expected a well formed integer value, got '$x[0]'"
-#       }
-#       $x[0]
-#     }
-#
-#
-#
-#
-#
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:scanf) do
-  require 'scanf'
-
-  dispatch :scanf do
-    param 'String', :data
-    param 'String', :format
-    optional_block_param
-  end
-
-  def scanf(data, format)
-    result = data.scanf(format)
-    if block_given?
-      result = yield(result)
-    end
-    result
-  end
-end

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

@@ -1,124 +0,0 @@
-# Slices an array or hash into pieces of a given size.
-#
-# This function takes two mandatory arguments: the first should be an array or hash, and the second specifies
-# the number of elements to include in each slice.
-#
-# When the first argument is a hash, each key value pair is counted as one. For example, a slice size of 2 will produce
-# an array of two arrays with key, and value.
-#
-# @example Slicing a Hash
-#
-# ```puppet
-# $a.slice(2) |$entry|          { notice "first ${$entry[0]}, second ${$entry[1]}" }
-# $a.slice(2) |$first, $second| { notice "first ${first}, second ${second}" }
-# ```
-# The function produces a concatenated result of the slices.
-#
-# @example Slicing an Array
-#
-# ```puppet
-# slice([1,2,3,4,5,6], 2) # produces [[1,2], [3,4], [5,6]]
-# slice(Integer[1,6], 2)  # produces [[1,2], [3,4], [5,6]]
-# slice(4,2)              # produces [[0,1], [2,3]]
-# slice('hello',2)        # produces [[h, e], [l, l], [o]]
-# ```
-#
-# @example Passing a lambda to a slice (optional)
-#
-# ```puppet
-#  $a.slice($n) |$x| { ... }
-#  slice($a) |$x| { ... }
-# ```
-#
-# The lambda should have either one parameter (receiving an array with the slice), or the same number
-# of parameters as specified by the slice size (each parameter receiving its part of the slice).
-# If there are fewer remaining elements than the slice size for the last slice, it will contain the remaining
-# elements. If the lambda has multiple parameters, excess parameters are set to undef for an array, or
-# to empty arrays for a hash.
-#
-# @example Getting individual values of a slice
-#
-# ```puppet
-#     $a.slice(2) |$first, $second| { ... }
-# ```
-#
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:slice) do
-  dispatch :slice_Hash do
-    param 'Hash[Any, Any]', :hash
-    param 'Integer[1, default]', :slice_size
-    optional_block_param
-  end
-
-  dispatch :slice_Enumerable do
-    param 'Iterable', :enumerable
-    param 'Integer[1, default]', :slice_size
-    optional_block_param
-  end
-
-  def slice_Hash(hash, slice_size, &pblock)
-    result = slice_Common(hash, slice_size, [], block_given? ? pblock : nil)
-    block_given? ? hash : result
-  end
-
-  def slice_Enumerable(enumerable, slice_size, &pblock)
-    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    result = slice_Common(enum, slice_size, nil, block_given? ? pblock : nil)
-    block_given? ? enumerable : result
-  end
-
-  def slice_Common(o, slice_size, filler, pblock)
-    serving_size = asserted_slice_serving_size(pblock, slice_size)
-
-    enumerator = o.each_slice(slice_size)
-    result = []
-    if serving_size == 1
-      begin
-        if pblock
-          loop do
-            pblock.call(enumerator.next)
-          end
-        else
-          loop do
-            result << enumerator.next
-          end
-        end
-      rescue StopIteration
-      end
-    else
-      begin
-        loop do
-          a = enumerator.next
-          if a.size < serving_size
-            a = a.dup.fill(filler, a.length...serving_size)
-          end
-          pblock.call(*a)
-        end
-      rescue StopIteration
-      end
-    end
-    if pblock
-      o
-    else
-      result
-    end
-  end
-
-  def asserted_slice_serving_size(pblock, slice_size)
-    if pblock
-      arity = pblock.arity
-      serving_size = arity < 0 ? slice_size : arity
-    else
-      serving_size = 1
-    end
-    if serving_size == 0
-      raise ArgumentError, _("slice(): block must define at least one parameter. Block has 0.")
-    end
-    unless serving_size == 1 || serving_size == slice_size
-      raise ArgumentError, _("slice(): block must define one parameter, or the same number of parameters as the given size of the slice (%{slice_size}). Block has %{serving_size}; %{parameter_names}") %
-          { slice_size: slice_size, serving_size: serving_size, parameter_names: pblock.parameter_names.join(', ') }
-    end
-    serving_size
-  end
-end

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

@@ -1,49 +0,0 @@
-# Splits a string into an array using a given pattern.
-# The pattern can be a string, regexp or regexp type.
-#
-# @example Splitting a String value
-#
-# ```puppet
-# $string     = 'v1.v2:v3.v4'
-# $array_var1 = split($string, /:/)
-# $array_var2 = split($string, '[.]')
-# $array_var3 = split($string, Regexp['[.:]'])
-#
-# #`$array_var1` now holds the result `['v1.v2', 'v3.v4']`,
-# # while `$array_var2` holds `['v1', 'v2:v3', 'v4']`, and
-# # `$array_var3` holds `['v1', 'v2', 'v3', 'v4']`.
-# ```
-#
-# Note that in the second example, we split on a literal string that contains
-# a regexp meta-character (`.`), which must be escaped.  A simple
-# way to do that for a single character is to enclose it in square
-# brackets; a backslash will also escape a single character.
-#
-Puppet::Functions.create_function(:split) do
-  dispatch :split_String do
-    param 'String', :str
-    param 'String', :pattern
-  end
-
-  dispatch :split_Regexp do
-    param 'String', :str
-    param 'Regexp', :pattern
-  end
-
-  dispatch :split_RegexpType do
-    param 'String', :str
-    param 'Type[Regexp]', :pattern
-  end
-
-  def split_String(str, pattern)
-    str.split(Regexp.compile(pattern))
-  end
-
-  def split_Regexp(str, pattern)
-    str.split(pattern)
-  end
-
-  def split_RegexpType(str, pattern)
-    str.split(pattern.regexp)
-  end
-end

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

@@ -1,98 +0,0 @@
-# Provides stepping with given interval over elements in an iterable and optionally runs a
-# [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) for each
-# element.
-#
-# This function takes two to three arguments:
-#
-# 1. An 'Iterable' that the function will iterate over.
-# 2. An `Integer` step factor. This must be a positive integer.
-# 3. An optional lambda, which the function calls for each element in the interval. It must
-#    request one parameter.
-#
-# @example Using the `step` function
-#
-# ```puppet
-# $data.step(<n>) |$parameter| { <PUPPET CODE BLOCK> }
-# ```
-#
-# or
-#
-# ```puppet
-# $stepped_data = $data.step(<n>)
-# ```
-#
-# or
-#
-# ```puppet
-# step($data, <n>) |$parameter| { <PUPPET CODE BLOCK> }
-# ```
-#
-# or
-#
-# ```puppet
-# $stepped_data = step($data, <n>)
-# ```
-#
-# When no block is given, Puppet returns an `Iterable` that yields the first element and every nth successor
-# element, from its first argument. This allows functions on iterables to be chained.
-# When a block is given, Puppet iterates and calls the block with the first element and then with
-# every nth successor element. It then returns `undef`.
-#
-# @example Using the `step` function with an array, a step factor, and a one-parameter block
-#
-# ```puppet
-# # For the array $data, call a block with the first element and then with each 3rd successor element
-# $data = [1,2,3,4,5,6,7,8]
-# $data.step(3) |$item| {
-#  notice($item)
-# }
-# # Puppet notices the values '1', '4', '7'.
-# ```
-
-# When no block is given, 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 `step` function chained with a `map` function.
-#
-# ```puppet
-# # For the array $data, return an array, set to the first element and each 5th successor element, in reverse
-# # order multiplied by 10
-# $data = Integer[0,20]
-# $transformed_data = $data.step(5).map |$item| { $item * 10 }
-# $transformed_data contains [0,50,100,150,200]
-# ```
-#
-# @example The same example using `step` function chained with a `map` in alternative syntax
-#
-# ```puppet
-# # For the array $data, return an array, set to the first and each 5th
-# # successor, in reverse order, multiplied by 10
-# $data = Integer[0,20]
-# $transformed_data = map(step($data, 5)) |$item| { $item * 10 }
-# $transformed_data contains [0,50,100,150,200]
-# ```
-#
-# @since 4.4.0
-#
-Puppet::Functions.create_function(:step) do
-  dispatch :step do
-    param 'Iterable', :iterable
-    param 'Integer[1]', :step
-  end
-
-  dispatch :step_block do
-    param 'Iterable', :iterable
-    param 'Integer[1]', :step
-    block_param 'Callable[1,1]', :block
-  end
-
-  def step(iterable, step)
-    # produces an Iterable
-    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).step(step)
-  end
-
-  def step_block(iterable, step, &block)
-    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).step(step, &block)
-    nil
-  end
-end

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

@@ -1,217 +0,0 @@
-# Formats timestamp or timespan according to the directives in the given format string. The directives begins with a percent (%) character.
-# Any text not listed as a directive will be passed through to the output string.
-#
-# A third optional timezone argument can be provided. The first argument will then be formatted to represent a local time in that
-# timezone. The timezone can be any timezone that is recognized when using the '%z' or '%Z' formats, or the word 'current', in which
-# case the current timezone of the evaluating process will be used. The timezone argument is case insensitive.
-#
-# The default timezone, when no argument is provided, or when using the keyword `default`, is 'UTC'.
-#
-# The directive consists of a percent (%) character, zero or more flags, optional minimum field width and
-# a conversion specifier as follows:
-#
-# ```
-# %[Flags][Width]Conversion
-# ```
-#
-# ### Flags that controls padding
-#
-# | Flag  | Meaning
-# | ----  | ---------------
-# | -     | Don't pad numerical output
-# | _     | Use spaces for padding
-# | 0     | Use zeros for padding
-#
-# ### `Timestamp` specific flags
-#
-# | Flag  | Meaning
-# | ----  | ---------------
-# | #     | Change case
-# | ^     | Use uppercase
-# | :     | Use colons for %z
-#
-# ### Format directives applicable to `Timestamp` (names and padding can be altered using flags):
-#
-# **Date (Year, Month, Day):**
-#
-# | Format | Meaning |
-# | ------ | ------- |
-# | Y | Year with century, zero-padded to at least 4 digits |
-# | C | year / 100 (rounded down such as 20 in 2009) |
-# | y | year % 100 (00..99) |
-# | m | Month of the year, zero-padded (01..12) |
-# | B | The full month name ("January") |
-# | b | The abbreviated month name ("Jan") |
-# | h | Equivalent to %b |
-# | d | Day of the month, zero-padded (01..31) |
-# | e | Day of the month, blank-padded ( 1..31) |
-# | j | Day of the year (001..366) |
-#
-# **Time (Hour, Minute, Second, Subsecond):**
-#
-# | Format | Meaning |
-# | ------ | ------- |
-# | H | Hour of the day, 24-hour clock, zero-padded (00..23) |
-# | k | Hour of the day, 24-hour clock, blank-padded ( 0..23) |
-# | I | Hour of the day, 12-hour clock, zero-padded (01..12) |
-# | l | Hour of the day, 12-hour clock, blank-padded ( 1..12) |
-# | P | Meridian indicator, lowercase ("am" or "pm") |
-# | p | Meridian indicator, uppercase ("AM" or "PM") |
-# | M | Minute of the hour (00..59) |
-# | S | Second of the minute (00..60) |
-# | L | Millisecond of the second (000..999). Digits under millisecond are truncated to not produce 1000 |
-# | N | Fractional seconds digits, default is 9 digits (nanosecond). Digits under a specified width are truncated to avoid carry up |
-#
-# **Time (Hour, Minute, Second, Subsecond):**
-#
-# | Format | Meaning |
-# | ------ | ------- |
-# | z   | Time zone as hour and minute offset from UTC (e.g. +0900) |
-# | :z  | hour and minute offset from UTC with a colon (e.g. +09:00) |
-# | ::z | hour, minute and second offset from UTC (e.g. +09:00:00) |
-# | Z   | Abbreviated time zone name or similar information.  (OS dependent) |
-#
-# **Weekday:**
-#
-# | Format | Meaning |
-# | ------ | ------- |
-# | A | The full weekday name ("Sunday") |
-# | a | The abbreviated name ("Sun") |
-# | u | Day of the week (Monday is 1, 1..7) |
-# | w | Day of the week (Sunday is 0, 0..6) |
-#
-# **ISO 8601 week-based year and week number:**
-#
-# The first week of YYYY starts with a Monday and includes YYYY-01-04.
-# The days in the year before the first week are in the last week of
-# the previous year.
-#
-# | Format | Meaning |
-# | ------ | ------- |
-# | G | The week-based year |
-# | g | The last 2 digits of the week-based year (00..99) |
-# | V | Week number of the week-based year (01..53) |
-#
-# **Week number:**
-#
-# The first week of YYYY that starts with a Sunday or Monday (according to %U
-# or %W). The days in the year before the first week are in week 0.
-#
-# | Format | Meaning |
-# | ------ | ------- |
-# | U | Week number of the year. The week starts with Sunday. (00..53) |
-# | W | Week number of the year. The week starts with Monday. (00..53) |
-#
-# **Seconds since the Epoch:**
-#
-# | Format | Meaning |
-# | s | Number of seconds since 1970-01-01 00:00:00 UTC. |
-#
-# **Literal string:**
-#
-# | Format | Meaning |
-# | ------ | ------- |
-# | n | Newline character (\n) |
-# | t | Tab character (\t) |
-# | % | Literal "%" character |
-#
-# **Combination:**
-#
-# | Format | Meaning |
-# | ------ | ------- |
-# | c | date and time (%a %b %e %T %Y) |
-# | D | Date (%m/%d/%y) |
-# | F | The ISO 8601 date format (%Y-%m-%d) |
-# | v | VMS date (%e-%^b-%4Y) |
-# | x | Same as %D |
-# | X | Same as %T |
-# | r | 12-hour time (%I:%M:%S %p) |
-# | R | 24-hour time (%H:%M) |
-# | T | 24-hour time (%H:%M:%S) |
-#
-# @example Using `strftime` with a `Timestamp`:
-#
-# ```puppet
-# $timestamp = Timestamp('2016-08-24T12:13:14')
-#
-# # Notice the timestamp using a format that notices the ISO 8601 date format
-# notice($timestamp.strftime('%F')) # outputs '2016-08-24'
-#
-# # Notice the timestamp using a format that notices weekday, month, day, time (as UTC), and year
-# notice($timestamp.strftime('%c')) # outputs 'Wed Aug 24 12:13:14 2016'
-#
-# # Notice the timestamp using a specific timezone
-# notice($timestamp.strftime('%F %T %z', 'PST')) # outputs '2016-08-24 04:13:14 -0800'
-#
-# # Notice the timestamp using timezone that is current for the evaluating process
-# notice($timestamp.strftime('%F %T', 'current')) # outputs the timestamp using the timezone for the current process
-# ```
-#
-# ### Format directives applicable to `Timespan`:
-#
-# | Format | Meaning |
-# | ------ | ------- |
-# | D | Number of Days |
-# | H | Hour of the day, 24-hour clock |
-# | M | Minute of the hour (00..59) |
-# | S | Second of the minute (00..59) |
-# | L | Millisecond of the second (000..999). Digits under millisecond are truncated to not produce 1000. |
-# | N | Fractional seconds digits, default is 9 digits (nanosecond). Digits under a specified length are truncated to avoid carry up |
-#
-# The format directive that represents the highest magnitude in the format will be allowed to overflow.
-# I.e. if no "%D" is used but a "%H" is present, then the hours will be more than 23 in case the
-# timespan reflects more than a day.
-#
-# @example Using `strftime` with a Timespan and a format
-#
-# ```puppet
-# $duration = Timespan({ hours => 3, minutes => 20, seconds => 30 })
-#
-# # Notice the duration using a format that outputs <hours>:<minutes>:<seconds>
-# notice($duration.strftime('%H:%M:%S')) # outputs '03:20:30'
-#
-# # Notice the duration using a format that outputs <minutes>:<seconds>
-# notice($duration.strftime('%M:%S')) # outputs '200:30'
-# ```
-#
-# - Since 4.8.0
-# 
-Puppet::Functions.create_function(:strftime) do
-  dispatch :format_timespan do
-    param 'Timespan', :time_object
-    param 'String', :format
-  end
-
-  dispatch :format_timestamp do
-    param 'Timestamp', :time_object
-    param 'String', :format
-    optional_param 'String', :timezone
-  end
-
-  dispatch :legacy_strftime do
-    param 'String', :format
-    optional_param 'String', :timezone
-  end
-
-  def format_timespan(time_object, format)
-    time_object.format(format)
-  end
-
-  def format_timestamp(time_object, format, timezone = nil)
-    time_object.format(format, timezone)
-  end
-
-  def legacy_strftime(format, timezone = nil)
-    stacktrace = Puppet::Pops::PuppetStack.stacktrace()
-    if stacktrace.size > 0
-      file, line = stacktrace[0]
-    else
-      file = nil
-      line = nil
-    end
-    Puppet.warn_once('deprecations', 'legacy#strftime',
-      _('The argument signature (String format, [String timezone]) is deprecated for #strftime. See #strftime documentation and Timespan type for more info'),
-      file, line)
-    Puppet::Pops::Time::Timestamp.format_time(format, Time.now.utc, timezone)
-  end
-end