puppet 5.0.1-universal-darwin → 5.1.0-universal-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 273a35f20a1bb72a5cf393a7117114b92b70d20a
-  data.tar.gz: fde5abdeaf7dff7906811ebbaf5aa0eae45d291d
+  metadata.gz: bab00ee21fac0eeb13f59a189aa1b7a22e81593f
+  data.tar.gz: a756306c620cae863d386eb1f04b8f2e2cf1b992
 SHA512:
-  metadata.gz: 27dad1cda1fb27c0f679e8c5aae68d759e2c197ef8c61c4c820ccba879b113a21747ca21ea0faf3b000c9386def70d523765147f132c78e51d028d736aee0a28
-  data.tar.gz: 7b20f10677a845e905b05c6ae833c881e16198e4b81c0073306f25102c534aa33582891595917748faf50e75c61c675134b73aa767876440b881e0f2dbc04cde
+  metadata.gz: 9788f82dace26eeb426f045c705822c7070c649a1dc2e638859e1496717e5826669c1c3d48ed675dc6d76e0eef98945d91e945bf4ac7521090bce21a44db9ea2
+  data.tar.gz: 2af856c64dc1e95d1fc9bdb71968c71192f46579073e93b8e17dd861272655b12d3cfbaa3deb532ac9f2e8cb97fdf9e953a3ada7b1ff0572a4bca4e44ba390d3

data/lib/puppet/agent.rb

@@ -49,6 +49,7 @@ class Puppet::Agent
             return
           rescue StandardError => detail
             Puppet.log_exception(detail, _("Could not run %{client_class}: %{detail}") % { client_class: client_class, detail: detail })
+            1
           end
         end
       end

data/lib/puppet/defaults.rb

@@ -1047,7 +1047,7 @@ EOT
             the process table.",
       },
       :bindaddress => {
-        :default    => "0.0.0.0",
+        :default    => "*",
         :desc       => "The address a listening server should bind to.",
       }
   )

data/lib/puppet/functions.rb

@@ -301,7 +301,7 @@ module Puppet::Functions
 
     # @api private
     def self.builder
-      DispatcherBuilder.new(dispatcher, Puppet::Pops::Types::TypeParser.singleton, Puppet::Pops::Types::PCallableType::DEFAULT, loader)
+      DispatcherBuilder.new(dispatcher, Puppet::Pops::Types::PCallableType::DEFAULT, loader)
     end
 
     # Dispatch any calls that match the signature to the provided method name.
@@ -389,8 +389,7 @@ module Puppet::Functions
     attr_reader :loader
 
     # @api private
-    def initialize(dispatcher, type_parser, all_callables, loader)
-      @type_parser = type_parser
+    def initialize(dispatcher, all_callables, loader)
       @all_callables = all_callables
       @dispatcher = dispatcher
       @loader = loader
@@ -476,7 +475,7 @@ module Puppet::Functions
         name = type_and_name[0]
       when 2
         type_string, name = type_and_name
-        type = @type_parser.parse(type_string, loader)
+        type = Puppet::Pops::Types::TypeParser.singleton.parse(type_string, loader)
       else
         raise ArgumentError, _("block_param accepts max 2 arguments (type, name), got %{size}.") % { size: type_and_name.size }
       end
@@ -572,10 +571,10 @@ module Puppet::Functions
     # @api private
     def create_callable(types, block_type, return_type, from, to)
       mapped_types = types.map do |t|
-        @type_parser.parse(t, loader)
+        Puppet::Pops::Types::TypeParser.singleton.parse(t, loader)
       end
       param_types = Puppet::Pops::Types::PTupleType.new(mapped_types, from > 0 && from == to ? nil : Puppet::Pops::Types::PIntegerType.new(from, to))
-      return_type = @type_parser.parse(return_type, loader) unless return_type.nil?
+      return_type = Puppet::Pops::Types::TypeParser.singleton.parse(return_type, loader) unless return_type.nil?
       Puppet::Pops::Types::PCallableType.new(param_types, block_type, return_type)
     end
   end
@@ -646,7 +645,7 @@ module Puppet::Functions
   class InternalFunction < Function
     # @api private
     def self.builder
-      InternalDispatchBuilder.new(dispatcher, Puppet::Pops::Types::TypeParser.singleton, Puppet::Pops::Types::PCallableType::DEFAULT, loader)
+      InternalDispatchBuilder.new(dispatcher, Puppet::Pops::Types::PCallableType::DEFAULT, loader)
     end
 
     # Allows the implementation of a function to call other functions by name and pass the caller

data/lib/puppet/functions/all.rb

