puppet 8.2.0-universal-darwin → 8.4.0-universal-darwin

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

@@ -1,84 +1,85 @@
 # frozen_string_literal: true
+
 Puppet::Parser::Functions::newfunction(
   :reverse_each,
   :type => :rvalue,
   :arity => -1,
-  :doc => <<-DOC
-Reverses the order of the elements of something that is iterable and optionally runs a
-[lambda](https://puppet.com/docs/puppet/latest/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
-
-DOC
-) do |args|
+  :doc => <<~DOC
+    Reverses the order of the elements of something that is iterable and optionally runs a
+    [lambda](https://puppet.com/docs/puppet/latest/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
+    
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('reverse_each')
 end

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

@@ -1,37 +1,38 @@
 # frozen_string_literal: true
+
 require 'scanf'
 
 Puppet::Parser::Functions::newfunction(
   :scanf,
   :type => :rvalue,
   :arity => 2,
-  :doc => <<-DOC
-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.
-
-```puppet
-"42".scanf("%i")
-```
-
-You can also optionally pass a lambda to scanf, to do additional validation or processing.
-
-```puppet
-"42".scanf("%i") |$x| {
-  unless $x[0] =~ Integer {
-    fail "Expected a well formed integer value, got '$x[0]'"
-  }
-  $x[0]
-}
-```
-
-- Since 4.0.0
-DOC
+  :doc => <<~DOC
+    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.
+    
+    ```puppet
+    "42".scanf("%i")
+    ```
+    
+    You can also optionally pass a lambda to scanf, to do additional validation or processing.
+    
+    ```puppet
+    "42".scanf("%i") |$x| {
+      unless $x[0] =~ Integer {
+        fail "Expected a well formed integer value, got '$x[0]'"
+      }
+      $x[0]
+    }
+    ```
+    
+    - Since 4.0.0
+  DOC
 ) do |args|
   data = args[0]
   format = args[1]

data/lib/puppet/parser/functions/sha1.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
+
 require 'digest/sha1'
 
 Puppet::Parser::Functions::newfunction(:sha1, :type => :rvalue, :arity => 1, :doc => "Returns a SHA1 hash value from a provided string.") do |args|
-      Digest::SHA1.hexdigest(args[0])
+  Digest::SHA1.hexdigest(args[0])
 end

data/lib/puppet/parser/functions/sha256.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'digest/sha2'
 
 Puppet::Parser::Functions::newfunction(:sha256, :type => :rvalue, :arity => 1, :doc => "Returns a SHA256 hash value from a provided string.") do |args|

data/lib/puppet/parser/functions/shellquote.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Copyright (C) 2009 Thomas Bellman
 #
 # Permission is hereby granted, free of charge, to any person obtaining

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

@@ -1,40 +1,41 @@
 # frozen_string_literal: true
+
 Puppet::Parser::Functions::newfunction(
   :slice,
   :type => :rvalue,
   :arity => -3,
-  :doc => <<-DOC
-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.
-
-    $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.
-
-    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]]
-
-You can also optionally pass a lambda to slice.
-
-    $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.
-
-    $a.slice(2) |$first, $second| { ... }
-
-- Since 4.0.0
-DOC
-) do |args|
+  :doc => <<~DOC
+    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.
+    
+        $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.
+    
+        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]]
+    
+    You can also optionally pass a lambda to slice.
+    
+        $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.
+    
+        $a.slice(2) |$first, $second| { ... }
+    
+    - Since 4.0.0
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('slice')
 end

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
-module Puppet::Parser::Functions
 
+module Puppet::Parser::Functions
   newfunction(
-  :split, :type => :rvalue,
-  :arity => 2,
+    :split, :type => :rvalue,
+            :arity => 2,
 
-    :doc => "\
+            :doc => "\
 Split a string variable into an array using the specified split regexp.
 
 *Example:*
@@ -22,8 +22,7 @@ while `$array_var2` holds `['v1', 'v2:v3', 'v4']`, and
 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.") do |args|
-
+brackets; a backslash will also escape a single character.") do |_args|
     Error.is4x('split')
   end
 end

data/lib/puppet/parser/functions/sprintf.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Copyright (C) 2009 Thomas Bellman
 #
 # Permission is hereby granted, free of charge, to any person obtaining
@@ -27,8 +28,8 @@
 
 Puppet::Parser::Functions::newfunction(
   :sprintf, :type => :rvalue,
-  :arity => -2,
-  :doc => "Perform printf-style formatting of text.
+            :arity => -2,
+            :doc => "Perform printf-style formatting of text.
 
   The first parameter is format string describing how the rest of the parameters should be formatted.
   See the documentation for the [`Kernel::sprintf` function](https://ruby-doc.org/core/Kernel.html)
@@ -42,7 +43,6 @@ Puppet::Parser::Functions::newfunction(
   ```
 
   This statement produces a notice of `value is : 42`."
-
 ) do |args|
   fmt = args[0]
   args = args[1..-1]

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

@@ -1,85 +1,86 @@
 # frozen_string_literal: true
+
 Puppet::Parser::Functions::newfunction(
   :step,
   :type => :rvalue,
   :arity => -1,
-  :doc => <<-DOC
-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
-
-DOC
-) do |args|
+  :doc => <<~DOC
+    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
+    
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('step')
 end