puppet 4.0.0 → 4.9.1

data/lib/puppet/functions/next.rb

@@ -0,0 +1,23 @@
+# Make iteration continue with the next value optionally given a value for this iteration.
+# If a value is not given it defaults to `undef`
+#
+# @since 4.7.0
+#
+Puppet::Functions.create_function(:next) do
+  dispatch :next_impl do
+    optional_param 'Any', :value
+  end
+
+  def next_impl(value = nil)
+    stacktrace = Puppet::Pops::PuppetStack.stacktrace()
+    if stacktrace.size > 0
+      file, line = stacktrace[0]
+    else
+      file = nil
+      line = nil
+    end
+
+    exc = Puppet::Pops::Evaluator::Next.new(value, file, line)
+    raise exc
+  end
+end

data/lib/puppet/functions/notice.rb

@@ -0,0 +1,14 @@
+# Log a message on the server at level notice.
+Puppet::Functions.create_function(:notice, Puppet::Functions::InternalFunction) do
+  # @param values The values to log.
+  # @return [Undef]
+  dispatch :notice do
+    scope_param
+    repeated_param 'Any', :values
+    return_type 'Undef'
+  end
+
+  def notice(scope, *values)
+    Puppet::Util::Log.log_func(scope, :notice, values)
+  end
+end

data/lib/puppet/functions/reduce.rb

