openvox 7.37.1

data/lib/puppet/functions/size.rb

@@ -0,0 +1,15 @@
+# The same as length() - returns the size of an Array, Hash, String, or Binary value.
+#
+# @since 6.0.0 - also supporting Binary
+#
+Puppet::Functions.create_function(:size) do
+  dispatch :generic_size do
+    param 'Variant[Collection, String, Binary]', :arg
+  end
+
+
+  def generic_size(arg)
+    call_function('length', arg)
+  end
+
+end

data/lib/puppet/functions/slice.rb

@@ -0,0 +1,124 @@
+# 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/lib/puppet/functions/sort.rb

@@ -0,0 +1,74 @@
+# Sorts an Array numerically or lexicographically or the characters of a String lexicographically.
+# Please note: This function is based on Ruby String comparison and as such may not be entirely UTF8 compatible.
+# To ensure compatibility please use this function with Ruby 2.4.0 or greater - https://bugs.ruby-lang.org/issues/10085.
+#
+# This function is compatible with the function `sort()` in `stdlib`.
+# * Comparison of characters in a string always uses a system locale and may not be what is expected for a particular locale
+# * Sorting is based on Ruby's `<=>` operator unless a lambda is given that performs the comparison.
+#   * comparison of strings is case dependent (use lambda with `compare($a,$b)` to ignore case)
+#   * comparison of mixed data types raises an error (if there is the need to sort mixed data types use a lambda)
+#
+# Also see the `compare()` function for information about comparable data types in general.
+#
+# @example Sorting a String
+#
+# ```puppet
+# notice(sort("xadb")) # notices 'abdx'
+# ```
+#
+# @example Sorting an Array
+#
+# ```puppet
+# notice(sort([3,6,2])) # notices [2, 3, 6]
+# ```
+#
+# @example Sorting with a lambda
+#
+# ```puppet
+# notice(sort([3,6,2]) |$a,$b| { compare($a, $b) }) # notices [2, 3, 6]
+# notice(sort([3,6,2]) |$a,$b| { compare($b, $a) }) # notices [6, 3, 2]
+# ```
+#
+# @example Case independent sorting with a lambda
+#
+# ```puppet
+# notice(sort(['A','b','C']))                                    # notices ['A', 'C', 'b']
+# notice(sort(['A','b','C']) |$a,$b| { compare($a, $b) })        # notices ['A', 'b', 'C']
+# notice(sort(['A','b','C']) |$a,$b| { compare($a, $b, true) })  # notices ['A', 'b', 'C']
+# notice(sort(['A','b','C']) |$a,$b| { compare($a, $b, false) }) # notices ['A','C', 'b']
+# ```
+#
+# @example Sorting Array with Numeric and String so that numbers are before strings
+#
+# ```puppet
+# notice(sort(['b', 3, 'a', 2]) |$a, $b| {
+#   case [$a, $b] {
+#     [String, Numeric] : { 1 }
+#     [Numeric, String] : { -1 }
+#     default:            { compare($a, $b) }
+#   }
+# })
+# ```
+# Would notice `[2,3,'a','b']`
+#
+# @since 6.0.0 - supporting a lambda to do compare
+#
+Puppet::Functions.create_function(:sort) do
+  dispatch :sort_string do
+    param 'String', :string_value
+    optional_block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :sort_array do
+    param 'Array', :array_value
+    optional_block_param 'Callable[2,2]', :block
+  end
+
+  def sort_string(s, &block)
+    sort_array(s.split(''), &block).join('')
+  end
+
+  def sort_array(a, &block)
+    a.sort(&block)
+  end
+end

data/lib/puppet/functions/split.rb

@@ -0,0 +1,76 @@
+# 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
+
+  dispatch :split_String_sensitive do
+    param 'Sensitive[String]', :sensitive
+    param 'String', :pattern
+  end
+
+  dispatch :split_Regexp_sensitive do
+    param 'Sensitive[String]', :sensitive
+    param 'Regexp', :pattern
+  end
+
+  dispatch :split_RegexpType_sensitive do
+    param 'Sensitive[String]', :sensitive
+    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
+
+  def split_String_sensitive(sensitive, pattern)
+    Puppet::Pops::Types::PSensitiveType::Sensitive.new(split_String(sensitive.unwrap, pattern))
+  end
+
+  def split_Regexp_sensitive(sensitive, pattern)
+    Puppet::Pops::Types::PSensitiveType::Sensitive.new(split_Regexp(sensitive.unwrap, pattern))
+  end
+
+  def split_RegexpType_sensitive(sensitive, pattern)
+    Puppet::Pops::Types::PSensitiveType::Sensitive.new(split_RegexpType(sensitive.unwrap, pattern))
+  end
+end

data/lib/puppet/functions/step.rb

@@ -0,0 +1,98 @@
+# Provides stepping with given interval over elements in an iterable and optionally runs a
+# [lambda](https://puppet.com/docs/puppet/latest/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, true).step(step)
+  end
+
+  def step_block(iterable, step, &block)
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).step(step, &block)
+    nil
+  end
+end

data/lib/puppet/functions/strftime.rb

@@ -0,0 +1,212 @@
+# 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)
+    file, line = Puppet::Pops::PuppetStack.top_of_stack
+    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

data/lib/puppet/functions/strip.rb

@@ -0,0 +1,58 @@
+# Strips leading and trailing spaces from a String
+#
+# This function is compatible with the stdlib function with the same name.
+#
+# The function does the following:
+# * For a `String` the conversion removes all leading and trailing ASCII white space characters such as space, tab, newline, and return.
+#   It does not remove other space-like characters like hard space (Unicode U+00A0). (Tip, `/^[[:space:]]/` regular expression
+#   matches all space-like characters).
+# * For an `Iterable[Variant[String, Numeric]]` (for example an `Array`) each value is processed and the conversion is not recursive.
+# * If the value is `Numeric` it is simply returned (this is for backwards compatibility).
+# * An error is raised for all other data types.
+#
+# @example Removing leading and trailing space from a String
+# ```puppet
+# " hello\n\t".strip()
+# strip(" hello\n\t")
+# ```
+# Would both result in `"hello"`
+#
+# @example Removing trailing space from strings in an Array
+# ```puppet
+# [" hello\n\t", " hi\n\t"].strip()
+# strip([" hello\n\t", " hi\n\t"])
+# ```
+# Would both result in `['hello', 'hi']`
+#
+Puppet::Functions.create_function(:strip) do
+
+  dispatch :on_numeric do
+    param 'Numeric', :arg
+  end
+
+  dispatch :on_string do
+    param 'String', :arg
+  end
+
+  dispatch :on_iterable do
+    param 'Iterable[Variant[String, Numeric]]', :arg
+  end
+
+  # unit function - since the old implementation skipped Numeric values
+  def on_numeric(n)
+    n
+  end
+
+  def on_string(s)
+    s.strip
+  end
+
+  def on_iterable(a)
+    a.map {|x| do_strip(x) }
+  end
+
+  def do_strip(x)
+    # x can only be a String or Numeric because type constraints have been automatically applied
+    x.is_a?(String) ? x.strip : x
+  end
+end