openvox 8.19.0

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

@@ -0,0 +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
+) 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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+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.
+
+  The argument to this function should be a `<MODULE NAME>/<FILE>`
+  reference, which will load `<FILE>` from a module's `files`
+  directory. (For example, the reference `mysql/mysqltuner.pl` will load the
+  file `<MODULES DIRECTORY>/mysql/files/mysqltuner.pl`.)
+
+  This function can also accept:
+
+  * An absolute path, which can load a file from anywhere on disk.
+  * Multiple arguments, which will return the contents of the **first** file
+  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
+  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

@@ -0,0 +1,81 @@
+# 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`).
+
+    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 `filter` function
+
+    `$filtered_data = $data.filter |$parameter| { <PUPPET CODE BLOCK> }`
+
+    or
+
+    `$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.
+
+    **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]
+    ~~~
+
+    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
+
+    ~~~ 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.
+
+    **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]
+    ~~~
+
+    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
+
+    ~~~ 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|
+  Puppet::Parser::Functions::Error.is4x('filter')
+end

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

@@ -0,0 +1,29 @@
+# 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.
+
+    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:
+
+    * 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
+
+    - since 4.8.0
+  DOC
+) do |_args|
+  Puppet::Parser::Functions::Error.is4x('find_file')
+end

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

@@ -0,0 +1,46 @@
+# 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], [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.) 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
+  other services if they all fire at once. Adding a SEED can be useful when you
+  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)
+end

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

@@ -0,0 +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,
+    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
+    malicious generator calls (e.g., those with '..' in them), but it can
+    never be entirely safe. No subshell is used to execute
+    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])
+
+  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
+
+  if args[0] =~ /\.\./
+    raise Puppet::ParseError, _("Can not use generators with '..' in them.")
+  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

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'hiera_puppet'
+
+module Puppet::Parser::Functions
+  newfunction(
+    :hiera,
+    :type => :rvalue,
+    :arity => -2,
+    :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
+          fails with a compilation error.
+      3. The optional name of an arbitrary
+      [hierarchy level](https://puppet.com/docs/hiera/latest/hierarchy.html) to insert at the
+      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:
+          - "Edith Franklin"
+          - "Ginny Hamilton"
+        regular:
+          - "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|
+    Error.is4x('hiera')
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'hiera_puppet'
+
+module Puppet::Parser::Functions
+  newfunction(
+    :hiera_array,
+    :type => :rvalue,
+    :arity => -2,
+    :doc => <<~DOC
+      Finds all matches of a key throughout the hierarchy and returns them as a single flattened
+      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
+          fails with a compilation error.
+      3. The optional name of an arbitrary
+      [hierarchy level](https://puppet.com/docs/hiera/latest/hierarchy.html) to insert at the
+      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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'hiera_puppet'
+
+module Puppet::Parser::Functions
+  newfunction(
+    :hiera_hash,
+    :type => :rvalue,
+    :arity => -2,
+    :doc => <<~DOC
+      Finds all matches of a key throughout the hierarchy and returns them in a merged hash.
+      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
+          fails with a compilation error.
+      3. The optional name of an arbitrary
+      [hierarchy level](https://puppet.com/docs/hiera/latest/hierarchy.html) to insert at the
+      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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'hiera_puppet'
+
+module Puppet::Parser::Functions
+  newfunction(
+    :hiera_include,
+    :arity => -2,
+    :doc => <<~DOC
+      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
+          fails with a compilation error.
+      3. The optional name of an arbitrary
+      [hierarchy level](https://puppet.com/docs/hiera/latest/hierarchy.html) to insert at the
+      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