puppet 6.0.5-x64-mingw32 → 8.8.1-x64-mingw32

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

@@ -1,5 +1,7 @@
-require 'puppet/util/checksums'
-Puppet::Parser::Functions::newfunction(:digest, :type => :rvalue, :arity => 1, :doc => "Returns a hash value from a provided string using the digest_algorithm setting from the Puppet config file.") do |args|
+# frozen_string_literal: true
+
+require_relative '../../../puppet/util/checksums'
+Puppet::Parser::Functions.newfunction(:digest, :type => :rvalue, :arity => 1, :doc => "Returns a hash value from a provided string using the digest_algorithm setting from the Puppet config file.") do |args|
   algo = Puppet[:digest_algorithm]
   Puppet::Util::Checksums.method(algo.intern).call args[0]
 end

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

@@ -1,104 +1,106 @@
-Puppet::Parser::Functions::newfunction(
+# frozen_string_literal: true
+
+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,4 +1,6 @@
-Puppet::Parser::Functions::newfunction(:epp, :type => :rvalue, :arity => -2, :doc =>
+# frozen_string_literal: true
+
+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.
 
@@ -7,12 +9,12 @@ result as a String.
 The first argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
 reference, which loads `<TEMPLATE FILE>` from `<MODULE NAME>`'s `templates`
 directory. In most cases, the last argument is optional; if used, it should be a
-[hash](/puppet/latest/reference/lang_data_hash.html) that contains parameters to
+[hash](https://puppet.com/docs/puppet/latest/lang_data_hash.html) that contains parameters to
 pass to the template.
 
-- See the [template](/puppet/latest/reference/lang_template.html) documentation
+- See the [template](https://puppet.com/docs/puppet/latest/lang_template.html) documentation
 for general template usage information.
-- See the [EPP syntax](/puppet/latest/reference/lang_template_epp.html)
+- See the [EPP syntax](https://puppet.com/docs/puppet/latest/lang_template_epp.html)
 documentation for examples of EPP.
 
 For example, to call the apache module's `templates/vhost/_docroot.epp`
@@ -33,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,4 +1,13 @@
-Puppet::Parser::Functions::newfunction(:fail, :arity => -1, :doc => "Fail with a parse error.") do |vals|
-    vals = vals.collect { |s| s.to_s }.join(" ") if vals.is_a? Array
-    raise Puppet::ParseError, vals.to_s
+# 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
+) do |vals|
+  vals = vals.collect(&:to_s).join(" ") if vals.is_a? Array
+  raise Puppet::ParseError, vals.to_s
 end

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

@@ -1,8 +1,10 @@
-require 'puppet/file_system'
+# frozen_string_literal: true
 
-Puppet::Parser::Functions::newfunction(
+require_relative '../../../puppet/file_system'
+
+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`
@@ -16,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,78 +1,81 @@
-Puppet::Parser::Functions::newfunction(
+# frozen_string_literal: true
+
+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,28 +1,29 @@
-Puppet::Parser::Functions::newfunction(
+# frozen_string_literal: true
+
+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,14 +1,19 @@
+# frozen_string_literal: true
+
 require 'digest/md5'
 require 'digest/sha2'
 
-Puppet::Parser::Functions::newfunction(:fqdn_rand, :arity => -2, :type => :rvalue, :doc =>
-  "Usage: `fqdn_rand(MAX, [SEED])`. MAX is required and must be a positive
-  integer; SEED is optional and may be any number or string.
+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.
 
   Generates a random Integer number greater than or equal to 0 and less than MAX,
   combining the `$fqdn` fact and the value of SEED for repeatable randomness.
   (That is, each node will get a different random number from this function, but
-  a given node's result will be the same every time unless its hostname changes.)
+  a given node's result will be the same every time unless its hostname changes.) If
+  DOWNCASE is true, then the `fqdn` fact will be downcased when computing the value
+  so that the result is not sensitive to the case of the `fqdn` fact.
 
   This function is usually used for spacing out runs of resource-intensive cron
   tasks that run on many nodes, which could cause a thundering herd or degrade
@@ -16,21 +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
- 
-    # 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([self['::fqdn'],max,args].join(':')).hex
-    else
-      seed = Digest::MD5.hexdigest([self['::fqdn'],max,args].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,36 +1,39 @@
+# 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
-    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,
+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
-    thrown.  Generators can only have file separators, alphanumerics, dashes,
-    and periods in them.  This function will attempt to protect you from
+    thrown. Generators can only have file separators, alphanumerics, dashes,
+    and periods in them. This function will attempt to protect you from
     malicious generator calls (e.g., those with '..' in them), but it can
-    never be entirely safe.  No subshell is used to execute
+    never be entirely safe. No subshell is used to execute
     generators, so all shell metacharacters are passed directly to
-    the generator.") 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])
+    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])
 
-      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] =~ %r{^[a-z]:(?:[/\\][-.~\w]+)+$}i
+  else
+    valid = args[0] =~ %r{^[-/\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 = File.dirname(args[0])
+    Puppet::Util::Execution.execute(args, failonfail: true, combine: true, cwd: dir).to_str
+  rescue Puppet::ExecutionFailure => detail
+    raise Puppet::ParseError, _("Failed to execute generator %{generator}: %{detail}") % { generator: args[0], detail: detail }, detail.backtrace
+  end
 end