@@ -1,92 +1,121 @@
-# Applies a parameterized block to each element in a sequence of entries from the first
-# argument (_the enumerable_) and returns the last result of the invocation of the parameterized block.
-#
-# This function takes two mandatory arguments: the first should be an Array, Hash, or something of
-# enumerable type, and the last a parameterized block as produced by the puppet syntax:
-#
-#       $a.reduce |$memo, $x| { ... }
-#       reduce($a) |$memo, $x| { ... }
-#
-# When the first argument is an Array or someting of an enumerable type, the block is called with each entry in turn.
-# When the first argument is a hash each entry is converted to an array with `[key, value]` before being
-# fed to the block. An optional 'start memo' value may be supplied as an argument between the array/hash
-# and mandatory block.
-#
-#       $a.reduce(start) |$memo, $x| { ... }
-#       reduce($a, start) |$memo, $x| { ... }
-#
-# If no 'start memo' is given, the first invocation of the parameterized block will be given the first and second
-# elements of the enumeration, and if the enumerable has fewer than 2 elements, the first
-# element is produced as the result of the reduction without invocation of the block.
-#
-# On each subsequent invocation, the produced value of the invoked parameterized block is given as the memo in the
-# next invocation.
-#
-# @example Using reduce
-#
-#       # Reduce an array
-#       $a = [1,2,3]
-#       $a.reduce |$memo, $entry| { $memo + $entry }
-#       #=> 6
-#
-#       # Reduce hash values
-#       $a = {a => 1, b => 2, c => 3}
-#       $a.reduce |$memo, $entry| { [sum, $memo[1]+$entry[1]] }
-#       #=> [sum, 6]
-#
-#       # reverse a string
-#       "abc".reduce |$memo, $char| { "$char$memo" }
-#       #=>"cbe"
-#
-# It is possible to provide a starting 'memo' as an argument.
-#
-# @example Using reduce with given start 'memo'
-#
-#       # Reduce an array
-#       $a = [1,2,3]
-#       $a.reduce(4) |$memo, $entry| { $memo + $entry }
-#       #=> 10
-#
-#       # Reduce hash values
-#       $a = {a => 1, b => 2, c => 3}
-#       $a.reduce([na, 4]) |$memo, $entry| { [sum, $memo[1]+$entry[1]] }
-#       #=> [sum, 10]
-#
-# @example Using reduce with an Integer range
-#
-#       Integer[1,4].reduce |$memo, $x| { $memo + $x }
-#       #=> 10
+# Applies a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/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
+# argument's data structure.
+#
+# This function takes two mandatory arguments, in this order:
+#
+# 1. An array, hash, or other iterable object that the function will iterate over.
+# 2. A lambda, which the function calls for each element in the first argument. It takes
+# two mandatory parameters:
+#     1. A memo value that is overwritten after each iteration with the iteration's result.
+#     2. A second value that is overwritten after each iteration with the next value in the
+#     function's first argument.
+#
+# @example Using the `reduce` function
+#
+# `$data.reduce |$memo, $value| { ... }`
+#
+# or
+#
+# `reduce($data) |$memo, $value| { ... }`
+#
+# You can also pass an optional "start memo" value as an argument, such as `start` below:
+#
+# `$data.reduce(start) |$memo, $value| { ... }`
+#
+# or
+#
+# `reduce($data, start) |$memo, $value| { ... }`
+#
+# When the first argument (`$data` in the above example) is an array, Puppet passes each
+# of the data structure's values in turn to the lambda's parameters. When the first
+# argument is a hash, Puppet converts each of the hash's values to an array in the form
+# `[key, value]`.
+#
+# If you pass a start memo value, Puppet executes the lambda with the provided memo value
+# and the data structure's first value. Otherwise, Puppet passes the structure's first two
+# values to the lambda.
+#
+# Puppet calls the lambda for each of the data structure's remaining values. For each
+# call, it passes the result of the previous call as the first parameter ($memo in the
+# above examples) and the next value from the data structure as the second parameter
+# ($value).
+#
+# If the structure has one value, Puppet returns the value and does not call the lambda.
+#
+# @example Using the `reduce` function
+#
+# ~~~ puppet
+# # Reduce the array $data, returning the sum of all values in the array.
+# $data = [1, 2, 3]
+# $sum = $data.reduce |$memo, $value| { $memo + $value }
+# # $sum contains 6
+#
+# # Reduce the array $data, returning the sum of a start memo value and all values in the
+# # array.
+# $data = [1, 2, 3]
+# $sum = $data.reduce(4) |$memo, $value| { $memo + $value }
+# # $sum contains 10
+#
+# # Reduce the hash $data, returning the sum of all values and concatenated string of all
+# # keys.
+# $data = {a => 1, b => 2, c => 3}
+# $combine = $data.reduce |$memo, $value| {
+#   $string = "${memo[0]}${value[0]}"
+#   $number = $memo[1] + $value[1]
+#   [$string, $number]
+# }
+# # $combine contains [abc, 6]
+# ~~~
+#
+# @example Using the `reduce` function with a start memo and two-parameter lambda
+#
+# ~~~ puppet
+# # Reduce the array $data, returning the sum of all values in the array and starting
+# # with $memo set to an arbitrary value instead of $data's first value.
+# $data = [1, 2, 3]
+# $sum = $data.reduce(4) |$memo, $value| { $memo + $value }
+# # At the start of the lambda's first iteration, $memo contains 4 and $value contains 1.
+# # After all iterations, $sum contains 10.
+#
+# # Reduce the hash $data, returning the sum of all values and concatenated string of
+# # all keys, and starting with $memo set to an arbitrary array instead of $data's first
+# # key-value pair.
+# $data = {a => 1, b => 2, c => 3}
+# $combine = $data.reduce( [d, 4] ) |$memo, $value| {
+#   $string = "${memo[0]}${value[0]}"
+#   $number = $memo[1] + $value[1]
+#   [$string, $number]
+# }
+# # At the start of the lambda's first iteration, $memo contains [d, 4] and $value
+# # contains [a, 1].
+# # $combine contains [dabc, 10]
+# ~~~
 #
 # @since 4.0.0
 #
 Puppet::Functions.create_function(:reduce) do
 
   dispatch :reduce_without_memo do
-    param 'Any', :enumerable
+    param 'Iterable', :enumerable
     block_param 'Callable[2,2]', :block
   end
 
   dispatch :reduce_with_memo do
-    param 'Any', :enumerable
+    param 'Iterable', :enumerable
     param 'Any', :memo
     block_param 'Callable[2,2]', :block
   end
 
   def reduce_without_memo(enumerable)
-    enum = asserted_enumerable(enumerable)
+    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
     enum.reduce {|memo, x| yield(memo, x) }
   end
 
   def reduce_with_memo(enumerable, given_memo)
-    enum = asserted_enumerable(enumerable)
+    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
     enum.reduce(given_memo) {|memo, x| yield(memo, x) }
   end
