puppet-retrospec 1.5.0 → 1.6.0

data/vendor/gems/puppet-4.5.2/lib/puppet/functions/hiera_hash.rb

@@ -1,84 +0,0 @@
-require 'hiera/puppet_function'
-
-# 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).
-#
-# 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 documentation](https://docs.puppetlabs.com/hiera/latest/puppet.html#hiera-lookup-functions)
-# for more information about Hiera lookup functions.
-#
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:hiera_hash, Hiera::PuppetFunction) do
-  init_dispatch
-
-  def merge_type
-    :hash
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/functions/hiera_include.rb

@@ -1,90 +0,0 @@
-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.
-#
-# 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 documentation](http://links.puppetlabs.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
-#
-Puppet::Functions.create_function(:hiera_include, Hiera::PuppetFunction) do
-  init_dispatch
-
-  def merge_type
-    :array
-  end
-
-  def post_lookup(scope, key, value)
-    raise Puppet::ParseError, "Could not find data item #{key}" if value.nil?
-    call_function_with_scope(scope, 'include', value) unless value.empty?
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/functions/lest.rb

@@ -1,53 +0,0 @@
-# Call a [lambda](https://docs.puppet.com/puppet/latest/reference/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`, otherwwise the
-# given argument.
-#
-# The `lest` function is useful in a chain of `then` calls, or in general
-# as a guard against `undef` values. The function can be used to call `fail`, or to
-# return a default value.
-#
-# These two expressions are equivalent:
-# ~~~puppet
-# if $x == undef { do_things() }
-# lest($x) || { do_things() }
-# ~~
-#
-# @example Using `lest`
-#
-# ~~~ puppet
-# $data = {a => [ b, c ] }
-# notice $data.dig(a, b, c)
-#  .then |$x| { $x * 2 }
-#  .lest || { fail("no value for $data[a][b][c]" }
-# ~~~
-#
-# Would fail the operation because $data[a][b][c] results in `undef`
-#
-# In contrast - this example:
-#
-# ~~~ puppet
-# $data = {a => { b => { c => 10 } } }
-# notice $data.dig(a, b, c)
-#  .then |$x| { $x * 2 }
-#  .lest || { fail("no value for $data[a][b][c]" }
-# ~~~
-#
-# Would notice the value 20
-#
-# @since 4.5.0
-#
-Puppet::Functions.create_function(:lest) do
-  dispatch :lest do
-    param 'Any', :arg
-    block_param 'Callable[0,0]', :block
-  end
-
-  def lest(arg)
-    if arg.nil?
-      yield()
-    else
-      arg
-    end
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/functions/new.rb

