bolt 0.20.0 → 0.20.2

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

@@ -0,0 +1,88 @@
+require 'hiera/puppet_function'
+# 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.
+#
+# This function is deprecated in favor of the `lookup` function. While this function
+# continues to work, it does **not** support:
+# * `lookup_options` stored in the data
+# * lookup across global, environment, and module layers
+#
+# 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://docs.puppetlabs.com/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
+# returning 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://docs.puppetlabs.com/puppet/latest/reference/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.
+#
+# See
+# [the 'Using the lookup function' documentation](https://docs.puppet.com/puppet/latest/hiera_use_function.html) for how to perform lookup of data.
+# Also see
+# [the 'Using the deprecated hiera functions' documentation](https://docs.puppet.com/puppet/latest/hiera_use_hiera_functions.html)
+# for more information about the Hiera 3 functions.
+#
+# @since 4.0.0
+#
+Puppet::Functions.create_function(:hiera, Hiera::PuppetFunction) do
+  init_dispatch
+end

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

@@ -0,0 +1,81 @@
+require 'hiera/puppet_function'
+
+# 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://docs.puppetlabs.com/hiera/latest/lookup_types.html#array-merge).
+#
+# This function is deprecated in favor of the `lookup` function. While this function
+# continues to work, it does **not** support:
+# * `lookup_options` stored in the data
+# * lookup across global, environment, and module layers
+#
+# 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://docs.puppetlabs.com/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://docs.puppetlabs.com/puppet/latest/reference/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.
+#
+# See
+# [the 'Using the lookup function' documentation](https://docs.puppet.com/puppet/latest/hiera_use_function.html) for how to perform lookup of data.
+# Also see
+# [the 'Using the deprecated hiera functions' documentation](https://docs.puppet.com/puppet/latest/hiera_use_hiera_functions.html)
+# for more information about the Hiera 3 functions.
+#
+# @since 4.0.0
+#
+Puppet::Functions.create_function(:hiera_array, Hiera::PuppetFunction) do
+  init_dispatch
+
+  def merge_type
+    :unique
+  end
+end

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

@@ -0,0 +1,92 @@
+require 'hiera/puppet_function'
+
+# Finds all matches of a key throughout the hierarchy and returns them in a merged hash.
+#
+# This function is deprecated in favor of the `lookup` function. While this function
+# continues to work, it does **not** support:
+# * `lookup_options` stored in the data
+# * lookup across global, environment, and module layers
+#
+# 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://docs.puppetlabs.com/hiera/latest/lookup_types.html#hash-merge).
+#
+# The merge strategy is determined by Hiera's
+# [`:merge_behavior`](https://docs.puppetlabs.com/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://docs.puppetlabs.com/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://docs.puppetlabs.com/puppet/latest/reference/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.
+#
+# See
+# [the 'Using the lookup function' documentation](https://docs.puppet.com/puppet/latest/hiera_use_function.html) for how to perform lookup of data.
+# Also see
+# [the 'Using the deprecated hiera functions' documentation](https://docs.puppet.com/puppet/latest/hiera_use_hiera_functions.html)
+# for more information about the Hiera 3 functions.
+#
+# @since 4.0.0
+#
+Puppet::Functions.create_function(:hiera_hash, Hiera::PuppetFunction) do
+  init_dispatch
+
+  def merge_type
+    :hash
+  end
+end

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

@@ -0,0 +1,104 @@
+require 'hiera/puppet_function'
+
+# Assigns classes to a node using an
+# [array merge lookup](https://docs.puppetlabs.com/hiera/latest/lookup_types.html#array-merge)
+# that retrieves the value for a user-specified key from Hiera's data.
+#
+# This function is deprecated in favor of the `lookup` function in combination with `include`.
+# While this function continues to work, it does **not** support:
+# * `lookup_options` stored in the data
+# * lookup across global, environment, and module layers
+#
+# @example Using `lookup` and `include` instead of of the deprecated `hiera_include`
+# 
+# ```puppet
+# # In site.pp, outside of any node definitions and below any top-scope variables:
+# lookup('classes', Array[String], 'unique').include
+# ```
+#
+# 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://docs.puppetlabs.com/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://docs.puppetlabs.com/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://docs.puppetlabs.com/puppet/latest/reference/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".
+# ```
+#
+# See
+# [the 'Using the lookup function' documentation](https://docs.puppet.com/puppet/latest/hiera_use_function.html) for how to perform lookup of data.
+# Also see
+# [the 'Using the deprecated hiera functions' documentation](https://docs.puppet.com/puppet/latest/hiera_use_hiera_functions.html)
+# for more information about the Hiera 3 functions.
+#
+# @since 4.0.0
+#
+Puppet::Functions.create_function(:hiera_include, Hiera::PuppetFunction) do
+  init_dispatch
+
+  def merge_type
+    :unique
+  end
+
+  def post_lookup(scope, key, value)
+    raise Puppet::ParseError, _("Could not find data item %{key}") % { key: key } if value.nil?
+    call_function_with_scope(scope, 'include', value) unless value.empty?
+  end
+end