-
-  def asserted_enumerable(obj)
-    unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
-      raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
-    end
-    enum
-  end
-
 end

data/lib/puppet/functions/regsubst.rb

@@ -1,54 +1,51 @@
 # Perform regexp replacement on a string or array of strings.
 #
-# @example
-#
-# Get the third octet from the node's IP address:
-#
-#   $i3 = regsubst($ipaddress,'^(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)$','\\3')
-#
-# Put angle brackets around each octet in the node's IP address:
-#
-#   $x = regsubst($ipaddress, /([0-9]+)/, '<\\1>', 'G')
-#
-# @param target [Array[String]|String]
+# @param target [String, Array[String]]
 #      The string or array of strings to operate on.  If an array, the replacement will be
 #      performed on each of the elements in the array, and the return value will be an array.
-# @param regexp [String|Regexp|Type[Regexp]]
+# @param pattern [String, Regexp, Type[Regexp]]
 #      The regular expression matching the target string.  If you want it anchored at the start
 #      and or end of the string, you must do that with ^ and $ yourself.
-# @param replacement [String]
+# @param replacement [String, Hash[String, String]]
 #      Replacement string. Can contain backreferences to what was matched using \\0 (whole match),
 #      \\1 (first set of parentheses), and so on.
-# @param flags [String]
+#      If the second argument is a Hash, and the matched text is one of its keys, the corresponding value is the replacement string.
+# @param flags [Optional[Pattern[/^[GEIM]*$/]], Pattern[/^G?$/]]
 #      Optional. String of single letter flags for how the regexp is interpreted (E, I, and M cannot be used
 #      if pattern is a precompiled regexp):
 #        - *E*         Extended regexps
 #        - *I*         Ignore case in regexps
 #        - *M*         Multiline regexps
 #        - *G*         Global replacement; all occurrences of the regexp in each target string will be replaced.  Without this, only the first occurrence will be replaced.
-# @param encoding [String]
+# @param encoding [Enum['N','E','S','U']]
 #      Optional. How to handle multibyte characters when compiling the regexp (must not be used when pattern is a
 #      precompiled regexp). A single-character string with the following values:
 #        - *N*         None
 #        - *E*         EUC
 #        - *S*         SJIS
 #        - *U*         UTF-8
-# @return [Array[String]|String] The result of the substitution. Result type is the same as for the target parameter.
+# @return [Array[String], String] The result of the substitution. Result type is the same as for the target parameter.
+#
+# @example Get the third octet from the node's IP address:
+#     $i3 = regsubst($ipaddress,'^(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)$','\\3')
+#
+# @example Put angle brackets around each octet in the node's IP address:
+#     $x = regsubst($ipaddress, /([0-9]+)/, '<\\1>', 'G')
 #
 Puppet::Functions.create_function(:regsubst) do
   dispatch :regsubst_string do
-    param          'Variant[Array[String],String]',  :target
-    param          'String',                         :pattern
-    param          'String',                         :replacement
-    optional_param 'Optional[Pattern[/^[GEIM]*$/]]', :flags
-    optional_param "Enum['N','E','S','U']",          :encoding
+    param          'Variant[Array[String],String]',       :target
+    param          'String',                              :pattern
+    param          'Variant[String,Hash[String,String]]', :replacement
+    optional_param 'Optional[Pattern[/^[GEIM]*$/]]',      :flags
+    optional_param "Enum['N','E','S','U']",               :encoding
   end
 
   dispatch :regsubst_regexp do
-    param          'Variant[Array[String],String]',  :target
-    param          'Variant[Regexp,Type[Regexp]]',   :pattern
-    param          'String',                         :replacement
-    optional_param 'Pattern[/^G?$/]',                :flags
+    param          'Variant[Array[String],String]',       :target
+    param          'Variant[Regexp,Type[Regexp]]',        :pattern
+    param          'Variant[String,Hash[String,String]]', :replacement
+    optional_param 'Pattern[/^G?$/]',                     :flags
   end
 
   def regsubst_string(target, pattern, replacement, flags = nil, encoding = nil)
@@ -68,7 +65,7 @@ Puppet::Functions.create_function(:regsubst) do
   end
 
   def regsubst_regexp(target, pattern, replacement, flags = nil)
