puppet 5.3.4 → 6.29.0

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

@@ -9,10 +9,10 @@ module Puppet::Parser::Functions
 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://docs.puppetlabs.com/hiera/latest/lookup_types.html#hash-merge).
+[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://docs.puppetlabs.com/hiera/latest/configuring.html#mergebehavior)
+[`:merge_behavior`](https://puppet.com/docs/hiera/latest/configuring.html#mergebehavior)
 setting.
 
 The `hiera_hash` function takes up to three arguments, in this order:
@@ -22,7 +22,7 @@ The `hiera_hash` function takes up to three arguments, in this order:
     * 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
+[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.
@@ -56,7 +56,7 @@ $allusers = hiera_hash('users', undef)
 ~~~
 
 You can optionally generate the default value with a
-[lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) that
+[lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) that
 takes one parameter.
 
 **Example**: Using `hiera_hash` with a lambda
@@ -76,7 +76,7 @@ $allusers = hiera_hash('users') | $key | { "Key \'${key}\' not found" }
 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://docs.puppet.com/puppet/#{Puppet.minor_version}/reference/deprecated_language.html.
+See  https://puppet.com/docs/puppet/#{Puppet.minor_version}/deprecated_language.html.
 Replace the calls as follows:
 
 | from  | to |
@@ -90,7 +90,7 @@ result must be post processed to get exactly the same result, for example using
 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://docs.puppetlabs.com/hiera/latest/puppet.html#hiera-lookup-functions)
+[the documentation](https://puppet.com/docs/hiera/latest/puppet.html#hiera-lookup-functions)
 for more information about Hiera lookup functions.
 
 - Since 4.0.0

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

@@ -6,7 +6,7 @@ module Puppet::Parser::Functions
     :arity => -2,
     :doc => <<-DOC
 Assigns classes to a node using an
-[array merge lookup](https://docs.puppetlabs.com/hiera/latest/lookup_types.html#array-merge)
+[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:
@@ -25,13 +25,13 @@ The function takes up to three arguments, in this order:
     * 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
+[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://docs.puppetlabs.com/hiera/latest/lookup_types.html#array-merge)
+[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`
@@ -59,7 +59,7 @@ hiera_include('classes', undef)
 ~~~
 
 You can optionally generate the default value with a
-[lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) that
+[lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) that
 takes one parameter.
 
 **Example**: Using `hiera_include` with a lambda
@@ -75,9 +75,8 @@ hiera_include('classes') | $key | {"Key \'${key}\' not found" }
 # "Key 'classes' not found".
 ~~~
 
-`hiera_include` is deprecated in favor of using a combination of `include`and `lookup` and will be
-removed in 6.0.0. See  https://docs.puppet.com/puppet/#{Puppet.minor_version}/reference/deprecated_language.html.
-Replace the calls as follows:
+`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 |
 | ----  | ---|
@@ -85,14 +84,14 @@ Replace the calls as follows:
 | 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.
 
-See [the documentation](http://links.puppet.com/hierainclude) for more information
-and a more detailed example of how `hiera_include` uses array merge lookups to classify
-nodes.
-
 - Since 4.0.0
 DOC
   ) do |*args|

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

@@ -6,12 +6,12 @@ text result as a String.
 
 The first argument to this function should be a string containing an EPP
 template. 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 evaluate an inline EPP template and pass it the `docroot` and
@@ -29,7 +29,7 @@ parameter tag without default values. Puppet produces an error if the
 `inline_epp` function fails to pass any required parameter.
 
 An inline EPP template should be written as a single-quoted string or
-[heredoc](/puppet/latest/reference/lang_data_string.html#heredocs).
+[heredoc](https://puppet.com/docs/puppet/latest/lang_data_string.html#heredocs).
 A double-quoted string is subject to expression interpolation before the string
 is parsed as an EPP template.
 
@@ -45,7 +45,7 @@ END
 ~~~
 
 - Since 3.5
-- Requires [future parser](/puppet/3.8/reference/experiments_future.html) in Puppet 3.5 to 3.8") do |arguments|
+- Requires [future parser](https://puppet.com/docs/puppet/3.8/experiments_future.html) in Puppet 3.5 to 3.8") do |arguments|
 
   Puppet::Parser::Functions::Error.is4x('inline_epp')
 end

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

@@ -1,9 +1,15 @@
 Puppet::Parser::Functions::newfunction(:inline_template, :type => :rvalue, :arity => -2, :doc =>
   "Evaluate a template string and return its value.  See
-  [the templating docs](https://docs.puppetlabs.com/puppet/latest/reference/lang_template.html) for
+  [the templating docs](https://puppet.com/docs/puppet/latest/lang_template.html) for
   more information. Note that if multiple template strings are specified, their
   output is all concatenated and returned as the output of the function.") do |vals|
 
+  if Puppet[:tasks]
+    raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+      Puppet::Pops::Issues::FEATURE_NOT_SUPPORTED_WHEN_SCRIPTING,
+      {:feature => 'ERB inline_template'})
+  end
+
   require 'erb'
 
     vals.collect do |string|

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

@@ -3,7 +3,7 @@ Puppet::Parser::Functions::newfunction(
   :type => :rvalue,
   :arity => -2,
   :doc => <<-DOC
-Call a [lambda](https://docs.puppet.com/puppet/latest/reference/lang_lambdas.html)
+Call a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 (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.

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

@@ -31,7 +31,7 @@ The arguments accepted by `lookup` are as follows:
     first key, it will try again with the subsequent ones, only resorting to a
     default value if none of them succeed.
 2. `<VALUE TYPE>` (data type) --- A
-[data type](https://docs.puppetlabs.com/puppet/latest/reference/lang_data_type.html)
+[data type](https://puppet.com/docs/puppet/latest/lang_data_type.html)
 that must match the retrieved value; if not, the lookup (and catalog
 compilation) will fail. Defaults to `Data` (accepts any normal value).
 3. `<MERGE BEHAVIOR>` (string or hash; see **"Merge Behaviors"** below) ---

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

@@ -3,7 +3,7 @@ Puppet::Parser::Functions::newfunction(
   :type => :rvalue,
   :arity => -3,
   :doc => <<-DOC
-Applies a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+Applies a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 to every value in a data structure and returns an array containing the results.
 
 This function takes two mandatory arguments, in this order:

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

@@ -56,16 +56,14 @@ Would fail with an assertion error (since value is less than 0).
 The following sections show the arguments and conversion rules
 per data type built into the Puppet Type System.
 
-Conversion to Optional[T] and NotUndef[T]
------------------------------------------
+### Conversion to Optional[T] and NotUndef[T]
 
 Conversion to these data types is the same as a conversion to the type argument `T`.
 In the case of `Optional[T]` it is accepted that the argument to convert may be `undef`.
 It is however not acceptable to give other arguments (than `undef`) that cannot be
 converted to `T`.
 
-Conversion to Integer
----------------------
+### Conversion to Integer
 
 A new `Integer` can be created from `Integer`, `Float`, `Boolean`, and `String` values.
 For conversion from `String` it is possible to specify the radix (base).
@@ -113,8 +111,7 @@ $a_number = Integer(true)          # results in 1
 $a_number = Integer(-38, 10, true) # results in 38
 ```
 
-Conversion to Float
--------------------
+### Conversion to Float
 
 A new `Float` can be created from `Integer`, `Float`, `Boolean`, and `String` values.
 For conversion from `String` both float and integer formats are supported.
@@ -126,15 +123,13 @@ function Float.new(
 )
 ```
 
-
 * For an integer, the floating point fraction of `.0` is added to the value.
 * A `Boolean` `true` is converted to 1.0, and a `false` to 0.0
 * In `String` format, integer prefixes for hex and binary are understood (but not octal since
   floating point in string format may start with a '0').
 * When `abs` is set to `true`, the result will be an absolute floating point value.
 
-Conversion to Numeric
----------------------
+### Conversion to Numeric
 
 A new `Integer` or `Float` can be created from `Integer`, `Float`, `Boolean` and
 `String` values.
@@ -163,8 +158,7 @@ $a_number = Numeric(-42.3, true) # results in 42.3
 $a_number = Numeric(-42, true)   # results in 42
 ```
 
-Conversion to Timespan
--------------------
+### Conversion to Timespan
 
 A new `Timespan` can be created from `Integer`, `Float`, `String`, and `Hash` values. Several variants of the constructor are provided.
 
@@ -178,7 +172,7 @@ function Timespan.new(
 )
 ```
 
-#### Timespan from days, hours, mintues, seconds, and fractions of a second
+#### Timespan from days, hours, minutes, seconds, and fractions of a second
 
 The arguments can be passed separately in which case the first four, days, hours, minutes, and seconds are mandatory and the rest are optional.
 All values may overflow and/or be negative. The internal 128-bit nano-second integer is calculated as:
@@ -281,8 +275,7 @@ $duration = Timespan('10:03.5', '%M:%S.%L') # 10 minutes, 3 seconds, and 5 milli
 $duration = Timespan('10:03.5', '%M:%S.%N') # 10 minutes, 3 seconds, and 5 nano-seconds
 ```
 
-Conversion to Timestamp
--------------------
+### Conversion to Timestamp
 
 A new `Timestamp` can be created from `Integer`, `Float`, `String`, and `Hash` values. Several variants of the constructor are provided.
 
@@ -475,8 +468,8 @@ $ts = Timestamp('2016-08-24T12:13:14', default, 'PST')   # 2016-08-24 20:13:14.0
 
 ```
 
-Conversion to Type
-------------------
+### Conversion to Type
+
 A new `Type` can be create from its `String` representation.
 
 **Example:** Creating a type from a string
@@ -485,8 +478,7 @@ A new `Type` can be create from its `String` representation.
 $t = Type.new('Integer[10]')
 ```
 
-Conversion to String
---------------------
+### Conversion to String
 
 Conversion to `String` is the most comprehensive conversion as there are many
 use cases where a string representation is wanted. The defaults for the many options
@@ -529,7 +521,7 @@ included in a string format.
 Note that all data type supports the formats `s` and `p` with the meaning "default string representation" and
 "default programmatic string representation" (which for example means that a String is quoted in 'p' format).
 
-### Signatures of String conversion
+#### Signatures of String conversion
 
 ```puppet
 type Format = Pattern[/^%([\s\+\-#0\[\{<\(\|]*)([1-9][0-9]*)?(?:\.([0-9]+))?([a-zA-Z])/]
@@ -587,7 +579,7 @@ $str = String([1,2,3], $formats) # produces '(0x1, 0x2, 0x3)'
 The given formats are merged with the default formats, and matching of values to convert against format is based on
 the specificity of the mapped type; for example, different formats can be used for short and long arrays.
 
-### Integer to String
+#### Integer to String
 
 | Format  | Integer Formats
 | ------  | ---------------
@@ -602,7 +594,7 @@ the specificity of the mapped type; for example, different formats can be used f
 
 Defaults to `d`.
 
-### Float to String
+#### Float to String
 
 | Format  | Float formats
 | ------  | -------------
@@ -616,7 +608,7 @@ Defaults to `d`.
 
 Defaults to `p`.
 
-### String to String
+#### String to String
 
 | Format | String
 | ------ | ------
@@ -630,7 +622,7 @@ Defaults to `p`.
 
 Defaults to `s` at top level and `p` inside array or hash.
 
-### Boolean to String
+#### Boolean to String
 
 | Format    | Boolean Formats
 | ----      | -------------------
@@ -641,14 +633,14 @@ Defaults to `s` at top level and `p` inside array or hash.
 | s         | String 'true' / 'false'.
 | p         | String 'true' / 'false'.
 
-### Regexp to String
+#### Regexp to String
 
 | Format    | Regexp Formats
 | ----      | --------------
 | s         | No delimiters, quoted if alternative flag `#` is used.
 | p         | Delimiters `/ /`.
 
-### Undef to String
+#### Undef to String
 
 | Format    | Undef formats
 | ------    | -------------
@@ -661,7 +653,7 @@ Defaults to `s` at top level and `p` inside array or hash.
 | V         | String 'N/A'.
 | u         | String 'undef', or 'undefined' if alternative `#` flag is used.
 
-### Default value to String
+#### Default value to String
 
 | Format    | Default formats
 | ------    | ---------------
@@ -669,7 +661,7 @@ Defaults to `s` at top level and `p` inside array or hash.
 | s         | Same as d.
 | p         | Same as d.
 
-### Binary value to String
+#### Binary value to String
 
 | Format    | Default formats
 | ------    | ---------------
@@ -686,7 +678,7 @@ Defaults to `s` at top level and `p` inside array or hash.
   as hex escaped characters on the form `\\xHH` where `H` is a hex digit.
 * The width and precision values are applied to the text part only in `%p` format.
 
-### Array & Tuple to String
+#### Array & Tuple to String
 
 | Format    | Array/Tuple Formats
 | ------    | -------------
@@ -701,7 +693,7 @@ The alternate form flag `#` will cause indentation of nested array or hash conta
 it is taken as the maximum allowed length of a sequence of elements (not including delimiters). If this max length
 is exceeded, each element will be indented.
 
-### Hash & Struct to String
+#### Hash & Struct to String
 
 | Format    | Hash/Struct Formats
 | ------    | -------------
@@ -715,14 +707,14 @@ more information about options.
 
 The alternate form flag `#` will format each hash key/value entry indented on a separate line.
 
-### Type to String
+#### Type to String
 
 | Format    | Array/Tuple Formats
 | ------    | -------------
 | s         | The same as `p`, quoted if alternative flag `#` is used.
 | p         | Outputs the type in string form as specified by the Puppet Language.
 
-### Flags
+#### Flags
 
 | Flag     | Effect
 | ------   | ------
@@ -733,8 +725,7 @@ The alternate form flag `#` will format each hash key/value entry indented on a
 | 0        | Pad with 0 instead of space for widths larger than value.
 | <[({\|   | Defines an enclosing pair <> [] () {} or \| \| when used with a container type.
 
-Conversion to Boolean
----
+### Conversion to Boolean
 
 Accepts a single value as argument:
 
@@ -745,8 +736,7 @@ Accepts a single value as argument:
   * `false` if 'false', 'no', 'n' (case independent compare)
 * Boolean is already boolean and is simply returned
 
-Conversion to Array and Tuple
----
+### Conversion to Array and Tuple
 
 When given a single value as argument:
 
@@ -771,8 +761,7 @@ $arr = Array($value, true)
 Conversion to a `Tuple` works exactly as conversion to an `Array`, only that the constructed array is
 asserted against the given tuple type.
 
-Conversion to Hash and Struct
----
+### Conversion to Hash and Struct
 
 Accepts a single value as argument:
 
@@ -811,8 +800,8 @@ Would notice the hash `{a => {b => {x => wine}}, b => {y => wine}}`
 Conversion to a `Struct` works exactly as conversion to a `Hash`, only that the constructed hash is
 asserted against the given struct type.
 
-Conversion to a Regexp
----
+### Conversion to a Regexp
+
 A `String` can be converted into a `Regexp`
 
 **Example**: Converting a String into a Regexp
@@ -824,8 +813,7 @@ if('foo.com' =~ $r) {
 }
 ```
 
-Creating a SemVer
----
+### Creating a SemVer
 
 A SemVer object represents a single [Semantic Version](http://semver.org/).
 It can be created from a String, individual values for its parts, or a hash specifying the value per part.
@@ -874,8 +862,7 @@ notice(SemVer('2.3.4') =~ $t) # false
 notice(SemVer('3.4.5') =~ $t) # true
 ```
 
-Creating a SemVerRange
----
+### Creating a SemVerRange
 
 A `SemVerRange` object represents a range of `SemVer`. It can be created from
 a `String`, or from two `SemVer` instances, where either end can be given as
@@ -909,10 +896,9 @@ function SemVerRange.new(
 )
 ```
 
-For examples of `SemVerRange` use see "Creating a SemVer"
+For examples of `SemVerRange` use, see "Creating a SemVer".
 
-Creating a Binary
----
+### Creating a Binary
 
 A `Binary` object represents a sequence of bytes and it can be created from a String in Base64 format,
 an Array containing byte values. A Binary can also be created from a Hash containing the value to convert to
@@ -932,7 +918,6 @@ function Binary.new(
   Optional[Base64Format] $format
 )
 
-
 function Binary.new(
   Array[ByteInteger] $byte_array
 }

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

@@ -7,6 +7,12 @@ Puppet::Parser::Functions::newfunction(:realize, :arity => -2, :doc => "Make a v
     and, of course, is a bit shorter.  You must pass the object using a
     reference; e.g.: `realize User[luke]`." ) do |vals|
 
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:operation => 'realize'})
+    end
+
     vals = [vals] unless vals.is_a?(Array)
 
     coll = Puppet::Pops::Evaluator::Collectors::FixedSetCollector.new(self, vals.flatten)

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

@@ -3,7 +3,7 @@ Puppet::Parser::Functions::newfunction(
   :type => :rvalue,
   :arity => -3,
   :doc => <<-DOC
-Applies a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+Applies a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 to every value in a data structure from the first argument, carrying over the returned
 value of each iteration, and returns the result of the lambda's final iteration. This
 lets you create a new value or data structure by combining values from the first

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

@@ -4,7 +4,8 @@ Puppet::Parser::Functions::newfunction(
   :doc => <<-DOC
 Immediately returns the given optional value from a function, class body or user defined type body.
 If a value is not given, an `undef` value is returned. This function does not return to the immediate caller.
-If called from within a lambda the return will return from the function evaluating the lambda.
+If this function is called from within a lambda, the return action is from the scope of the
+function containing the lambda (top scope), not the function accepting the lambda (local scope).
 
 The signal produced to return a value bubbles up through
 the call stack until reaching a function, class definition or
@@ -63,6 +64,26 @@ The code would notice `'bar'` but not `'foo'`
 
 Note that the returned value is ignored if used in a class or user defined type.
 
+**Example:** Using `return` in a lambda
+
+```puppet
+# Concatenate three strings into a single string formatted as a list.
+function getFruit() {
+  with("apples", "oranges", "bananas") |$x, $y, $z| {
+    return("${x}, ${y}, and ${z}")
+  }
+  notice "not reached"
+}
+$fruit = getFruit()
+notice $fruit
+
+# The output contains "apples, oranges, and bananas".
+# "not reached" is not output because the function returns its value within the
+# calling function's scope, which stops processing the calling function before
+# the `notice "not reached"` statement.
+# Using `return()` outside of a calling function results in an error.
+```
+
 * Also see functions `return` and `break`
 * Since 4.8.0
 DOC

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

@@ -4,7 +4,7 @@ Puppet::Parser::Functions::newfunction(
   :arity => -1,
   :doc => <<-DOC
 Reverses the order of the elements of something that is iterable and optionally runs a
-[lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) for each
+[lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) for each
 element.
 
 This function takes one to two arguments:
@@ -40,7 +40,7 @@ $reverse_data = reverse_each($data)
 When no second argument is present, Puppet returns an `Iterable` that represents the reverse
 order of its first argument. This allows methods on `Iterable` to be chained.
 
-When a lamdba is given as the second argument, Puppet iterates the first argument in reverse
+When a lambda is given as the second argument, Puppet iterates the first argument in reverse
 order and passes each value in turn to the lambda, then returns `undef`.
 
 **Example:** Using the `reverse_each` function with an array and a one-parameter lambda

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

@@ -34,5 +34,5 @@ DOC
 ) do |args|
   data = args[0]
   format = args[1]
-  result = data.scanf(format)
+  data.scanf(format)
 end

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

@@ -0,0 +1,5 @@
+require 'digest/sha2'
+
+Puppet::Parser::Functions::newfunction(:sha256, :type => :rvalue, :arity => 1, :doc => "Returns a SHA256 hash value from a provided string.") do |args|
+  Digest::SHA256.hexdigest(args[0])
+end

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

@@ -30,7 +30,18 @@ Puppet::Parser::Functions::newfunction(
   :doc => "Perform printf-style formatting of text.
 
   The first parameter is format string describing how the rest of the parameters should be formatted.
-  See the documentation for the `Kernel::sprintf` function in Ruby for all the details."
+  See the documentation for the [`Kernel::sprintf` function](https://ruby-doc.org/core/Kernel.html)
+  in Ruby for details.
+  
+  To use [named format](https://idiosyncratic-ruby.com/49-what-the-format.html) arguments, provide a
+  hash containing the target string values as the argument to be formatted. For example:
+
+  ```puppet
+  notice sprintf(\"%<x>s : %<y>d\", { 'x' => 'value is', 'y' => 42 })
+  ```
+
+  This statement produces a notice of `value is : 42`."
+
 ) do |args|
   fmt = args[0]
   args = args[1..-1]

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

@@ -4,7 +4,7 @@ Puppet::Parser::Functions::newfunction(
   :arity => -1,
   :doc => <<-DOC
 Provides stepping with given interval over elements in an iterable and optionally runs a
-[lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) for each
+[lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) for each
 element.
 
 This function takes two to three arguments:

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

@@ -2,5 +2,11 @@
 Puppet::Parser::Functions::newfunction(:tag, :arity => -2, :doc => "Add the specified tags to the containing class
   or definition.  All contained objects will then acquire that tag, also.
   ") do |vals|
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:operation => 'tag'})
+    end
+
     self.resource.tag(*vals)
 end

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

@@ -3,12 +3,15 @@ Puppet::Parser::Functions::newfunction(:tagged, :type => :rvalue, :arity => -2,
   tells you whether the current container is tagged with the specified tags.
   The tags are ANDed, so that all of the specified tags must be included for
   the function to return true.") do |vals|
-    configtags = compiler.catalog.tags
-    resourcetags = resource.tags
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:operation => 'tagged'})
+    end
 
     retval = true
     vals.each do |val|
-      unless configtags.include?(val) or resourcetags.include?(val)
+      unless compiler.catalog.tagged?(val) or resource.tagged?(val)
         retval = false
         break
       end

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

@@ -12,6 +12,11 @@ Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :arity => -2
   * An absolute path, which can load a template file from anywhere on disk.
   * Multiple arguments, which will evaluate all of the specified templates and
   return their outputs concatenated into a single string.") do |vals|
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::FEATURE_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:feature => 'ERB template'})
+    end
     vals.collect do |file|
       # Use a wrapper, so the template can't get access to the full
       # Scope object.

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

@@ -3,7 +3,7 @@ Puppet::Parser::Functions::newfunction(
   :type => :rvalue,
   :arity => -2,
   :doc => <<-DOC
-Call a [lambda](https://docs.puppet.com/puppet/latest/reference/lang_lambdas.html)
+Call a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 with the given argument unless the argument is undef. Return `undef` if argument is
 `undef`, and otherwise the result of giving the argument to the lambda.