data/vendored/puppet/lib/puppet/functions/hocon_data.rb

@@ -0,0 +1,41 @@
+# The `hocon_data` is a hiera 5 `data_hash` data provider function.
+# See [the configuration guide documentation](https://docs.puppet.com/puppet/latest/hiera_config_yaml_5.html#configuring-a-hierarchy-level-built-in-backends) for
+# how to use this function.
+#
+# Note that this function is not supported without a hocon library being present.
+#
+# @since 4.9.0
+#
+Puppet::Functions.create_function(:hocon_data) do
+  unless Puppet.features.hocon?
+    raise Puppet::DataBinding::LookupError, _('Lookup using Hocon data_hash function is not supported without hocon library')
+  end
+
+  require 'hocon'
+  require 'hocon/config_error'
+
+  dispatch :hocon_data do
+    param 'Struct[{path=>String[1]}]', :options
+    param 'Puppet::LookupContext', :context
+  end
+
+  argument_mismatch :missing_path do
+    param 'Hash', :options
+    param 'Puppet::LookupContext', :context
+  end
+
+  def hocon_data(options, context)
+    path = options['path']
+    context.cached_file_data(path) do |content|
+      begin
+        Hocon.parse(content)
+      rescue Hocon::ConfigError => ex
+        raise Puppet::DataBinding::LookupError, _("Unable to parse (%{path}): %{message}") % { path: path, message: ex.message }
+      end
+    end
+  end
+
+  def missing_path(options, context)
+    "one of 'path', 'paths' 'glob', 'globs' or 'mapped_paths' must be declared in hiera.yaml when using this data_hash function"
+  end
+end

data/vendored/puppet/lib/puppet/functions/import.rb

@@ -0,0 +1,7 @@
+# The import function raises an error when called to inform the user that import is no longer supported.
+#
+Puppet::Functions.create_function(:import) do
+  def import(*args)
+    raise Puppet::Pops::SemanticError.new(Puppet::Pops::Issues::DISCONTINUED_IMPORT)
+  end
+end

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

@@ -0,0 +1,53 @@
+# 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.
+#
+# The `include` function can be used multiple times on the same class and will
+# only declare a given class once. If a class declared with `include` has any
+# parameters, Puppet will automatically look up values for them in Hiera, using
+# `<class name>::<parameter name>` as the lookup key.
+#
+# Contrast this behavior with resource-like class declarations
+# (`class {'name': parameter => 'value',}`), which must be used in only one place
+# per class and can directly set parameters. You should avoid using both `include`
+# and resource-like declarations with the same class.
+#
+# The `include` function does not cause classes to be contained in the class
+# where they are declared. For that, see the `contain` function. It also
+# does not create a dependency relationship between the declared class and the
+# surrounding class; for that, see the `require` function.
+#
+# You must use the class's full name;
+# relative names are not allowed. In addition to names in string form,
+# you may also directly use `Class` and `Resource` `Type`-values that are produced by
+# the 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
+#
+Puppet::Functions.create_function(:include, Puppet::Functions::InternalFunction) do
+  dispatch :include do
+    scope_param
+    # The function supports what the type system sees as Ruby runtime objects, and
+    # they cannot be parameterized to find what is actually valid instances.
+    # The validation is instead done in the function body itself via a call to
+    # `transform_and_assert_classnames` on the calling scope.
+    required_repeated_param 'Any', :names
+  end
+
+  def include(scope, *classes)
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:operation => 'include'})
+    end
+
+    classes = scope.transform_and_assert_classnames(classes.flatten)
+    result = classes.map {|name| Puppet::Pops::Types::TypeFactory.host_class(name) }
+    scope.compiler.evaluate_classes(classes, scope, false)
+
+    # Result is an Array[Class, 1, n] which allows chaining other operations
+    result
+  end
+end