@@ -1,502 +0,0 @@
-# Creates a new instance/object of a given type.
-#
-# This functions makes it possible to create new instances of
-# concrete types. If a block is given it is called with the
-# just created instance as an argument.
-#
-# Calling this function is equivalent to directly
-# calling the type:
-#
-# @ example new and calling type directly are equivalent
-#
-# ~~~ puppet
-# $a = Integer.new("42")
-# $b = Integer("42")
-# ~~~
-#
-# This would convert the string "42" to the decimal value 42.
-#
-# @ example arguments by position or by name
-#
-# ~~~ puppet
-# $a = Integer.new("42", 8)
-# $b = Integer({from => "42", radix => 8})
-# ~~~
-#
-# This would convert the octal (radix 8) number "42" in string form
-# to the decimal value 34.
-#
-# The new function supports two ways of giving the arguments:
-#
-# * by name (using a hash with property to value mapping)
-# * by position (as regular arguments)
-#
-# Note that it is not possible to create new instances of
-# some abstract classes (e.g. `Variant`). The type Optional[T] is an
-# exception as it will create an instance of T or `undef` if the
-# value to convert is `undef`.
-#
-# The arguments that can be given to each type is
-# determined by the type.
-#
-# An assertion is always made that
-# the produced value complies with the given type constraints.
-#
-# @example type constraints are checked:
-#
-# ~~~ puppet
-#  Integer[0].new("-100")
-# ~~~
-# 
-# Would fail with an assertion error.
-#
-# The following sections show the arguments and conversion rules
-# per type built into the Puppet Type System.
-#
-# Conversion to Optional[T] and NotUndef[T]
-# -----------------------------------------
-# Conversion to these types is the same as a conversion to the type argument `T`. In the case of `Optional[T]`
-# it accepted that the result may be `undef` (i.e. not possible to convert).
-#
-# 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. 
-#
-# ~~~ puppet
-# type Radix = Variant[Default, Integer[2,2], Integer[8,8], Integer[10,10], Integer[16,16]]
-# Callable[String, Radix, 1, 2]
-# Callable[Variant[Numeric, Boolean]]
-# ~~~
-# 
-# * When converting from String the default radix is 10
-# * If radix is not specified an attempt is made to detect the radix from the start of the string:
-#   * `0b` or `0B` is taken as radix 2, 
-#   * `0x` or `0X` is taken as radix 16, 
-#   * `0` as radix 8,
-#   * all other are decimal 
-# * Conversion from String accepts an optional sign in the string.
-# * For hexadecimal (radix 16) conversion an optional leading "0x", or "0X" is accepted
-# * for octal (radix 8) an optional leading "0" is accepted
-# * for binary (radix 2) an optional leading "0b" or "0B" is accepted
-# * When `radix` is set to `default`, the conversion is based on the leading
-#   characters in the string. A leading "0" for radix 8, a leading "0x", or "0X" for
-#   radix 16, and leading "0b" or "0B" for binary.
-# * Conversion from Boolean results in 0 for `false` and 1 for `true`.
-# * Conversion from Integer, Float, and Boolean ignores the radix.
-# * Float value fractions are truncated (no rounding)
-#
-# @example Converting to Integer
-#
-# ~~~ puppet
-# $a_number = Integer("0xFF", 16)  # results in 255
-# $a_number = Numeric("010")       # results in 8
-# $a_number = Numeric("010", 10)   # results in 10
-# $a_number = Integer("true")      # results in 1
-# ~~~
-#
-# 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.
-#
-# * 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'). 
-#
-# Conversion to Numeric
-# ---------------------
-#
-# A new Integer or Float can be created from Integer, Float, Boolean and
-# String values.
-#
-# ~~~ puppet
-# Callable[Variant[Numeric, Boolean, String]]
-# ~~~
-#
-# * If the value has a decimal period, or if given in scientific notation
-#   (e/E), the result is a `Float`, otherwise the value is an `Integer`. The
-#   conversion from `String` always uses a radix based on the prefix of the string.
-# * Conversion from Boolean results in 0 for `false` and 1 for `true`.
-#
-# @example Converting to Numeric
-#
-# ~~~ puppet
-# $a_number = Numeric("true")  # results in 1
-# $a_number = Numeric("0xFF")  # results in 255
-# $a_number = Numeric("010")   # results in 8
-# $a_number = Numeric("3.14")  # results in 3.14 (a float)
-# ~~~
-# 
-# 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
-# have been chosen with care to be the most basic "value in textual form" representation.
-#
-# A new String can be created from all other data types. The process is performed in
-# several steps - first the type of the given value is inferred, then the resulting type
-# is used to find the most significant format specified for that type. And finally,
-# the found format is used to convert the given value.
-#
-# The mapping from type to format is referred to as the format map. This map
-# allows different formatting depending on type.
-#
-# @example Positive Integers in Hexadecimal prefixed with '0x', negative in Decimal
-#
-# ~~~ puppet
-# $format_map = { Integer[default, 0] => "%d",
-#   Integer[1, default] => "%#x"
-# }
-# String("-1", $format_map)  # produces '-1'
-# String("10", $format_map)  # produces '0xa'
-# ~~~
-#
-# A format is specified on the form:
-#
-# ~~~
-# %[Flags][Width][.Precision]Format
-# ~~~
-#
-# `Width` is the number of characters into which the value should be fitted. This allocated space is
-# padded if value is shorter. By default it is space padded, and the flag 0 will cause padding with 0
-# for numerical formats.
-#
-# `Precision` is the number of fractional digits to show for floating point, and the maximum characters
-# included in a string format.
-#
-# Note that all data type supports the formats `s` and `p` with the meaning "default to string" and
-# "default programmatic string representation" (which for example means that a String is quoted in 'p' format).
-#
-# ### Signatures of String conversion
-#
-# ~~~ puppet
-# type Format = Pattern[/^%([\s\+\-#0\[\{<\(\|]*)([1-9][0-9]*)?(?:\.([0-9]+))?([a-zA-Z])/]
-# type ContainerFormat = Struct[{
-#   format         => Optional[String],
-#   separator      => Optional[String],
-#   separator2     => Optional[String],
-#   string_formats => Hash[Type, Format]
-#   }]
-# type TypeMap = Hash[Type, Variant[Format, ContainerFormat]]
-# type Formats = Variant[Default, String[1], TypeMap]
-#
-# Callable[Any, Formats]
-# ~~~
-#
-# Where:
-# * `separator` is the string used to separate entries in an array, or hash (extra space should not be included at
-#   then end), defaults to `","`
-# * `separator2` is the separator between key and value in a hash entry (space padding should be included as
-#   wanted), defaults to `" => ".
-# * `string_formats` is a type to format map for values contained in arrays and hashes - defaults to `{Any => "%p"}`. Note that
-#   these nested formats are not applicable to containers which are always formatted as per the top level format specification.
-#
-# @example Simple Conversion to String (using defaults)
-#
-# ~~~ puppet
-# $str = String(10)      # produces '10'
-# $str = String([10])    # produces '["10"]'
-# ~~~
-#
-# @example Simple Conversion to String specifying the format for the given value directly
-#
-# ~~~ puppet
-# $str = String(10, "%#x")    # produces '0x10'
-# $str = String([10], "%(a")  # produces '("10")'
-# ~~~
-#
-# @example Specifying type for values contained in an array
-#
-# ~~~ puppet
-# $formats = { Array => {format => '%(a', string_formats => { Integer => '%#x' } }
-# $str = String([1,2,3], $formats) # produces '(0x1, 0x2, 0x3)'
-# ~~~
-#
-# 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
-#
-# | Format  | Integer Formats
-# | ------  | ---------------
-# | d       | Decimal, negative values produces leading '-'
-# | x X     | Hexadecimal in lower or upper case. Uses ..f/..F for negative values unless # is also used
-# | o       | Octal. Uses ..0 for negative values unless # is also used
-# | b B     | Binary with prefix 'b' or 'B'. Uses ..1/..1 for negative values unless # is also used
-# | c       | numeric value representing a Unicode value, result is a one unicode character string, quoted if alternative flag # is used
-# | s       | same as d, or d in quotes if alternative flag # is used
-# | p       | same as d
-# | eEfgGaA | converts integer to float and formats using the floating point rules
-#
-# Defaults to `d`
-#
-# ### Float to String
-#
-# | Format  | Float formats
-# | ------  | -------------
-# | f       | floating point in non exponential notation
-# | e E     | exponential notation with 'e' or 'E'
-# | g G     | conditional exponential with 'e' or 'E' if exponent < -4 or >= the precision
-# | a A     | hexadecimal exponential form, using 'x'/'X' as prefix and 'p'/'P' before exponent
-# | s       | converted to string using format p, then applying string formatting rule, alternate form # quotes result
-# | p       | f format with minimum significant number of fractional digits, prec has no effect
-# | dxXobBc | converts float to integer and formats using the integer rules
-#
-# Defaults to `p`
-#
-# ### String to String
-#
-# | Format | String
-# | ------ | ------
-# | s      | unquoted string, verbatim output of control chars
-# | p      | programmatic representation - strings are quoted, interior quotes and control chars are escaped
-# | C      | each :: name segment capitalized, quoted if alternative flag # is used
-# | c      | capitalized string, quoted if alternative flag # is used
-# | d      | downcased string, quoted if alternative flag # is used
-# | u      | upcased string, quoted if alternative flag # is used
-# | t      | trims leading and trailing whitespace from the string, quoted if alternative flag # is used
-#
-# Defaults to `s` at top level and `p` inside array or hash.
-#
-# ### Boolean to String
-# 
-# | Format    | Boolean Formats
-# | ----      | -------------------   
-# | t T       | 'true'/'false' or 'True'/'False' , first char if alternate form is used (i.e. 't'/'f' or 'T'/'F').
-# | y Y       | 'yes'/'no', 'Yes'/'No', 'y'/'n' or 'Y'/'N' if alternative flag # is used
-# | dxXobB    | numeric value 0/1 in accordance with the given format which must be valid integer format
-# | eEfgGaA   | numeric value 0.0/1.0 in accordance with the given float format and flags
-# | s         | 'true' / 'false'
-# | p         | 'true' / 'false'
-#
-# ### Regexp to String
-#
-# | Format    | Regexp Formats (%/)
-# | ----      | ------------------
-# | s         | / / delimiters, alternate flag replaces / delimiters with quotes
-# | p         | / / delimiters
-#
-# ### Undef to String
-#
-# | Format    | Undef formats
-# | ------    | -------------
-# | s         | empty string, or quoted empty string if alternative flag # is used
-# | p         | 'undef', or quoted '"undef"' if alternative flag # is used
-# | n         | 'nil', or 'null' if alternative flag # is used
-# | dxXobB    | 'NaN'
-# | eEfgGaA   | 'NaN'
-# | v         | 'n/a'
-# | V         | 'N/A'
-# | u         | 'undef', or 'undefined' if alternative # flag is used
-#
-# ### Default value to String
-# 
-# | Format    | Default formats
-# | ------    | ---------------
-# | d D       | 'default' or 'Default', alternative form # causes value to be quoted
-# | s         | same as d
-# | p         | same as d
-#
-# ### Array & Tuple to String
-#
-# | Format    | Array/Tuple Formats
-# | ------    | -------------
-# | a         | formats with `[ ]` delimiters and `,`, alternate form `#` indents nested arrays/hashes
-# | s         | same as a
-# | p         | same as a
-#
-# See "Flags" `<[({\|` for formatting of delimiters, and "Additional parameters for containers; Array and Hash" for
-# more information about options.
-#
-# The alternate form flag `#` will cause indentation of nested array or hash containers. If width is also set
-# 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
-#
-# | Format    | Hash/Struct Formats
-# | ------    | -------------
-# | h         | formats with `{ }` delimiters, `,` element separator and ` => ` inner element separator unless overridden by flags 
-# | s         | same as h
-# | p         | same as h
-# | a         | converts the hash to an array of [k,v] tuples and formats it using array rule(s)
-# 
-# See "Flags" `<[({\|` for formatting of delimiters, and "Additional parameters for containers; Array and Hash" for
-# more information about options.
-#
-# The alternate form flag `#` will format each hash key/value entry indented on a separate line.
-#
-# ### 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
-#
-# | Flag     | Effect 
-# | ------   | ------
-# | (space)  | space instead of + for numeric output (- is shown), for containers skips delimiters
-# | #        | alternate format; prefix 0x/0x, 0 (octal) and 0b/0B for binary, Floats force decimal '.'. For g/G keep trailing 0.
-# | +        | show sign +/- depending on value's sign, changes x,X, o,b, B format to not use 2's complement form
-# | -        | left justify the value in the given width
-# | 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
-# ---
-#
-# Accepts a single value as argument:
-# * Float 0.0 is `false`, all other float values are `true`
-# * Integer 0 is `false`, all other integer values are `true`
-# * Strings
-#   * `true` if 'true', 'yes', 'y' (case independent compare)
-#   * `false` if 'false', 'no', 'n' (case independent compare)
-# * Boolean is already boolean and is simply returned
-#
-# Conversion to Array and Tuple
-# ---
-#
-# When given a single value as argument:
-#
-# * A non empty `Hash` is converted to an array matching `Array[Tuple[Any,Any], 1]`
-# * An empty `Hash` becomes an empty array
-# * An `Array` is simply returned
-# * An `Iterable[T]` is turned into an array of `T` instances
-#
-# When given a second Boolean argument
-# * if `true`, a value that is not already an array is returned as a one element array
-# * if `false`, (the default), converts the first argument as shown above.
-#
-# @example ensuring value is array
-#
-# ~~~ puppet
-# $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
-# ---
-# Accepts a single value as argument:
-#
-# * An empty `Array` becomes an empty hash
-# * An `Array` matching `Array[Tuple[Any,Any], 1]` is converted to a hash where each tuple describes a key/value entry
-# * An `Array` with an even number of entries is interpreted as `[key1, val1, key2, val2, ...]`
-# * An `Iterable` is turned into an `Array` and then converted to hash as per the array rules
-# * A `Hash` is simply returned
-#
-# Conversion to a `Struct` works exactly as conversion to a `Hash`, only that the constructed hash is
-# asserted against the given struct type.
-#
-# 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.
-# See the specification at [semver.org](http://semver.org/) for the meaning of the SemVer's parts.
-#
-# The signatures are:
-#
-# ~~~ puppet
-#
-# type PositiveInteger = Integer[0,default]
-# type SemVerQualifier = Pattern[/\A(?<part>[0-9A-Za-z-]+)(?:\.\g<part>)*\Z/]
-# type SemVerString = String[1]
-# type SemVerHash =Struct[{
-#   major                => PositiveInteger,
-#   minor                => PositiveInteger,
-#   patch                => PositiveInteger,
-#   Optional[prerelease] => SemVerQualifier,
-#   Optional[build]      => SemVerQualifier
-# }]
-# 
-# function SemVer.new(SemVerString $str)
-# function SemVer.new(
-#         PositiveInteger           $major
-#         PositiveInteger           $minor
-#         PositiveInteger           $patch
-#         Optional[SemVerQualifier] $prerelease = undef
-#         Optional[SemVerQualifier] $build = undef
-#         )
-# function SemVer.new(SemVerHash $hash_args)
-#
-# ~~~
-#
-# Examples of SemVer and SemVerRange usage:
-#
-# ~~~ puppet
-#
-# # As a type, SemVer can describe disjunct ranges which versions can be matched
-# # against - here the type is constructed with two SemVerRange objects.
-# $t = SemVer[SemVerRange('>=1.0.0 <2.0.0'), SemVerRange('>=3.0.0 <4.0.0')]
-# notice(SemVer('1.2.3') =~ $t) # true
-# notice(SemVer('2.3.4') =~ $t) # false
-# notice(SemVer('3.4.5') =~ $t) # true
-#
-# ~~~
-#
-# Creating a SemVerRange
-# ---
-# A SemVerRange object represents a range of SemVer. It can be created from
-# a String, from two SemVer instances, where either end can be given as
-# a literal `default` to indicate infinity. The string format of a SemVerRange is specified by
-# the [Semantic Version Range Grammar](https://github.com/npm/node-semver#ranges).
-# Use of the comparator sets described in the grammar (joining with `||`) is not supported.
-#
-# The signatures are:
-#
-# ~~~ puppet
-# type SemVerRangeString = String[1]
-# type SemVerRangeHash = Struct[{
-#   min                   => Variant[default, SemVer],
-#   Optional[max]         => Variant[default, SemVer],
-#   Optional[exclude_max] => Boolean
-# }]
-# 
-# function SemVerRange.new( SemVerRangeString $semver_range_string)
-# 
-# function SemVerRange.new(
-#               Variant[default,SemVer] $min
-#               Variant[default,SemVer] $max
-#               Optional[Boolean]       $exclude_max = undef
-#             }
-# function SemVerRange.new(SemVerRangeHash $semver_range_hash)
-# ~~~
-#
-# For examples, see `SemVer.new`.
-#
-# @since 4.5.0
-#
-Puppet::Functions.create_function(:new, Puppet::Functions::InternalFunction) do
-
-  dispatch :new_instance do
-    scope_param
-    param          'Type', :type
-    repeated_param 'Any',  :args
-    optional_block_param
-  end
-
-  def new_instance(scope, t, *args)
-    result = catch :undefined_value do
-      new_function_for_type(t, scope).call(scope, *args)
-    end
-    assert_type(t, result)
-    return block_given? ? yield(result) : result
-  end
-
-  def new_function_for_type(t, scope)
-    @new_function_cache ||= Hash.new() {|hsh, key| hsh[key] = key.new_function(loader).new(scope, loader) }
-    @new_function_cache[t]
-  end
-
-  def assert_type(type, value)
-    Puppet::Pops::Types::TypeAsserter.assert_instance_of('new():', type, value)
-  end
-end