-    pattern = pattern.pattern if pattern.is_a?(Puppet::Pops::Types::PRegexpType)
+    pattern = (pattern.pattern || '') if pattern.is_a?(Puppet::Pops::Types::PRegexpType)
     inner_regsubst(target, pattern, replacement, operation = flags == 'G' ? :gsub : :sub)
   end
 

data/lib/puppet/functions/require.rb

@@ -0,0 +1,37 @@
+# Requires the specified classes
+# For documentation see the 3.x function stub
+Puppet::Functions.create_function(:require, Puppet::Functions::InternalFunction) do
+  dispatch :require_impl 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 require_impl(scope, *classes)
+    # Make call patterns uniform and protected against nested arrays, also make
+    # names absolute if so desired.
+    classes = scope.transform_and_assert_classnames(classes.flatten)
+
+    result = classes.map {|name| Puppet::Pops::Types::TypeFactory.host_class(name) }
+
+    # This is the same as calling the include function (but faster) since it again
+    # would otherwise need to perform the optional absolute name transformation
+    # (for no reason since they are already made absolute here).
+    #
+    scope.compiler.evaluate_classes(classes, scope, false)
+    krt = scope.environment.known_resource_types
+
+    classes.each do |klass|
+      # lookup the class in the scopes
+      klass = (classobj = krt.find_hostclass(klass)) ? classobj.name : nil
+      raise Puppet::ParseError.new("Could not find class #{klass}") unless klass
+      ref = Puppet::Resource.new(:class, klass)
+      resource = scope.resource
+      resource.set_parameter(:require, [resource[:require]].flatten.compact << ref)
+    end
+    result
+  end
+end

data/lib/puppet/functions/return.rb

@@ -0,0 +1,22 @@
+# Make iteration continue with the next value optionally given a value for this iteration.
+# If a value is not given it defaults to `undef`
+#
+# @since 4.7.0
+#
+Puppet::Functions.create_function(:return, Puppet::Functions::InternalFunction) do
+  dispatch :return_impl do
+    optional_param 'Any', :value
+  end
+
+  def return_impl(value = nil)
+    stacktrace = Puppet::Pops::PuppetStack.stacktrace()
+    if stacktrace.size > 0
+      file, line = stacktrace[0]
+    else
+      file = nil
+      line = nil
+    end
+
+    raise Puppet::Pops::Evaluator::Return.new(value, file, line)
+  end
+end

data/lib/puppet/functions/reverse_each.rb

@@ -0,0 +1,25 @@
+# Reverses the order of the elements of something that is iterable.
+# (Documentation in 3.x stub)
+#
+# @since 4.4.0
+#
+Puppet::Functions.create_function(:reverse_each) do
+  dispatch :reverse_each do
+    param 'Iterable', :iterable
+  end
+
+  dispatch :reverse_each_block do
+    param 'Iterable', :iterable
+    block_param 'Callable[1,1]', :block
+  end
+
+  def reverse_each(iterable)
+    # produces an Iterable
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).reverse_each
+  end
+
+  def reverse_each_block(iterable, &block)
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).reverse_each(&block)
+    nil
+  end
+end

data/lib/puppet/functions/scanf.rb

@@ -1,23 +1,16 @@
-# Scans a string and returns an array of one or more converted values as directed by a given format string.args
-# See the documenation of Ruby's String::scanf method for details about the supported formats (which
-# are similar but not identical to the formats used in Puppet's `sprintf` function.
-#
-# This function takes two mandatory arguments: the first is the String to convert, and the second
-# the format String. A parameterized block may optionally be given, which is called with the result
-# that is produced by scanf if no block is present, the result of the block is then returned by
-# the function.
-#
-# The result of the scan is an Array, with each sucessfully scanned and transformed value.args The scanning
-# stops if a scan is unsuccesful and the scanned result up to that point is returned. If there was no
-# succesful scan at all, the result is an empty Array. The optional code block is typically used to
-# assert that the scan was succesful, and either produce the same input, or perform unwrapping of
-# the result
-#
-# @example scanning an integer in string form (result is an array with
-#   integer, or empty if  unsuccessful)
+# Scans a string and returns an array of one or more converted values based on the given format string.
+# See the documentation of Ruby's String#scanf method for details about the supported formats (which
+# are similar but not identical to the formats used in Puppet's `sprintf` function.)
+#
+# This function takes two mandatory arguments: the first is the string to convert, and the second is
+# the format string. The result of the scan is an array, with each successfully scanned and transformed value.
+# The scanning stops if a scan is unsuccessful, and the scanned result up to that point is returned. If there
+# was no successful scan, the result is an empty array.
+#
 #    "42".scanf("%i")
 #
