puppet 8.4.0-universal-darwin → 8.5.1-universal-darwin

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

@@ -10,9 +10,9 @@ module Puppet::Parser::Functions
     :doc => <<~DOC
       Performs a standard priority lookup of the hierarchy and returns the most specific value
       for a given key. The returned value can be any type of data.
-      
+
       The function takes up to three arguments, in this order:
-      
+
       1. A string key that Hiera searches for in the hierarchy. **Required**.
       2. An optional default value to return if Hiera doesn't find anything matching the key.
           * If this argument isn't provided and this function results in a lookup failure, Puppet
@@ -22,24 +22,24 @@ module Puppet::Parser::Functions
       top of the hierarchy. This lets you temporarily modify the hierarchy for a single lookup.
           * If Hiera doesn't find a matching key in the overriding hierarchy level, it continues
           searching the rest of the hierarchy.
-      
+
       The `hiera` function does **not** find all matches throughout a hierarchy, instead
       returining the first specific value starting at the top of the hierarchy. To search
       throughout a hierarchy, use the `hiera_array` or `hiera_hash` functions.
-      
+
       **Example**: Using `hiera`
-      
+
       ~~~ yaml
       # Assuming hiera.yaml
       # :hierarchy:
       #   - web01.example.com
       #   - common
-      
+
       # Assuming web01.example.com.yaml:
       # users:
       #   - "Amy Barry"
       #   - "Carrie Douglas"
-      
+
       # Assuming common.yaml:
       users:
         admins:
@@ -49,54 +49,54 @@ module Puppet::Parser::Functions
           - "Iris Jackson"
           - "Kelly Lambert"
       ~~~
-      
+
       ~~~ puppet
       # Assuming we are not web01.example.com:
-      
+
       $users = hiera('users', undef)
-      
+
       # $users contains {admins  => ["Edith Franklin", "Ginny Hamilton"],
       #                  regular => ["Iris Jackson", "Kelly Lambert"]}
       ~~~
-      
+
       You can optionally generate the default value with a
       [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) that
       takes one parameter.
-      
+
       **Example**: Using `hiera` with a lambda
-      
+
       ~~~ puppet
       # Assuming the same Hiera data as the previous example:
-      
+
       $users = hiera('users') | $key | { "Key \'${key}\' not found" }
-      
+
       # $users contains {admins  => ["Edith Franklin", "Ginny Hamilton"],
       #                  regular => ["Iris Jackson", "Kelly Lambert"]}
       # If hiera couldn't match its key, it would return the lambda result,
       # "Key 'users' not found".
       ~~~
-      
+
       The returned value's data type depends on the types of the results. In the example
       above, Hiera matches the 'users' key and returns it as a hash.
-      
+
       The `hiera` function is deprecated in favor of using `lookup` and will be removed in 6.0.0.
       See https://puppet.com/docs/puppet/#{Puppet.minor_version}/deprecated_language.html.
       Replace the calls as follows:
-      
+
       | from  | to |
       | ----  | ---|
       | hiera($key) | lookup($key) |
       | hiera($key, $default) | lookup($key, { 'default_value' => $default }) |
       | hiera($key, $default, $level) | override level not supported |
-      
+
       Note that calls using the 'override level' option are not directly supported by 'lookup' and the produced
       result must be post processed to get exactly the same result, for example using simple hash/array `+` or
       with calls to stdlib's `deep_merge` function depending on kind of hiera call and setting of merge in hiera.yaml.
-      
+
       See
       [the documentation](https://puppet.com/docs/hiera/latest/puppet.html#hiera-lookup-functions)
       for more information about Hiera lookup functions.
-      
+
       - Since 4.0.0
     DOC
   ) do |*_args|

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

