puppet 8.3.1-x86-mingw32 → 8.5.0-x86-mingw32

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

@@ -1,105 +1,106 @@
 # frozen_string_literal: true
-Puppet::Parser::Functions::newfunction(
+
+Puppet::Parser::Functions.newfunction(
   :each,
   :type => :rvalue,
   :arity => -3,
-  :doc => <<-DOC
-Runs a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
-repeatedly using each value in a data structure, then returns the values unchanged.
-
-This function takes two mandatory arguments, in this order:
-
-1. An array or hash the function will iterate over.
-2. A lambda, which the function calls for each element in the first argument. It can
-request one or two parameters.
-
-**Example**: Using the `each` function
-
-`$data.each |$parameter| { <PUPPET CODE BLOCK> }`
-
-or
-
-`each($data) |$parameter| { <PUPPET CODE BLOCK> }`
-
-When the first argument (`$data` in the above example) is an array, Puppet passes each
-value in turn to the lambda, then returns the original values.
-
-**Example**: Using the `each` function with an array and a one-parameter lambda
-
-~~~ puppet
-# For the array $data, run a lambda that creates a resource for each item.
-$data = ["routers", "servers", "workstations"]
-$data.each |$item| {
- notify { $item:
-   message => $item
- }
-}
-# Puppet creates one resource for each of the three items in $data. Each resource is
-# named after the item's value and uses the item's value in a parameter.
-~~~
-
-When the first argument is a hash, Puppet passes each key and value pair to the lambda
-as an array in the form `[key, value]` and returns the original hash.
-
-**Example**: Using the `each` function with a hash and a one-parameter lambda
-
-~~~ puppet
-# For the hash $data, run a lambda using each item as a key-value array that creates a
-# resource for each item.
-$data = {"rtr" => "Router", "svr" => "Server", "wks" => "Workstation"}
-$data.each |$items| {
- notify { $items[0]:
-   message => $items[1]
- }
-}
-# Puppet creates one resource for each of the three items in $data, each named after the
-# item's key and containing a parameter using the item's value.
-~~~
-
-When the first argument is an array and the lambda has two parameters, Puppet passes the
-array's indexes (enumerated from 0) in the first parameter and its values in the second
-parameter.
-
-**Example**: Using the `each` function with an array and a two-parameter lambda
-
-~~~ puppet
-# For the array $data, run a lambda using each item's index and value that creates a
-# resource for each item.
-$data = ["routers", "servers", "workstations"]
-$data.each |$index, $value| {
- notify { $value:
-   message => $index
- }
-}
-# Puppet creates one resource for each of the three items in $data, each named after the
-# item's value and containing a parameter using the item's index.
-~~~
-
-When the first argument is a hash, Puppet passes its keys to the first parameter and its
-values to the second parameter.
-
-**Example**: Using the `each` function with a hash and a two-parameter lambda
-
-~~~ puppet
-# For the hash $data, run a lambda using each item's key and value to create a resource
-# for each item.
-$data = {"rtr" => "Router", "svr" => "Server", "wks" => "Workstation"}
-$data.each |$key, $value| {
- notify { $key:
-   message => $value
- }
-}
-# Puppet creates one resource for each of the three items in $data, each named after the
-# item's key and containing a parameter using the item's value.
-~~~
-
-For an example that demonstrates how to create multiple `file` resources using `each`,
-see the Puppet
-[iteration](https://puppet.com/docs/puppet/latest/lang_iteration.html)
-documentation.
-
-- Since 4.0.0
-DOC
-) do |args|
+  :doc => <<~DOC
+    Runs a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
+    repeatedly using each value in a data structure, then returns the values unchanged.
+
+    This function takes two mandatory arguments, in this order:
+
+    1. An array or hash the function will iterate over.
+    2. A lambda, which the function calls for each element in the first argument. It can
+    request one or two parameters.
+
+    **Example**: Using the `each` function
+
+    `$data.each |$parameter| { <PUPPET CODE BLOCK> }`
+
+    or
+
+    `each($data) |$parameter| { <PUPPET CODE BLOCK> }`
+
+    When the first argument (`$data` in the above example) is an array, Puppet passes each
+    value in turn to the lambda, then returns the original values.
+
+    **Example**: Using the `each` function with an array and a one-parameter lambda
+
+    ~~~ puppet
+    # For the array $data, run a lambda that creates a resource for each item.
+    $data = ["routers", "servers", "workstations"]
+    $data.each |$item| {
+     notify { $item:
+       message => $item
+     }
+    }
+    # Puppet creates one resource for each of the three items in $data. Each resource is
+    # named after the item's value and uses the item's value in a parameter.
+    ~~~
+
+    When the first argument is a hash, Puppet passes each key and value pair to the lambda
+    as an array in the form `[key, value]` and returns the original hash.
+
+    **Example**: Using the `each` function with a hash and a one-parameter lambda
+
+    ~~~ puppet
+    # For the hash $data, run a lambda using each item as a key-value array that creates a
+    # resource for each item.
+    $data = {"rtr" => "Router", "svr" => "Server", "wks" => "Workstation"}
+    $data.each |$items| {
+     notify { $items[0]:
+       message => $items[1]
+     }
+    }
+    # Puppet creates one resource for each of the three items in $data, each named after the
+    # item's key and containing a parameter using the item's value.
+    ~~~
+
+    When the first argument is an array and the lambda has two parameters, Puppet passes the
+    array's indexes (enumerated from 0) in the first parameter and its values in the second
+    parameter.
+
+    **Example**: Using the `each` function with an array and a two-parameter lambda
+
+    ~~~ puppet
+    # For the array $data, run a lambda using each item's index and value that creates a
+    # resource for each item.
+    $data = ["routers", "servers", "workstations"]
+    $data.each |$index, $value| {
+     notify { $value:
+       message => $index
+     }
+    }
+    # Puppet creates one resource for each of the three items in $data, each named after the
+    # item's value and containing a parameter using the item's index.
+    ~~~
+
+    When the first argument is a hash, Puppet passes its keys to the first parameter and its
+    values to the second parameter.
+
+    **Example**: Using the `each` function with a hash and a two-parameter lambda
+
+    ~~~ puppet
+    # For the hash $data, run a lambda using each item's key and value to create a resource
+    # for each item.
+    $data = {"rtr" => "Router", "svr" => "Server", "wks" => "Workstation"}
+    $data.each |$key, $value| {
+     notify { $key:
+       message => $value
+     }
+    }
+    # Puppet creates one resource for each of the three items in $data, each named after the
+    # item's key and containing a parameter using the item's value.
+    ~~~
+
+    For an example that demonstrates how to create multiple `file` resources using `each`,
+    see the Puppet
+    [iteration](https://puppet.com/docs/puppet/latest/lang_iteration.html)
+    documentation.
+
+    - Since 4.0.0
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('each')
 end

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-Puppet::Parser::Functions::newfunction(:epp, :type => :rvalue, :arity => -2, :doc =>
+
+Puppet::Parser::Functions.newfunction(:epp, :type => :rvalue, :arity => -2, :doc =>
 "Evaluates an Embedded Puppet (EPP) template file and returns the rendered text
 result as a String.
 
@@ -34,7 +35,6 @@ Parameters are required only if they are declared in the called template's
 parameter tag without default values. Puppet produces an error if the `epp`
 function fails to pass any required parameter.
 
-- Since 4.0.0") do |args|
-
+- Since 4.0.0") do |_args|
   Puppet::Parser::Functions::Error.is4x('epp')
 end

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

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
-Puppet::Parser::Functions::newfunction(
-    :fail,
-    :arity => -1,
-    :doc   => <<DOC
-Fail with a parse error. Any parameters will be stringified,
-concatenated, and passed to the exception-handler.
-DOC
+
+Puppet::Parser::Functions.newfunction(
+  :fail,
+  :arity => -1,
+  :doc => <<~DOC
+    Fail with a parse error. Any parameters will be stringified,
+    concatenated, and passed to the exception-handler.
+  DOC
 ) do |vals|
-    vals = vals.collect { |s| s.to_s }.join(" ") if vals.is_a? Array
-    raise Puppet::ParseError, vals.to_s
+  vals = vals.collect { |s| s.to_s }.join(" ") if vals.is_a? Array
+  raise Puppet::ParseError, vals.to_s
 end

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

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/file_system'
 
-Puppet::Parser::Functions::newfunction(
+Puppet::Parser::Functions.newfunction(
   :file, :arity => -2, :type => :rvalue,
-  :doc => "Loads a file from a module and returns its contents as a string.
+         :doc => "Loads a file from a module and returns its contents as a string.
 
   The argument to this function should be a `<MODULE NAME>/<FILE>`
   reference, which will load `<FILE>` from a module's `files`
@@ -17,18 +18,18 @@ Puppet::Parser::Functions::newfunction(
   found, skipping any files that don't exist.
   "
 ) do |vals|
-    path = nil
-    vals.each do |file|
-      found = Puppet::Parser::Files.find_file(file, compiler.environment)
-      if found && Puppet::FileSystem.exist?(found)
-        path = found
-        break
-      end
+  path = nil
+  vals.each do |file|
+    found = Puppet::Parser::Files.find_file(file, compiler.environment)
+    if found && Puppet::FileSystem.exist?(found)
+      path = found
+      break
     end
+  end
 
-    if path
-      Puppet::FileSystem.read_preserve_line_endings(path)
-    else
-      raise Puppet::ParseError, _("Could not find any files from %{values}") % { values: vals.join(", ") }
-    end
+  if path
+    Puppet::FileSystem.read_preserve_line_endings(path)
+  else
+    raise Puppet::ParseError, _("Could not find any files from %{values}") % { values: vals.join(", ") }
+  end
 end

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

@@ -1,80 +1,81 @@
 # frozen_string_literal: true
-Puppet::Parser::Functions::newfunction(
+
+Puppet::Parser::Functions.newfunction(
   :filter,
   :type => :rvalue,
   :arity => -3,
-  :doc => <<-DOC
-Applies a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
-to every value in a data structure and returns an array or hash containing any elements
-for which the lambda evaluates to a truthy value (not `false` or `undef`).
+  :doc => <<~DOC
+    Applies a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
+    to every value in a data structure and returns an array or hash containing any elements
+    for which the lambda evaluates to a truthy value (not `false` or `undef`).
 
-This function takes two mandatory arguments, in this order:
+    This function takes two mandatory arguments, in this order:
 
-1. An array or hash the function will iterate over.
-2. A lambda, which the function calls for each element in the first argument. It can
-request one or two parameters.
+    1. An array or hash the function will iterate over.
+    2. A lambda, which the function calls for each element in the first argument. It can
+    request one or two parameters.
 
-**Example**: Using the `filter` function
+    **Example**: Using the `filter` function
 
-`$filtered_data = $data.filter |$parameter| { <PUPPET CODE BLOCK> }`
+    `$filtered_data = $data.filter |$parameter| { <PUPPET CODE BLOCK> }`
 
-or
+    or
 
-`$filtered_data = filter($data) |$parameter| { <PUPPET CODE BLOCK> }`
+    `$filtered_data = filter($data) |$parameter| { <PUPPET CODE BLOCK> }`
 
-When the first argument (`$data` in the above example) is an array, Puppet passes each
-value in turn to the lambda and returns an array containing the results.
+    When the first argument (`$data` in the above example) is an array, Puppet passes each
+    value in turn to the lambda and returns an array containing the results.
 
-**Example**: Using the `filter` function with an array and a one-parameter lambda
+    **Example**: Using the `filter` function with an array and a one-parameter lambda
 
-~~~ puppet
-# For the array $data, return an array containing the values that end with "berry"
-$data = ["orange", "blueberry", "raspberry"]
-$filtered_data = $data.filter |$items| { $items =~ /berry$/ }
-# $filtered_data = [blueberry, raspberry]
-~~~
+    ~~~ puppet
+    # For the array $data, return an array containing the values that end with "berry"
+    $data = ["orange", "blueberry", "raspberry"]
+    $filtered_data = $data.filter |$items| { $items =~ /berry$/ }
+    # $filtered_data = [blueberry, raspberry]
+    ~~~
 
-When the first argument is a hash, Puppet passes each key and value pair to the lambda
-as an array in the form `[key, value]` and returns a hash containing the results.
+    When the first argument is a hash, Puppet passes each key and value pair to the lambda
+    as an array in the form `[key, value]` and returns a hash containing the results.
 
-**Example**: Using the `filter` function with a hash and a one-parameter lambda
+    **Example**: Using the `filter` function with a hash and a one-parameter lambda
 
-~~~ puppet
-# For the hash $data, return a hash containing all values of keys that end with "berry"
-$data = { "orange" => 0, "blueberry" => 1, "raspberry" => 2 }
-$filtered_data = $data.filter |$items| { $items[0] =~ /berry$/ }
-# $filtered_data = {blueberry => 1, raspberry => 2}
-~~~
+    ~~~ puppet
+    # For the hash $data, return a hash containing all values of keys that end with "berry"
+    $data = { "orange" => 0, "blueberry" => 1, "raspberry" => 2 }
+    $filtered_data = $data.filter |$items| { $items[0] =~ /berry$/ }
+    # $filtered_data = {blueberry => 1, raspberry => 2}
+    ~~~
 
-When the first argument is an array and the lambda has two parameters, Puppet passes the
-array's indexes (enumerated from 0) in the first parameter and its values in the second
-parameter.
+    When the first argument is an array and the lambda has two parameters, Puppet passes the
+    array's indexes (enumerated from 0) in the first parameter and its values in the second
+    parameter.
 
-**Example**: Using the `filter` function with an array and a two-parameter lambda
+    **Example**: Using the `filter` function with an array and a two-parameter lambda
 
-~~~ puppet
-# For the array $data, return an array of all keys that both end with "berry" and have
-# an even-numbered index
-$data = ["orange", "blueberry", "raspberry"]
-$filtered_data = $data.filter |$indexes, $values| { $indexes % 2 == 0 and $values =~ /berry$/ }
-# $filtered_data = [raspberry]
-~~~
+    ~~~ puppet
+    # For the array $data, return an array of all keys that both end with "berry" and have
+    # an even-numbered index
+    $data = ["orange", "blueberry", "raspberry"]
+    $filtered_data = $data.filter |$indexes, $values| { $indexes % 2 == 0 and $values =~ /berry$/ }
+    # $filtered_data = [raspberry]
+    ~~~
 
-When the first argument is a hash, Puppet passes its keys to the first parameter and its
-values to the second parameter.
+    When the first argument is a hash, Puppet passes its keys to the first parameter and its
+    values to the second parameter.
 
-**Example**: Using the `filter` function with a hash and a two-parameter lambda
+    **Example**: Using the `filter` function with a hash and a two-parameter lambda
 
-~~~ puppet
-# For the hash $data, return a hash of all keys that both end with "berry" and have
-# values less than or equal to 1
-$data = { "orange" => 0, "blueberry" => 1, "raspberry" => 2 }
-$filtered_data = $data.filter |$keys, $values| { $keys =~ /berry$/ and $values <= 1 }
-# $filtered_data = {blueberry => 1}
-~~~
+    ~~~ puppet
+    # For the hash $data, return a hash of all keys that both end with "berry" and have
+    # values less than or equal to 1
+    $data = { "orange" => 0, "blueberry" => 1, "raspberry" => 2 }
+    $filtered_data = $data.filter |$keys, $values| { $keys =~ /berry$/ and $values <= 1 }
+    # $filtered_data = {blueberry => 1}
+    ~~~
 
-- Since 4.0.0
-DOC
-) do |args|
+    - Since 4.0.0
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('filter')
 end

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

@@ -1,29 +1,29 @@
 # frozen_string_literal: true
-Puppet::Parser::Functions::newfunction(
+
+Puppet::Parser::Functions.newfunction(
   :find_file,
   :type => :rvalue,
   :arity => -2,
-:doc => <<-DOC
-Finds an existing file from a module and returns its path.
+  :doc => <<~DOC
+    Finds an existing file from a module and returns its path.
 
-The argument to this function should be a String as a `<MODULE NAME>/<FILE>`
-reference, which will search for `<FILE>` relative to a module's `files`
-directory. (For example, the reference `mysql/mysqltuner.pl` will search for the
-file `<MODULES DIRECTORY>/mysql/files/mysqltuner.pl`.)
+    The argument to this function should be a String as a `<MODULE NAME>/<FILE>`
+    reference, which will search for `<FILE>` relative to a module's `files`
+    directory. (For example, the reference `mysql/mysqltuner.pl` will search for the
+    file `<MODULES DIRECTORY>/mysql/files/mysqltuner.pl`.)
 
-This function can also accept:
+    This function can also accept:
 
-* An absolute String path, which will check for the existence of a file from anywhere on disk.
-* Multiple String arguments, which will return the path of the **first** file
-  found, skipping non existing files.
-* An array of string paths, which will return the path of the **first** file
-  found from the given paths in the array, skipping non existing files.
+    * An absolute String path, which will check for the existence of a file from anywhere on disk.
+    * Multiple String arguments, which will return the path of the **first** file
+      found, skipping non existing files.
+    * An array of string paths, which will return the path of the **first** file
+      found from the given paths in the array, skipping non existing files.
 
-The function returns `undef` if none of the given paths were found
+    The function returns `undef` if none of the given paths were found
 
-- since 4.8.0
-DOC
-) do |args|
+    - since 4.8.0
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('find_file')
 end
-

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

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
+
 require 'digest/md5'
 require 'digest/sha2'
 
-Puppet::Parser::Functions::newfunction(:fqdn_rand, :arity => -2, :type => :rvalue, :doc =>
+Puppet::Parser::Functions.newfunction(:fqdn_rand, :arity => -2, :type => :rvalue, :doc =>
   "Usage: `fqdn_rand(MAX, [SEED], [DOWNCASE])`. MAX is required and must be a positive
   integer; SEED is optional and may be any number or string; DOWNCASE is optional
   and should be a boolean true or false.
@@ -20,26 +21,26 @@ Puppet::Parser::Functions::newfunction(:fqdn_rand, :arity => -2, :type => :rvalu
   have more than one such task and need several unrelated random numbers per
   node. (For example, `fqdn_rand(30)`, `fqdn_rand(30, 'expensive job 1')`, and
   `fqdn_rand(30, 'expensive job 2')` will produce totally different numbers.)") do |args|
-    max = args.shift.to_i
-    initial_seed = args.shift
-    downcase = !!args.shift
-
-    fqdn = self['facts'].dig('networking', 'fqdn')
-    fqdn = fqdn.downcase if downcase
-
-    # Puppet 5.4's fqdn_rand function produces a different value than earlier versions
-    # for the same set of inputs.
-    # This causes problems because the values are often written into service configuration files.
-    # When they change, services get notified and restart.
-
-    # Restoring previous fqdn_rand behavior of calculating its seed value using MD5
-    # when running on a non-FIPS enabled platform and only using SHA256 on FIPS enabled
-    # platforms.
-    if Puppet::Util::Platform.fips_enabled?
-      seed = Digest::SHA256.hexdigest([fqdn,max,initial_seed].join(':')).hex
-    else
-      seed = Digest::MD5.hexdigest([fqdn,max,initial_seed].join(':')).hex
-    end
-
-    Puppet::Util.deterministic_rand_int(seed,max)
+  max = args.shift.to_i
+  initial_seed = args.shift
+  downcase = !!args.shift
+
+  fqdn = self['facts'].dig('networking', 'fqdn')
+  fqdn = fqdn.downcase if downcase
+
+  # Puppet 5.4's fqdn_rand function produces a different value than earlier versions
+  # for the same set of inputs.
+  # This causes problems because the values are often written into service configuration files.
+  # When they change, services get notified and restart.
+
+  # Restoring previous fqdn_rand behavior of calculating its seed value using MD5
+  # when running on a non-FIPS enabled platform and only using SHA256 on FIPS enabled
+  # platforms.
+  if Puppet::Util::Platform.fips_enabled?
+    seed = Digest::SHA256.hexdigest([fqdn, max, initial_seed].join(':')).hex
+  else
+    seed = Digest::MD5.hexdigest([fqdn, max, initial_seed].join(':')).hex
+  end
+
+  Puppet::Util.deterministic_rand_int(seed, max)
 end

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

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
+
 # Runs an external command and returns the results
-Puppet::Parser::Functions::newfunction(:generate, :arity => -2, :type => :rvalue,
-    :doc => "Calls an external command on the Puppet master and returns
+Puppet::Parser::Functions.newfunction(:generate, :arity => -2, :type => :rvalue,
+                                                 :doc => "Calls an external command on the Puppet master and returns
     the results of the command. Any arguments are passed to the external command as
     arguments. If the generator does not exit with return code of 0,
     the generator is considered to have failed and a parse error is
@@ -12,27 +13,26 @@ Puppet::Parser::Functions::newfunction(:generate, :arity => -2, :type => :rvalue
     generators, so all shell metacharacters are passed directly to
     the generator, and all metacharacters are returned by the function.
     Consider cleaning white space from any string generated.") do |args|
+  # TRANSLATORS "fully qualified" refers to a fully qualified file system path
+  raise Puppet::ParseError, _("Generators must be fully qualified") unless Puppet::Util.absolute_path?(args[0])
 
-      #TRANSLATORS "fully qualified" refers to a fully qualified file system path
-      raise Puppet::ParseError, _("Generators must be fully qualified") unless Puppet::Util.absolute_path?(args[0])
-
-      if Puppet::Util::Platform.windows?
-        valid = args[0] =~ /^[a-z]:(?:[\/\\][-.~\w]+)+$/i
-      else
-        valid = args[0] =~ /^[-\/\w.+]+$/
-      end
+  if Puppet::Util::Platform.windows?
+    valid = args[0] =~ /^[a-z]:(?:[\/\\][-.~\w]+)+$/i
+  else
+    valid = args[0] =~ /^[-\/\w.+]+$/
+  end
 
-      unless valid
-        raise Puppet::ParseError, _("Generators can only contain alphanumerics, file separators, and dashes")
-      end
+  unless valid
+    raise Puppet::ParseError, _("Generators can only contain alphanumerics, file separators, and dashes")
+  end
 
-      if args[0] =~ /\.\./
-        raise Puppet::ParseError, _("Can not use generators with '..' in them.")
-      end
+  if args[0] =~ /\.\./
+    raise Puppet::ParseError, _("Can not use generators with '..' in them.")
+  end
 
-      begin
-        Dir.chdir(File.dirname(args[0])) { Puppet::Util::Execution.execute(args).to_str }
-      rescue Puppet::ExecutionFailure => detail
-        raise Puppet::ParseError, _("Failed to execute generator %{generator}: %{detail}") % { generator: args[0], detail: detail }, detail.backtrace
-      end
+  begin
+    Dir.chdir(File.dirname(args[0])) { Puppet::Util::Execution.execute(args).to_str }
+  rescue Puppet::ExecutionFailure => detail
+    raise Puppet::ParseError, _("Failed to execute generator %{generator}: %{detail}") % { generator: args[0], detail: detail }, detail.backtrace
+  end
 end