openvox 7.37.1 → 8.19.0

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

@@ -1,83 +1,85 @@
-Puppet::Parser::Functions::newfunction(
+# 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.
+  :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:
+    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.
+    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
+    **Example:** Using the `reverse_each` function
 
-```puppet
-$data.reverse_each |$parameter| { <PUPPET CODE BLOCK> }
-```
+    ```puppet
+    $data.reverse_each |$parameter| { <PUPPET CODE BLOCK> }
+    ```
 
-or
+    or
 
-```puppet
-$reverse_data = $data.reverse_each
-```
+    ```puppet
+    $reverse_data = $data.reverse_each
+    ```
 
-or
+    or
 
-```puppet
-reverse_each($data) |$parameter| { <PUPPET CODE BLOCK> }
-```
+    ```puppet
+    reverse_each($data) |$parameter| { <PUPPET CODE BLOCK> }
+    ```
 
-or
+    or
 
-```puppet
-$reverse_data = reverse_each($data)
-```
+    ```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 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`.
+    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
+    **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) }
-```
+    ``` 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.
+    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.
+    **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]
-```
+    ```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
+    **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]
-```
+    ```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
+    * Since 4.4.0
 
-DOC
-) do |args|
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('reverse_each')
 end

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

@@ -1,36 +1,38 @@
+# frozen_string_literal: true
+
 require 'scanf'
 
-Puppet::Parser::Functions::newfunction(
+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.)
+  :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.
+    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")
-```
+    ```puppet
+    "42".scanf("%i")
+    ```
 
-You can also optionally pass a lambda to scanf, to do additional validation or processing.
+    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]
-}
-```
+    ```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
+    - Since 4.0.0
+  DOC
 ) do |args|
   data = args[0]
   format = args[1]

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

@@ -1,5 +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])
+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])
 end

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

@@ -1,5 +1,7 @@
+# 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|
+Puppet::Parser::Functions.newfunction(:sha256, :type => :rvalue, :arity => 1, :doc => "Returns a SHA256 hash value from a provided string.") do |args|
   Digest::SHA256.hexdigest(args[0])
 end

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

@@ -1,3 +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,39 +1,41 @@
-Puppet::Parser::Functions::newfunction(
+# 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.
+  :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.
+    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}" }
+        $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.
+    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]]
+        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.
+    You can also optionally pass a lambda to slice.
 
-    $a.slice($n) |$x| { ... }
-    slice($a) |$x| { ... }
+        $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.
+    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| { ... }
+        $a.slice(2) |$first, $second| { ... }
 
-- Since 4.0.0
-DOC
-) do |args|
+    - Since 4.0.0
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('slice')
 end

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

@@ -1,10 +1,11 @@
-module Puppet::Parser::Functions
+# frozen_string_literal: true
 
+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:*
@@ -21,8 +22,8 @@ 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,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright (C) 2009 Thomas Bellman
 #
 # Permission is hereby granted, free of charge, to any person obtaining
@@ -24,15 +26,15 @@
 # other dealings in this Software without prior written authorization
 # from Thomas Bellman.
 
-Puppet::Parser::Functions::newfunction(
+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)
   in Ruby for details.
-  
+
   To use [named format](https://idiosyncratic-ruby.com/49-what-the-format.html) arguments, provide a
   hash containing the target string values as the argument to be formatted. For example:
 
@@ -41,10 +43,9 @@ Puppet::Parser::Functions::newfunction(
   ```
 
   This statement produces a notice of `value is : 42`."
-
 ) do |args|
   fmt = args[0]
-  args = args[1..-1]
+  args = args[1..]
   begin
     return sprintf(fmt, *args)
   rescue KeyError => e
@@ -53,7 +54,7 @@ Puppet::Parser::Functions::newfunction(
       # as that allows named arguments to be used in the format string.
       #
       result = {}
-      args[0].each_pair { |k,v| result[k.is_a?(String) ? k.to_sym : k] = v }
+      args[0].each_pair { |k, v| result[k.is_a?(String) ? k.to_sym : k] = v }
       return sprintf(fmt, result)
     end
     raise e

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

@@ -1,84 +1,86 @@
-Puppet::Parser::Functions::newfunction(
+# 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.
+  :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:
+    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.
+    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
+    **Example:** Using the `step` function
 
-```puppet
-$data.step(<n>) |$parameter| { <PUPPET CODE BLOCK> }
-```
+    ```puppet
+    $data.step(<n>) |$parameter| { <PUPPET CODE BLOCK> }
+    ```
 
-or
+    or
 
-```puppet
-$stepped_data = $data.step(<n>)
-```
+    ```puppet
+    $stepped_data = $data.step(<n>)
+    ```
 
-or
-```puppet
-step($data, <n>) |$parameter| { <PUPPET CODE BLOCK> }
-```
+    or
+    ```puppet
+    step($data, <n>) |$parameter| { <PUPPET CODE BLOCK> }
+    ```
 
-or
+    or
 
-```puppet
-$stepped_data = step($data, <n>)
-```
+    ```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`.
+    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
+    **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'.
-```
+    ```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.
+    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.
+    **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]
-```
+    ```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
+    **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]
-```
+    ```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
+    * Since 4.4.0
 
-DOC
-) do |args|
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('step')
 end