-# @example scanning and processing resulting array to assert result and unwrap
+# You can also optionally pass a lambda to scanf, to do additional validation or processing.
+#
 #
 #     "42".scanf("%i") |$x| {
 #       unless $x[0] =~ Integer {
@@ -26,6 +19,10 @@
 #       $x[0]
 #     }
 #
+#
+#
+#
+#
 # @since 4.0.0
 #
 Puppet::Functions.create_function(:scanf) do

data/lib/puppet/functions/slice.rb

@@ -1,51 +1,45 @@
-# Applies a parameterized block to each _slice_ of elements in a sequence of selected entries from the first
-# argument and returns the first argument, or if no block is given returns a new array with a concatenation of
-# the slices.
+# This function takes two mandatory arguments: the first should be an array or hash, and the second specifies
+# the number of elements to include in each slice.
 #
-# This function takes two mandatory arguments: the first, `$a`, should be an Array, Hash, or something of
-# enumerable type (integer, Integer range, or String), and the second, `$n`, the number of elements to include
-# in each slice. The optional third argument should be a a parameterized block as produced by the puppet syntax:
-#
-#     $a.slice($n) |$x| { ... }
-#     slice($a) |$x| { ... }
-#
-# The parameterized block should have either one parameter (receiving an array with the slice), or the same number
-# of parameters as specified by the slice size (each parameter receiving its part of the slice).
-# In case there are fewer remaining elements than the slice size for the last slice it will contain the remaining
-# elements. When the block has multiple parameters, excess parameters are set to undef for an array or
-# enumerable type, and to empty arrays for a Hash.
-#
-#     $a.slice(2) |$first, $second| { ... }
-#
-# When the first argument is a Hash, each `key,value` entry is counted as one, e.g, a slice size of 2 will produce
+# When the first argument is a hash, each key value pair is counted as one. For example, a slice size of 2 will produce
 # an array of two arrays with key, and value.
 #
-# @example Using slice with Hash
-#
 #     $a.slice(2) |$entry|          { notice "first ${$entry[0]}, second ${$entry[1]}" }
 #     $a.slice(2) |$first, $second| { notice "first ${first}, second ${second}" }
 #
-# When called without a block, the function produces a concatenated result of the slices.
-#
-# @example Using slice without a block
+# The function produces a concatenated result of the slices.
 #
 #     slice([1,2,3,4,5,6], 2) # produces [[1,2], [3,4], [5,6]]
 #     slice(Integer[1,6], 2)  # produces [[1,2], [3,4], [5,6]]
 #     slice(4,2)              # produces [[0,1], [2,3]]
 #     slice('hello',2)        # produces [[h, e], [l, l], [o]]
 #
+#
+# You can also optionally pass a lambda to slice.
+#
+#     $a.slice($n) |$x| { ... }
+#     slice($a) |$x| { ... }
+#
+# The lambda should have either one parameter (receiving an array with the slice), or the same number
+# of parameters as specified by the slice size (each parameter receiving its part of the slice).
+# If there are fewer remaining elements than the slice size for the last slice, it will contain the remaining
+# elements. If the lambda has multiple parameters, excess parameters are set to undef for an array, or
+# to empty arrays for a hash.
+#
+#     $a.slice(2) |$first, $second| { ... }
+#
 # @since 4.0.0
 #
 Puppet::Functions.create_function(:slice) do
   dispatch :slice_Hash do
     param 'Hash[Any, Any]', :hash
-    param 'Integer[1, default]', :slize_size
+    param 'Integer[1, default]', :slice_size
     optional_block_param
   end
 
   dispatch :slice_Enumerable do