@@ -0,0 +1,100 @@
+# Runs a [lambda](http://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+# repeatedly using each value in a data structure until the lambda returns a non "truthy" value which
+# makes the function return `false`, or if the end of the iteration is reached, `true` is returned.
+#
+# 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 can
+# request one or two parameters.
+#
+# @example Using the `all` function
+#
+# `$data.all |$parameter| { <PUPPET CODE BLOCK> }`
+#
+# or
+#
+# `all($data) |$parameter| { <PUPPET CODE BLOCK> }`
+#
+# @example Using the `all` function with an Array and a one-parameter lambda
+#
+# ~~~ puppet
+# # For the array $data, run a lambda that checks that all values are multiples of 10
+# $data = [10, 20, 30]
+# notice $data.all |$item| { $item % 10 == 0 }
+# ~~~
+#
+# Would notice `true`.
+#
+# When the first argument is a `Hash`, Puppet passes each key and value pair to the lambda
+# as an array in the form `[key, value]`.
+#
+# @example Using the `all` function with a `Hash` and a one-parameter lambda
+#
+# ~~~ puppet
+# # For the hash $data, run a lambda using each item as a key-value array
+# $data = { 'a_0'=> 10, 'b_1' => 20 }
+# notice $data.all |$item| { $item[1] % 10 == 0  }
+# ~~~
+#
+# Would notice `true` if all values in the hash are multiples of 10.
+#
+# When the lambda accepts two arguments, the first argument gets the index in an array
+# or the key from a hash, and the second argument the value.
+#
+#
+# @example Using the `all` function with a hash and a two-parameter lambda
+#
+# ~~~ puppet
+# # Check that all values are a multiple of 10 and keys start with 'abc'
+# $data = {abc_123 => 10, abc_42 => 20, abc_blue => 30}
+# notice $data.all |$key, $value| { $value % 10 == 0  and $key =~ /^abc/ }
+# ~~~
+#
+# Would notice true.
+#
+# For an general examples that demonstrates iteration, see the Puppet
+# [iteration](https://docs.puppetlabs.com/puppet/latest/reference/lang_iteration.html)
+# documentation.
+#
+# @since 5.2.0
+#
+Puppet::Functions.create_function(:all) do
+  dispatch :all_Hash_2 do
+    param 'Hash[Any, Any]', :hash
+    block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :all_Hash_1 do
+    param 'Hash[Any, Any]', :hash
+    block_param 'Callable[1,1]', :block
+  end
+
+  dispatch :all_Enumerable_2 do
+    param 'Iterable', :enumerable
+    block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :all_Enumerable_1 do
+    param 'Iterable', :enumerable
+    block_param 'Callable[1,1]', :block
+  end
+
+  def all_Hash_1(hash)
+    hash.each_pair.all? { |x| yield(x) }
+  end
+
+  def all_Hash_2(hash)
+    hash.each_pair.all? { |x,y| yield(x,y) }
+  end
+
+  def all_Enumerable_1(enumerable)
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable).all? { |e| yield(e) }
+  end
+
+  def all_Enumerable_2(enumerable)
+    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
+    enum.each_with_index { |e, i| return false unless yield(i, e) }
+    true
+  end
+end

data/lib/puppet/functions/any.rb