@@ -12,9 +12,9 @@ module Puppet::Parser::Functions
       array of unique values. If any of the matched values are arrays, they're flattened and
       included in the results. This is called an
       [array merge lookup](https://puppet.com/docs/hiera/latest/lookup_types.html#array-merge).
-      
+
       The `hiera_array` function takes up to three arguments, in this order:
-      
+
       1. A string key that Hiera searches for in the hierarchy. **Required**.
       2. An optional default value to return if Hiera doesn't find anything matching the key.
           * If this argument isn't provided and this function results in a lookup failure, Puppet
@@ -24,71 +24,70 @@ module Puppet::Parser::Functions
       top of the hierarchy. This lets you temporarily modify the hierarchy for a single lookup.
           * If Hiera doesn't find a matching key in the overriding hierarchy level, it continues
           searching the rest of the hierarchy.
-      
+
       **Example**: Using `hiera_array`
-      
+
       ~~~ yaml
       # Assuming hiera.yaml
       # :hierarchy:
       #   - web01.example.com
       #   - common
-      
+
       # Assuming common.yaml:
       # users:
       #   - 'cdouglas = regular'
       #   - 'efranklin = regular'
-      
+
       # Assuming web01.example.com.yaml:
       # users: 'abarry = admin'
       ~~~
-      
+
       ~~~ puppet
       $allusers = hiera_array('users', undef)
-      
+
       # $allusers contains ["cdouglas = regular", "efranklin = regular", "abarry = admin"].
       ~~~
-      
+
       You can optionally generate the default value with a
       [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) that
       takes one parameter.
-      
+
       **Example**: Using `hiera_array` with a lambda
-      
+
       ~~~ puppet
       # Assuming the same Hiera data as the previous example:
-      
+
       $allusers = hiera_array('users') | $key | { "Key \'${key}\' not found" }
-      
+
       # $allusers contains ["cdouglas = regular", "efranklin = regular", "abarry = admin"].
       # If hiera_array couldn't match its key, it would return the lambda result,
       # "Key 'users' not found".
       ~~~
-      
+
       `hiera_array` expects that all values returned will be strings or arrays. If any matched
       value is a hash, Puppet raises a type mismatch error.
-      
+
       `hiera_array` is deprecated in favor of using `lookup` and will be removed in 6.0.0.
       See https://puppet.com/docs/puppet/#{Puppet.minor_version}/deprecated_language.html.
       Replace the calls as follows:
-      
+
       | from  | to |
       | ----  | ---|
       | hiera_array($key) | lookup($key, { 'merge' => 'unique' }) |
       | hiera_array($key, $default) | lookup($key, { 'default_value' => $default, 'merge' => 'unique' }) |
       | hiera_array($key, $default, $level) | override level not supported |
-      
+
       Note that calls using the 'override level' option are not directly supported by 'lookup' and the produced
       result must be post processed to get exactly the same result, for example using simple hash/array `+` or
       with calls to stdlib's `deep_merge` function depending on kind of hiera call and setting of merge in hiera.yaml.
-      
+
       See
       [the documentation](https://puppet.com/docs/hiera/latest/puppet.html#hiera-lookup-functions)
       for more information about Hiera lookup functions.
-      
+
       - Since 4.0.0
     DOC
   ) do |*_args|
     Error.is4x('hiera_array')
   end
 end
-

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

@@ -12,13 +12,13 @@ module Puppet::Parser::Functions
       If any of the matched hashes share keys, the final hash uses the value from the
       highest priority match. This is called a
       [hash merge lookup](https://puppet.com/docs/hiera/latest/lookup_types.html#hash-merge).
-      
+
       The merge strategy is determined by Hiera's
       [`:merge_behavior`](https://puppet.com/docs/hiera/latest/configuring.html#mergebehavior)
       setting.
-      
+
       The `hiera_hash` function takes up to three arguments, in this order:
-      
+
       1. A string key that Hiera searches for in the hierarchy. **Required**.
       2. An optional default value to return if Hiera doesn't find anything matching the key.
           * If this argument isn't provided and this function results in a lookup failure, Puppet
@@ -28,77 +28,76 @@ module Puppet::Parser::Functions
       top of the hierarchy. This lets you temporarily modify the hierarchy for a single lookup.
           * If Hiera doesn't find a matching key in the overriding hierarchy level, it continues
           searching the rest of the hierarchy.
-      
+
       **Example**: Using `hiera_hash`
-      
+
       ~~~ yaml
       # Assuming hiera.yaml
       # :hierarchy:
       #   - web01.example.com
       #   - common
-      
+
       # Assuming common.yaml:
       # users:
       #   regular:
       #     'cdouglas': 'Carrie Douglas'
-      
+
       # Assuming web01.example.com.yaml:
       # users:
       #   administrators:
       #     'aberry': 'Amy Berry'
       ~~~
-      
+
       ~~~ puppet
       # Assuming we are not web01.example.com:
-      
+
       $allusers = hiera_hash('users', undef)
-      
+
       # $allusers contains {regular => {"cdouglas" => "Carrie Douglas"},
       #                     administrators => {"aberry" => "Amy Berry"}}
       ~~~
-      
+
       You can optionally generate the default value with a
       [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) that
       takes one parameter.
-      
+
       **Example**: Using `hiera_hash` with a lambda
-      
+
       ~~~ puppet
       # Assuming the same Hiera data as the previous example:
-      
+
       $allusers = hiera_hash('users') | $key | { "Key \'${key}\' not found" }
-      
+
       # $allusers contains {regular => {"cdouglas" => "Carrie Douglas"},
       #                     administrators => {"aberry" => "Amy Berry"}}
       # If hiera_hash couldn't match its key, it would return the lambda result,
       # "Key 'users' not found".
       ~~~
-      
+
       `hiera_hash` expects that all values returned will be hashes. If any of the values
       found in the data sources are strings or arrays, Puppet raises a type mismatch error.
-      
+
       `hiera_hash` is deprecated in favor of using `lookup` and will be removed in 6.0.0.
       See  https://puppet.com/docs/puppet/#{Puppet.minor_version}/deprecated_language.html.
       Replace the calls as follows:
-      
+
       | from  | to |
       | ----  | ---|
       | hiera_hash($key) | lookup($key, { 'merge' => 'hash' }) |
       | hiera_hash($key, $default) | lookup($key, { 'default_value' => $default, 'merge' => 'hash' }) |
       | hiera_hash($key, $default, $level) | override level not supported |
-      
+
       Note that calls using the 'override level' option are not directly supported by 'lookup' and the produced
       result must be post processed to get exactly the same result, for example using simple hash/array `+` or
       with calls to stdlib's `deep_merge` function depending on kind of hiera call and setting of merge in hiera.yaml.
-      
+
       See
       [the documentation](https://puppet.com/docs/hiera/latest/puppet.html#hiera-lookup-functions)
       for more information about Hiera lookup functions.
-      
+
       - Since 4.0.0
     DOC
   ) do |*_args|
     Error.is4x('hiera_hash')
   end
 end
-

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

@@ -10,18 +10,18 @@ module Puppet::Parser::Functions
       Assigns classes to a node using an
       [array merge lookup](https://puppet.com/docs/hiera/latest/lookup_types.html#array-merge)
       that retrieves the value for a user-specified key from Hiera's data.
-      
+
       The `hiera_include` function requires:
-      
+
       - A string key name to use for classes.
       - A call to this function (i.e. `hiera_include('classes')`) in your environment's
       `sites.pp` manifest, outside of any node definitions and below any top-scope variables
       that Hiera uses in lookups.
       - `classes` keys in the appropriate Hiera data sources, with an array for each
       `classes` key and each value of the array containing the name of a class.
-      
+
       The function takes up to three arguments, in this order:
-      
+
       1. A string key that Hiera searches for in the hierarchy. **Required**.
       2. An optional default value to return if Hiera doesn't find anything matching the key.
           * If this argument isn't provided and this function results in a lookup failure, Puppet
@@ -31,73 +31,72 @@ module Puppet::Parser::Functions
       top of the hierarchy. This lets you temporarily modify the hierarchy for a single lookup.
           * If Hiera doesn't find a matching key in the overriding hierarchy level, it continues
           searching the rest of the hierarchy.
-      
+
       The function uses an
       [array merge lookup](https://puppet.com/docs/hiera/latest/lookup_types.html#array-merge)
       to retrieve the `classes` array, so every node gets every class from the hierarchy.
-      
+
       **Example**: Using `hiera_include`
-      
+
       ~~~ yaml
       # Assuming hiera.yaml
       # :hierarchy:
       #   - web01.example.com
       #   - common
-      
+
       # Assuming web01.example.com.yaml:
       # classes:
       #   - apache::mod::php
-      
+
       # Assuming common.yaml:
       # classes:
       #   - apache
       ~~~
-      
+
       ~~~ puppet
       # In site.pp, outside of any node definitions and below any top-scope variables:
       hiera_include('classes', undef)
-      
+
       # Puppet assigns the apache and apache::mod::php classes to the web01.example.com node.
       ~~~
-      
+
       You can optionally generate the default value with a
       [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) that
       takes one parameter.
-      
+
       **Example**: Using `hiera_include` with a lambda
-      
+
       ~~~ puppet
       # Assuming the same Hiera data as the previous example:
-      
+
       # In site.pp, outside of any node definitions and below any top-scope variables:
       hiera_include('classes') | $key | {"Key \'${key}\' not found" }
-      
+
       # Puppet assigns the apache and apache::mod::php classes to the web01.example.com node.
       # If hiera_include couldn't match its key, it would return the lambda result,
       # "Key 'classes' not found".
       ~~~
-      
+
       `hiera_include` is deprecated in favor of using a combination of `include` and `lookup` and will be
       removed in Puppet 6.0.0. Replace the calls as follows:
-      
+
       | from  | to |
       | ----  | ---|
       | hiera_include($key) | include(lookup($key, { 'merge' => 'unique' })) |
       | hiera_include($key, $default) | include(lookup($key, { 'default_value' => $default, 'merge' => 'unique' })) |
       | hiera_include($key, $default, $level) | override level not supported |
-      
+
       See
       [the Upgrading to Hiera 5 migration guide](https://puppet.com/docs/puppet/5.5/hiera_migrate.html)
       for more information.
-      
+
       Note that calls using the 'override level' option are not directly supported by 'lookup' and the produced
       result must be post processed to get exactly the same result, for example using simple hash/array `+` or
       with calls to stdlib's `deep_merge` function depending on kind of hiera call and setting of merge in hiera.yaml.
-      
+
       - Since 4.0.0
     DOC
   ) do |*_args|
     Error.is4x('hiera_include')
   end
 end
-

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Include the specified classes
-Puppet::Parser::Functions::newfunction(:include, :arity => -2, :doc =>
+Puppet::Parser::Functions.newfunction(:include, :arity => -2, :doc =>
 "Declares one or more classes, causing the resources in them to be
 evaluated and added to the catalog. Accepts a class name, an array of class
 names, or a comma-separated list of class names.
@@ -28,7 +28,7 @@ the future parser's resource and relationship expressions.
 
 - Since < 3.0.0
 - Since 4.0.0 support for class and resource type values, absolute names
-- Since 4.7.0 returns an Array[Type[Class]] of all included classes 
+- Since 4.7.0 returns an Array[Type[Class]] of all included classes
 ") do |classes|
   call_function('include', classes)
   # TRANSLATORS "function_include", "Scope", and "Scope#call_function" refer to Puppet internals and should not be translated

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-Puppet::Parser::Functions::newfunction(:inline_epp, :type => :rvalue, :arity => -2, :doc =>
+Puppet::Parser::Functions.newfunction(:inline_epp, :type => :rvalue, :arity => -2, :doc =>
 "Evaluates an Embedded Puppet (EPP) template string and returns the rendered
 text result as a String.
 

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-Puppet::Parser::Functions::newfunction(:inline_template, :type => :rvalue, :arity => -2, :doc =>
+Puppet::Parser::Functions.newfunction(:inline_template, :type => :rvalue, :arity => -2, :doc =>
   "Evaluate a template string and return its value.  See
   [the templating docs](https://puppet.com/docs/puppet/latest/lang_template.html) for
   more information. Note that if multiple template strings are specified, their
@@ -8,7 +8,8 @@ Puppet::Parser::Functions::newfunction(:inline_template, :type => :rvalue, :arit
   if Puppet[:tasks]
     raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
       Puppet::Pops::Issues::FEATURE_NOT_SUPPORTED_WHEN_SCRIPTING,
-      {:feature => 'ERB inline_template'})
+      { :feature => 'ERB inline_template' }
+    )
   end
 
   require 'erb'

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-Puppet::Parser::Functions::newfunction(
+Puppet::Parser::Functions.newfunction(
   :lest,
   :type => :rvalue,
   :arity => -2,
@@ -9,41 +9,41 @@ Puppet::Parser::Functions::newfunction(
     (which should accept no arguments) if the argument given to the function is `undef`.
     Returns the result of calling the lambda if the argument is `undef`, otherwise the
     given argument.
-    
+
     The `lest` function is useful in a chain of `then` calls, or in general
     as a guard against `undef` values. The function can be used to call `fail`, or to
     return a default value.
-    
+
     These two expressions are equivalent:
-    
+
     ```puppet
     if $x == undef { do_things() }
     lest($x) || { do_things() }
     ```
-    
+
     **Example:** Using the `lest` function
-    
+
     ```puppet
     $data = {a => [ b, c ] }
     notice $data.dig(a, b, c)
      .then |$x| { $x * 2 }
      .lest || { fail("no value for $data[a][b][c]" }
     ```
-    
+
     Would fail the operation because $data[a][b][c] results in `undef`
     (there is no `b` key in `a`).
-    
+
     In contrast - this example:
-    
+
     ```puppet
     $data = {a => { b => { c => 10 } } }
     notice $data.dig(a, b, c)
      .then |$x| { $x * 2 }
      .lest || { fail("no value for $data[a][b][c]" }
     ```
-    
+
     Would notice the value `20`
-    
+
     * Since 4.5.0
   DOC
 ) do |_args|

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

@@ -6,28 +6,28 @@ module Puppet::Parser::Functions
     this returns the first value found (and fails compilation if no values are
     available), but you can configure it to merge multiple values into one, fail
     gracefully, and more.
-    
+
     When looking up a key, Puppet will search up to three tiers of data, in the
     following order:
-    
+
     1. Hiera.
     2. The current environment's data provider.
     3. The indicated module's data provider, if the key is of the form
        `<MODULE NAME>::<SOMETHING>`.
-    
+
     #### Arguments
-    
+
     You must provide the name of a key to look up, and can optionally provide other
     arguments. You can combine these arguments in the following ways:
-    
+
     * `lookup( <NAME>, [<VALUE TYPE>], [<MERGE BEHAVIOR>], [<DEFAULT VALUE>] )`
     * `lookup( [<NAME>], <OPTIONS HASH> )`
     * `lookup( as above ) |$key| { # lambda returns a default value }`
-    
+
     Arguments in `[square brackets]` are optional.
-    
+
     The arguments accepted by `lookup` are as follows:
-    
+
     1. `<NAME>` (string or array) --- The name of the key to look up.
         * This can also be an array of keys. If Puppet doesn't find anything for the
         first key, it will try again with the subsequent ones, only resorting to a
@@ -64,24 +64,24 @@ module Puppet::Parser::Functions
         will check for the requested key in the overrides hash _first;_ if found, it
         returns that value as the _final_ value, ignoring merge behavior. Defaults
         to an empty hash.
-    
+
     Finally, `lookup` can take a lambda, which must accept a single parameter.
     This is yet another way to set a default value for the lookup; if no results are
     found, Puppet will pass the requested key to the lambda and use its result as
     the default value.
-    
+
     #### Merge Behaviors
-    
+
     Puppet lookup uses a hierarchy of data sources, and a given key might have
     values in multiple sources. By default, Puppet returns the first value it finds,
     but it can also continue searching and merge all the values together.
-    
+
     > **Note:** Data sources can use the special `lookup_options` metadata key to
     request a specific merge behavior for a key. The `lookup` function will use that
     requested behavior unless you explicitly specify one.
-    
+
     The valid merge behaviors are:
-    
+
     * `'first'` --- Returns the first value found, with no merging. Puppet lookup's
     default behavior.
     * `'unique'` (called "array merge" in classic Hiera) --- Combines any number of
@@ -106,28 +106,28 @@ module Puppet::Parser::Functions
         merged together. Defaults to `false`.
         * `'merge_hash_arrays'` (boolean) --- Whether to merge hashes within arrays.
         Defaults to `false`.
-    
+
     #### Examples
-    
+
     Look up a key and return the first value found:
-    
+
         lookup('ntp::service_name')
-    
+
     Do a unique merge lookup of class names, then add all of those classes to the
     catalog (like `hiera_include`):
-    
+
         lookup('classes', Array[String], 'unique').include
-    
+
     Do a deep hash merge lookup of user data, but let higher priority sources
     remove values by prefixing them with `--`:
-    
+
         lookup( { 'name'  => 'users',
                   'merge' => {
                     'strategy'        => 'deep',
                     'knockout_prefix' => '--',
                   },
         })
-    
+
   ENDHEREDOC
     Error.is4x('lookup')
   end