-    param 'Any', :enumerable
-    param 'Integer[1, default]', :slize_size
+    param 'Iterable', :enumerable
+    param 'Integer[1, default]', :slice_size
     optional_block_param
   end
 
@@ -55,7 +49,7 @@ Puppet::Functions.create_function(:slice) do
   end
 
   def slice_Enumerable(enumerable, slice_size, &pblock)
-    enum = asserted_enumerable(enumerable)
+    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
     result = slice_Common(enum, slice_size, nil, block_given? ? pblock : nil)
     block_given? ? enumerable : result
   end
@@ -114,12 +108,4 @@ Puppet::Functions.create_function(:slice) do
     end
     serving_size
   end
-
-  def asserted_enumerable(obj)
-    unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
-      raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
-    end
-    enum
-  end
-
 end

data/lib/puppet/functions/split.rb

@@ -6,7 +6,7 @@
 #     $string     = 'v1.v2:v3.v4'
 #     $array_var1 = split($string, /:/)
 #     $array_var2 = split($string, '[.]')
-#     $array_var3 = split($string, Regexp('[.:]'))
+#     $array_var3 = split($string, Regexp['[.:]'])
 #
 # `$array_var1` now holds the result `['v1.v2', 'v3.v4']`,
 # while `$array_var2` holds `['v1', 'v2:v3', 'v4']`, and
@@ -15,7 +15,7 @@
 # Note that in the second example, we split on a literal string that contains
 # a regexp meta-character (.), which must be escaped.  A simple
 # way to do that for a single character is to enclose it in square
-# brackets; a backslash will also escape a single character.") do |args|
+# brackets; a backslash will also escape a single character.
 #
 Puppet::Functions.create_function(:split) do
   dispatch :split_String do
@@ -42,6 +42,6 @@ Puppet::Functions.create_function(:split) do
   end
 
   def split_RegexpType(str, pattern)
-    str.split(pattern.pattern)
+    str.split(pattern.regexp)
   end
 end

data/lib/puppet/functions/step.rb

@@ -0,0 +1,26 @@
+# (Documentation in 3.x stub)
+#
+# @since 4.4.0
+#
+Puppet::Functions.create_function(:step) do
+  dispatch :step do
+    param 'Iterable', :iterable
+    param 'Integer[1]', :step
+  end
+
+  dispatch :step_block do
+    param 'Iterable', :iterable
+    param 'Integer[1]', :step
+    block_param 'Callable[1,1]', :block
+  end
+
+  def step(iterable, step)
+    # produces an Iterable
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).step(step)
+  end
+
+  def step_block(iterable, step, &block)
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).step(step, &block)
+    nil
+  end
+end

data/lib/puppet/functions/strftime.rb

@@ -0,0 +1,35 @@
+# (Documentation in 3.x stub)
+#
+# @since 4.8.0
+#
+Puppet::Functions.create_function(:strftime) do
+  dispatch :format_timespan do
+    param 'Timespan', :time_object
+    param 'String', :format
+  end
+
+  dispatch :format_timestamp do
+    param 'Timestamp', :time_object
+    param 'String', :format
+    optional_param 'String', :timezone
+  end
+
+  dispatch :legacy_strftime do
+    param 'String', :format
+    optional_param 'String', :timezone
+  end
+
+  def format_timespan(time_object, format)
+    time_object.format(format)
+  end
+
+  def format_timestamp(time_object, format, timezone = nil)
+    time_object.format(format, timezone)
+  end
+
+  def legacy_strftime(format, timezone = nil)
+    Puppet.warn_once('deprecation', 'legacy#strftime',
+      'The argument signature (String format, [String timezone]) is deprecated for #strfime. See #strftime documentation and Timespan type for more info')
+    Puppet::Pops::Time::Timestamp.format_time(format, Time.now.utc, timezone)
+  end
+end

data/lib/puppet/functions/then.rb

@@ -0,0 +1,14 @@
+# (Documented in 3.x stub)
+# @since 4.5.0
+#
+Puppet::Functions.create_function(:then) do
+  dispatch :then do
+    param 'Any', :arg
+    block_param 'Callable[1,1]', :block
+  end
+
+  def then(arg)
+    return nil if arg.nil?
+    yield(arg)
+  end
+end