@@ -0,0 +1,105 @@
+# Runs a [lambda](http://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+# repeatedly using each value in a data structure until the lambda returns a "truthy" value which
+# makes the function return `true`, or if the end of the iteration is reached, false is returned.
+#
+# 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 can
+# request one or two parameters.
+#
+# @example Using the `any` function
+#
+# `$data.any |$parameter| { <PUPPET CODE BLOCK> }`
+#
+# or
+#
+# `any($data) |$parameter| { <PUPPET CODE BLOCK> }`
+#
+# @example Using the `any` function with an Array and a one-parameter lambda
+#
+# ~~~ puppet
+# # For the array $data, run a lambda that checks if an unknown hash contains those keys
+# $data = ["routers", "servers", "workstations"]
+# $looked_up = lookup('somekey', Hash)
+# notice $data.any |$item| { $looked_up[$item] }
+# ~~~
+#
+# Would notice `true` if the looked up hash had a value that is neither `false` nor `undef` for at least
+# one of the keys. That is, it is equivalent to the expression
+# `$lookued_up[routers] || $looked_up[servers] || $looked_up[workstations]`.
+#
+# When the first argument is a `Hash`, Puppet passes each key and value pair to the lambda
+# as an array in the form `[key, value]`.
+#
+# @example Using the `any` function with a `Hash` and a one-parameter lambda
+#
+# ~~~ puppet
+# # For the hash $data, run a lambda using each item as a key-value array.
+# $data = {"rtr" => "Router", "svr" => "Server", "wks" => "Workstation"}
+# $looked_up = lookup('somekey', Hash)
+# notice $data.any |$item| { $looked_up[$item[0]] }
+# ~~~
+#
+# Would notice `true` if the looked up hash had a value for one of the wanted key that is
+# neither `false` nor `undef`.
+#
+# When the lambda accepts two arguments, the first argument gets the index in an array
+# or the key from a hash, and the second argument the value.
+#
+#
+# @example Using the `any` function with an array and a two-parameter lambda
+#
+# ~~~ puppet
+# # Check if there is an even numbered index that has a non String value
+# $data = [key1, 1, 2, 2]
+# notice $data.any |$index, $value| { $index % 2 == 0 and $value !~ String }
+# ~~~
+#
+# Would notice true as the index `2` is even and not a `String`
+#
+# For an general examples that demonstrates iteration, see the Puppet
+# [iteration](https://docs.puppetlabs.com/puppet/latest/reference/lang_iteration.html)
+# documentation.
+#
+# @since 5.2.0
+#
+Puppet::Functions.create_function(:any) do
+  dispatch :any_Hash_2 do
+    param 'Hash[Any, Any]', :hash
+    block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :any_Hash_1 do
+    param 'Hash[Any, Any]', :hash
+    block_param 'Callable[1,1]', :block
+  end
+
+  dispatch :any_Enumerable_2 do
+    param 'Iterable', :enumerable
+    block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :any_Enumerable_1 do
+    param 'Iterable', :enumerable
+    block_param 'Callable[1,1]', :block
+  end
+
+  def any_Hash_1(hash)
+    hash.each_pair.any? { |x| yield(x) }
+  end
+
+  def any_Hash_2(hash)
+    hash.each_pair.any? { |x,y| yield(x, y) }
+  end
+
+  def any_Enumerable_1(enumerable)
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable).any? { |e| yield(e) }
+  end
+
+  def any_Enumerable_2(enumerable)
+    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
+    enum.each_with_index { |e, i| return true if yield(i, e) }
+    false
+  end
+end

data/lib/puppet/functions/defined.rb

@@ -133,18 +133,18 @@ Puppet::Functions.create_function(:'defined', Puppet::Functions::InternalFunctio
         type = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, val.type_name)
         val.title.nil? ? type : scope.compiler.findresource(type, val.title)
 
-      when Puppet::Pops::Types::PHostClassType
+      when Puppet::Pops::Types::PClassType
         raise  ArgumentError, _('The given class type is a reference to all classes') if val.class_name.nil?
         scope.compiler.findresource(:class, val.class_name)
 
-      when Puppet::Pops::Types::PType
+      when Puppet::Pops::Types::PTypeType
         case val.type
         when Puppet::Pops::Types::PResourceType
           # It is most reasonable to take Type[File] and Type[File[foo]] to mean the same as if not wrapped in a Type
           # Since the difference between File and File[foo] already captures the distinction of type vs instance.
           is_defined(scope, val.type)
 
-        when Puppet::Pops::Types::PHostClassType
+        when Puppet::Pops::Types::PClassType
           # Interpreted as asking if a class (and nothing else) is defined without having to be included in the catalog
           # (this is the same as asking for just the class' name, but with the added certainty that it cannot be a defined type.
           #

data/lib/puppet/functions/new.rb

@@ -13,6 +13,7 @@ Puppet::Functions.create_function(:new, Puppet::Functions::InternalFunction) do
   end
 
   def new_instance(scope, t, *args)
+    return args[0] if args.size == 1 && !t.is_a?(Puppet::Pops::Types::PInitType) && t.instance?(args[0])
     result = catch :undefined_value do
       new_function_for_type(t, scope).call(scope, *args)
     end
@@ -21,7 +22,7 @@ Puppet::Functions.create_function(:new, Puppet::Functions::InternalFunction) do
   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 ||= Hash.new() {|hsh, key| hsh[key] = key.new_function.new(scope, loader) }
     @new_function_cache[t]
   end
 

data/lib/puppet/functions/reduce.rb

@@ -94,6 +94,37 @@
 # # $combine contains [dabc, 10]
 # ~~~
 #
+# @example Using the `reduce` function to reduce a hash of hashes
+#
+# ~~~ puppet
+# # Reduce a hash of hashes $data, merging defaults into the inner hashes.
+# $data = {
+#   'connection1' => {
+#     'username' => 'user1',
+#     'password' => 'pass1',
+#   },
+#   'connection_name2' => {
+#     'username' => 'user2',
+#     'password' => 'pass2',
+#   },
+# }
+#
+# $defaults = {
+#   'maxActive' => '20',
+#   'maxWait'   => '10000',
+#   'username'  => 'defaultuser',
+#   'password'  => 'defaultpass',
+# }
+#
+# $merged = $data.reduce( {} ) |$memo, $x| {
+#   $memo + { $x[0] => $defaults + $data[$x[0]] }
+# }
+# # At the start of the lambda's first iteration, $memo is set to {}, and $x is set to
+# # the first [key, value] tuple. The key in $data is, therefore, given by $x[0]. In
+# # subsequent rounds, $memo retains the value returned by the expression, i.e.
+# # $memo + { $x[0] => $defaults + $data[$x[0]] }.
+# ~~~
+#
 # @since 4.0.0
 #
 Puppet::Functions.create_function(:reduce) do

data/lib/puppet/functions/tree_each.rb

@@ -0,0 +1,200 @@
+# Runs a [lambda](http://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+# recursively and repeatedly using values from a data structure, then returns the unchanged data structure, or if
+# a lambda is not given, returns an `Iterator` for the tree.
+#
+# This function takes one mandatory argument, one optional, and an optional block in this order:
+#
+# 1. An `Array`, `Hash`, `Iterator`, or `Object` that the function will iterate over.
+# 2. An optional hash with the options:
+#    * `include_containers` => `Optional[Boolean]` # default true - if containers should be given to the lambda
+#    * `include_values` => `Optional[Boolean]` # default true - if non containers should be given to the lambda
+#    * `include_root` => `Optional[Boolean]` # default true - if the root container should be given to the lambda
+#    * `container_type` => `Optional[Type[Variant[Array, Hash, Object]]]` # a type that determines what a container is - can only
+#       be set to a type that matches the default `Variant[Array, Hash, Object]`.
+#    * `order` => `Enum[depth_first, breadth_first]` # default ´depth_first`, the order in which elements are visited
+#    * `include_refs` => Optional[Boolean] # default `false`, if attributes in objects marked as bing of `reference` kind
+#       should be included.
+# 3. An optional lambda, which the function calls for each element in the first argument. It must
+#    accept one or two arguments; either `$path`, and `$value`, or just `$value`.
+#
+# @example Using the `tree_each` function
+#
+# `$data.tree_each |$path, $value| { <PUPPET CODE BLOCK> }`
+# `$data.tree_each |$value| { <PUPPET CODE BLOCK> }`
+#
+# or
+#
+# `tree_each($data) |$path, $value| { <PUPPET CODE BLOCK> }`
+# `tree_each($data) |$value| { <PUPPET CODE BLOCK> }`
+#
+# The parameter `$path` is always given as an `Array` containing the path that when applied to
+# the tree as `$data.dig(*$path) yields the `$value`.
+# The `$value` is the value at that path.
+#
+# For `Array` values, the path will contain `Integer` entries with the array index,
+# and for `Hash` values, the path will contain the hash key, which may be `Any` value.
+# For `Object` containers, the entry is the name of the attribute (a `String`).
+#
+# The tree is walked in either depth-first order, or in breadth-first order under the control of the
+# `order` option, yielding each `Array`, `Hash`, `Object`, and each entry/attribute.
+# The default is `depth_first` which means that children are processed before siblings.
+# An order of `breadth_first` means that siblings are processed before children.
+#
+# @example depth- or breadth-first order
+#
+# ~~~ puppet
+# [1, [2, 3], 4]
+# ~~~
+# 
+# Results in:
+# 
+# If containers are skipped:
+#
+# * `depth_first` order `1`, `2`, `3`, `4` 
+# * `breadth_first` order `1`, `4`,`2`, `3` 
+#
+# If containers and root, are included:
+#
+# * `depth_first` order `[1, [2, 3], 4]`, `1`, `[2, 3]`, `2`, `3`, `4` 
+# * `breadth_first` order `[1, [2, 3], 4]`, `1`, `[2, 3]`, `4`, `2`, `3` 
+#
+# Typical use of the `tree_each` function include:
+# * a more efficient way to iterate over a tree than first using `flatten` on an array
+#   as that requires a new (potentially very large) array to be created
+# * when a tree needs to be transformed and 'pretty printed' in a template
+# * avoiding having to write a special recursive function when tree contains hashes (flatten does
+#   not work on hashes)
+#
+# @example A flattened iteration over a tree excluding Collections
+#
+# ~~~ puppet
+# $data = [1, 2, [3, [4, 5]]]
+# $data.tree_each({include_containers => false}) |$v| { notice "$v" }
+# ~~~
+#
+# This would call the lambda 5 times with with the following values in sequence: `1`, `2`, `3`, `4`, `5`
+#
+# @example A flattened iteration over a tree (including containers by default)
+#
+# ~~~ puppet
+# $data = [1, 2, [3, [4, 5]]]
+# $data.tree_each |$v| { notice "$v" }
+# ~~~
+#
+# This would call the lambda 7 times with the following values in sequence:
+# `1`, `2`, `[3, [4, 5]]`, `3`, `[4, 5]`, `4`, `5`
+#
+# @example A flattened iteration over a tree (including only non root containers)
+#
+# ~~~ puppet
+# $data = [1, 2, [3, [4, 5]]]
+# $data.tree_each({include_values => false, include_root => false}) |$v| { notice "$v" }
+# ~~~
+#
+# This would call the lambda 2 times with the following values in sequence:
+# `[3, [4, 5]]`, `[4, 5]`
+
+# Any Puppet Type system data type can be used to filter what is
+# considered to be a container, but it must be a narrower type than one of
+# the default Array, Hash, Object types - for example it is not possible to make a
+# `String` be a container type.
+#
+# @example Only `Array` as container type
+#
+# ~~~ puppet
+# $data = [1, {a => 'hello', b => [100, 200]}, [3, [4, 5]]]
+# $data.tree_each({container_type => Array, include_containers => false} |$v| { notice "$v" }
+# ~~~
+# 
+# Would call the lambda 5 times with `1`, `{a => 'hello', b => [100, 200]}`, `3`, `4`, `5`
+#
+# **Chaining** When calling `tree_each` without a lambda the function produces an `Iterator`
+# that can be chained into another iteration. Thus it is easy to use one of:
+# 
+# * `reverse_each` - get "leaves before root" 
+# * `filter` - prune the tree
+# * `map` - transform each element
+# * `reduce` - produce something else
+#
+# Note than when chaining, the value passed on is a `Tuple` with `[path, value]`.
+#
+# @example pruning a tree
+# 
+# ~~~ puppet
+# # A tree of some complexity (here very simple for readability)
+# $tree = [
+#  { name => 'user1', status => 'inactive', id => '10'},
+#  { name => 'user2', status => 'active', id => '20'}
+# ]
+# notice $tree.tree_each.filter |$v| {
+#  $value = $v[1]
+#  $value =~ Hash and $value[status] == active
+# }
+# ~~~
+#
+# Would notice `[[[1], {name => user2, status => active, id => 20}]]`, which can then be processed
+# further as each filtered result appears as a `Tuple` with `[path, value]`.
+#
+#
+# For general examples that demonstrates iteration see the Puppet
+# [iteration](https://docs.puppetlabs.com/puppet/latest/reference/lang_iteration.html)
+# documentation.
+#
+# @since 5.0.0
+#
+Puppet::Functions.create_function(:tree_each) do
+
+  local_types do
+    type "OptionsType  = Struct[{\
+      container_type => Optional[Type],\
+      include_root   => Optional[Boolean],
+      include_containers => Optional[Boolean],\
+      include_values => Optional[Boolean],\
+      order => Optional[Enum[depth_first, breadth_first]],\
+      include_refs   => Optional[Boolean]\
+    }]"
+  end
+
+  dispatch :tree_Enumerable2 do
+    param 'Variant[Iterator, Array, Hash, Object]', :tree
+    optional_param 'OptionsType', :options
+    block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :tree_Enumerable1 do
+    param 'Variant[Iterator, Array, Hash, Object]', :tree
+    optional_param 'OptionsType', :options
+    block_param 'Callable[1,1]', :block
+  end
+
+  dispatch :tree_Iterable do
+    param 'Variant[Iterator, Array, Hash, Object]', :tree
+    optional_param 'OptionsType', :options
+  end
+
+  def tree_Enumerable1(enum, options = {}, &block)
+    iterator(enum, options).each {|_, v| yield(v) }
+    enum
+  end
+
+  def tree_Enumerable2(enum, options = {}, &block)
+    iterator(enum, options).each {|path, v| yield(path, v) }
+    enum
+  end
+
+  def tree_Iterable(enum, options = {}, &block)
+    Puppet::Pops::Types::Iterable.on(iterator(enum, options))
+  end
+
+  def iterator(enum, options)
+    if depth_first?(options)
+      Puppet::Pops::Types::Iterable::DepthFirstTreeIterator.new(enum, options)
+    else
+      Puppet::Pops::Types::Iterable::BreadthFirstTreeIterator.new(enum, options)
+    end
+  end
+
+  def depth_first?(options)
+    (order = options['order']).nil? ? true : order == 'depth_first'
+  end
+end