puppet 3.7.4 → 3.7.5

data/lib/puppet/functions/assert_type.rb

@@ -30,14 +30,14 @@ Puppet::Functions.create_function(:assert_type) do
   # @param type [Type] the type the value must be an instance of
   # @param value [Object] the value to assert
   #
-  def assert_type(type, value, block=nil)
+  def assert_type(type, value)
     unless Puppet::Pops::Types::TypeCalculator.instance?(type,value)
       inferred_type = Puppet::Pops::Types::TypeCalculator.infer(value)
-      if block
+      if block_given?
         # Give the inferred type to allow richer comparisson in the given block (if generalized
         # information is lost).
         #
-        value = block.call(nil, type, inferred_type)
+        value = yield(type, inferred_type)
       else
         # Do not give all the details - i.e. format as Integer, instead of Integer[n, n] for exact value, which
         # is just confusing. (OTOH: may need to revisit, or provide a better "type diff" output.
@@ -52,8 +52,8 @@ Puppet::Functions.create_function(:assert_type) do
   # @param type_string [String] the type the value must be an instance of given in String form
   # @param value [Object] the value to assert
   #
-  def assert_type_s(type_string, value)
+  def assert_type_s(type_string, value, &proc)
     t = Puppet::Pops::Types::TypeParser.new.parse(type_string)
-    assert_type(t, value)
+    block_given? ? assert_type(t, value, &proc) : assert_type(t, value)
   end
 end

data/lib/puppet/functions/each.rb

@@ -41,58 +41,58 @@
 Puppet::Functions.create_function(:each) do
   dispatch :foreach_Hash_2 do
     param 'Hash[Any, Any]', :hash
-    required_block_param 'Callable[2,2]', :block
+    block_param 'Callable[2,2]', :block
   end
 
   dispatch :foreach_Hash_1 do
     param 'Hash[Any, Any]', :hash
-    required_block_param 'Callable[1,1]', :block
+    block_param 'Callable[1,1]', :block
   end
 
   dispatch :foreach_Enumerable_2 do
     param 'Any', :enumerable
-    required_block_param 'Callable[2,2]', :block
+    block_param 'Callable[2,2]', :block
   end
 
   dispatch :foreach_Enumerable_1 do
     param 'Any', :enumerable
-    required_block_param 'Callable[1,1]', :block
+    block_param 'Callable[1,1]', :block
   end
 
-  def foreach_Hash_1(hash, pblock)
+  def foreach_Hash_1(hash)
     enumerator = hash.each_pair
     hash.size.times do
-      pblock.call(nil, enumerator.next)
+      yield(enumerator.next)
     end
     # produces the receiver
     hash
   end
 
-  def foreach_Hash_2(hash, pblock)
+  def foreach_Hash_2(hash)
     enumerator = hash.each_pair
     hash.size.times do
-      pblock.call(nil, *enumerator.next)
+      yield(*enumerator.next)
     end
     # produces the receiver
     hash
   end
 
-  def foreach_Enumerable_1(enumerable, pblock)
+  def foreach_Enumerable_1(enumerable)
     enum = asserted_enumerable(enumerable)
       begin
-        loop { pblock.call(nil, enum.next) }
+        loop { yield(enum.next) }
       rescue StopIteration
       end
     # produces the receiver
     enumerable
   end
 
-  def foreach_Enumerable_2(enumerable, pblock)
+  def foreach_Enumerable_2(enumerable)
     enum = asserted_enumerable(enumerable)
     index = 0
     begin
       loop do
-        pblock.call(nil, index, enum.next)
+        yield(index, enum.next)
         index += 1
       end
     rescue StopIteration

data/lib/puppet/functions/epp.rb

@@ -42,10 +42,9 @@
 Puppet::Functions.create_function(:epp, Puppet::Functions::InternalFunction) do
 
   dispatch :epp do
-    scope_param()
-    param 'String', 'path'
-    param 'Hash[Pattern[/^\w+$/], Any]', 'parameters'
-    arg_count(1, 2)
+    scope_param
+    param 'String', :path
+    optional_param 'Hash[Pattern[/^\w+$/], Any]', :parameters
   end
 
   def epp(scope, path, parameters = nil)

data/lib/puppet/functions/filter.rb

@@ -38,46 +38,46 @@
 Puppet::Functions.create_function(:filter) do
   dispatch :filter_Hash_2 do
     param 'Hash[Any, Any]', :hash
-    required_block_param 'Callable[2,2]', :block
+    block_param 'Callable[2,2]', :block
   end
 
   dispatch :filter_Hash_1 do
     param 'Hash[Any, Any]', :hash
-    required_block_param 'Callable[1,1]', :block
+    block_param 'Callable[1,1]', :block
   end
 
   dispatch :filter_Enumerable_2 do
     param 'Any', :enumerable
-    required_block_param 'Callable[2,2]', :block
+    block_param 'Callable[2,2]', :block
   end
 
   dispatch :filter_Enumerable_1 do
     param 'Any', :enumerable
-    required_block_param 'Callable[1,1]', :block
+    block_param 'Callable[1,1]', :block
   end
 
-  def filter_Hash_1(hash, pblock)
-    result = hash.select {|x, y| pblock.call(self, [x, y]) }
+  def filter_Hash_1(hash)
+    result = hash.select {|x, y| yield([x, y]) }
     # Ruby 1.8.7 returns Array
     result = Hash[result] unless result.is_a? Hash
     result
   end
 
-  def filter_Hash_2(hash, pblock)
-    result = hash.select {|x, y| pblock.call(self, x, y) }
+  def filter_Hash_2(hash)
+    result = hash.select {|x, y| yield(x, y) }
     # Ruby 1.8.7 returns Array
     result = Hash[result] unless result.is_a? Hash
     result
   end
 
-  def filter_Enumerable_1(enumerable, pblock)
+  def filter_Enumerable_1(enumerable)
     result = []
     index = 0
     enum = asserted_enumerable(enumerable)
     begin
       loop do
         it = enum.next
-        if pblock.call(nil, it) == true
+        if yield(it) == true
           result << it
         end
       end
@@ -86,14 +86,14 @@ Puppet::Functions.create_function(:filter) do
     result
   end
 
-  def filter_Enumerable_2(enumerable, pblock)
+  def filter_Enumerable_2(enumerable)
     result = []
     index = 0
     enum = asserted_enumerable(enumerable)
     begin
       loop do
         it = enum.next
-        if pblock.call(nil, index, it) == true
+        if yield(index, it) == true
           result << it
         end
         index += 1

data/lib/puppet/functions/hiera.rb

@@ -0,0 +1,29 @@
+require 'hiera/puppet_function'
+
+#  Performs a standard priority lookup and returns the most specific value for a given key.
+#  The returned value can be data of any type (strings, arrays, or hashes).
+#
+#  The function can be called in one of three ways:
+#  1. Using 1 to 3 arguments where the arguments are:
+#     'key'      [String] Required
+#           The key to lookup.
+#     'default`  [Any] Optional
+#           A value to return when there's no match for `key`. Optional
+#     `override` [Any] Optional
+#           An argument in the third position, providing a data source
+#           to consult for matching values, even if it would not ordinarily be
+#           part of the matched hierarchy. If Hiera doesn't find a matching key
+#           in the named override data source, it will continue to search through the
+#           rest of the hierarchy.
+#
+#  2. Using a 'key' and an optional 'override' parameter like in #1 but with a block to
+#     provide the default value. The block is called with one parameter (the key) and
+#     should return the value.
+#
+#  3. Like #1 but with all arguments passed in an array.
+#
+#  More thorough examples of `hiera` are available at:
+#  <http://docs.puppetlabs.com/hiera/1/puppet.html#hiera-lookup-functions>
+Puppet::Functions.create_function(:hiera, Hiera::PuppetFunction) do
+  init_dispatch
+end

data/lib/puppet/functions/hiera_array.rb

@@ -0,0 +1,34 @@
+require 'hiera/puppet_function'
+
+# Returns all matches throughout the hierarchy --- not just the first match --- as a flattened array of unique values.
+#  If any of the matched values are arrays, they're flattened and included in the results.
+#
+#  The function can be called in one of three ways:
+#  1. Using 1 to 3 arguments where the arguments are:
+#     'key'      [String] Required
+#           The key to lookup.
+#     'default`  [Any] Optional
+#           A value to return when there's no match for `key`. Optional
+#     `override` [Any] Optional
+#           An argument in the third position, providing a data source
+#           to consult for matching values, even if it would not ordinarily be
+#           part of the matched hierarchy. If Hiera doesn't find a matching key
+#           in the named override data source, it will continue to search through the
+#           rest of the hierarchy.
+#
+#  2. Using a 'key' and an optional 'override' parameter like in #1 but with a block to
+#     provide the default value. The block is called with one parameter (the key) and
+#     should return the value.
+#
+#  3. Like #1 but with all arguments passed in an array.
+#  If any matched value is a hash, puppet will raise a type mismatch error.
+#
+#  More thorough examples of `hiera` are available at:
+#  <http://docs.puppetlabs.com/hiera/1/puppet.html#hiera-lookup-functions>
+Puppet::Functions.create_function(:hiera_array, Hiera::PuppetFunction) do
+  init_dispatch
+
+  def merge_type
+    :array
+  end
+end

data/lib/puppet/functions/hiera_hash.rb

@@ -0,0 +1,36 @@
+require 'hiera/puppet_function'
+
+# Returns a merged hash of matches from throughout the hierarchy. In cases where two or
+# more hashes share keys, the hierarchy  order determines which key/value pair will be
+#  used in the returned hash, with the pair in the highest priority data source winning.
+#
+#  The function can be called in one of three ways:
+#  1. Using 1 to 3 arguments where the arguments are:
+#     'key'      [String] Required
+#           The key to lookup.
+#     'default`  [Any] Optional
+#           A value to return when there's no match for `key`. Optional
+#     `override` [Any] Optional
+#           An argument in the third position, providing a data source
+#           to consult for matching values, even if it would not ordinarily be
+#           part of the matched hierarchy. If Hiera doesn't find a matching key
+#           in the named override data source, it will continue to search through the
+#           rest of the hierarchy.
+#
+#  2. Using a 'key' and an optional 'override' parameter like in #1 but with a block to
+#     provide the default value. The block is called with one parameter (the key) and
+#     should return the value.
+#
+#  3. Like #1 but with all arguments passed in an array.
+#  `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 will raise a type mismatch error.
+#
+#  More thorough examples of `hiera_hash` are available at:
+#  <http://docs.puppetlabs.com/hiera/1/puppet.html#hiera-lookup-functions>
+Puppet::Functions.create_function(:hiera_hash, Hiera::PuppetFunction) do
+  init_dispatch
+
+  def merge_type
+    :hash
+  end
+end

data/lib/puppet/functions/hiera_include.rb

@@ -0,0 +1,50 @@
+require 'hiera_puppet'
+
+# Assigns classes to a node using an array merge lookup that retrieves the value for a user-specified key
+#   from a Hiera data source.
+#
+#  To use `hiera_include`, the following configuration is required:
+#  - A key name to use for classes, e.g. `classes`.
+#  - A line in the puppet `sites.pp` file (e.g. `/etc/puppet/manifests/sites.pp`)
+#    reading `hiera_include('classes')`. Note that this line must be outside any node
+#    definition and below any top-scope variables in use for Hiera lookups.
+#  - Class keys in the appropriate data sources. In a data source keyed to a node's role,
+#    one might have:
+#
+#            ---
+#            classes:
+#              - apache
+#              - apache::passenger
+#  The function can be called in one of three ways:
+#  1. Using 1 to 3 arguments where the arguments are:
+#     'key'      [String] Required
+#           The key to lookup.
+#     'default`  [Any] Optional
+#           A value to return when there's no match for `key`. Optional
+#     `override` [Any] Optional
+#           An argument in the third position, providing a data source
+#           to consult for matching values, even if it would not ordinarily be
+#           part of the matched hierarchy. If Hiera doesn't find a matching key
+#           in the named override data source, it will continue to search through the
+#          rest of the hierarchy.
+#
+#  2. Using a 'key' and an optional 'override' parameter like in #1 but with a block to
+#     provide the default value. The block is called with one parameter (the key) and
+#     should return the array to be used in the subsequent call to include.
+#
+#  3. Like #1 but with all arguments passed in an array.
+#
+#  More thorough examples of `hiera_include` are available at:
+#  <http://docs.puppetlabs.com/hiera/1/puppet.html#hiera-lookup-functions>
+Puppet::Functions.create_function(:hiera_include, Hiera::PuppetFunction) do
+  init_dispatch
+
+  def merge_type
+    :array
+  end
+
+  def post_lookup(key, value)
+    raise Puppet::ParseError, "Could not find data item #{key}" if value.nil?
+    call_function('include', value) unless value.empty?
+  end
+end

data/lib/puppet/functions/inline_epp.rb

@@ -77,9 +77,8 @@ Puppet::Functions.create_function(:inline_epp, Puppet::Functions::InternalFuncti
 
   dispatch :inline_epp do
     scope_param()
-    param 'String', 'template'
-    param 'Hash[Pattern[/^\w+$/], Any]', 'parameters'
-    arg_count(1, 2)
+    param 'String', :template
+    optional_param 'Hash[Pattern[/^\w+$/], Any]', :parameters
   end
 
   def inline_epp(scope, template, parameters = nil)

data/lib/puppet/functions/map.rb

@@ -36,50 +36,50 @@
 Puppet::Functions.create_function(:map) do
   dispatch :map_Hash_2 do
     param 'Hash[Any, Any]', :hash
-    required_block_param 'Callable[2,2]', :block
+    block_param 'Callable[2,2]', :block
   end
 
   dispatch :map_Hash_1 do
     param 'Hash[Any, Any]', :hash
-    required_block_param 'Callable[1,1]', :block
+    block_param 'Callable[1,1]', :block
   end
 
   dispatch :map_Enumerable_2 do
     param 'Any', :enumerable
-    required_block_param 'Callable[2,2]', :block
+    block_param 'Callable[2,2]', :block
   end
 
   dispatch :map_Enumerable_1 do
     param 'Any', :enumerable
-    required_block_param 'Callable[1,1]', :block
+    block_param 'Callable[1,1]', :block
   end
 
-  def map_Hash_1(hash, pblock)
-    hash.map {|x, y| pblock.call(nil, [x, y]) }
+  def map_Hash_1(hash)
+    hash.map {|x, y| yield([x, y]) }
   end
 
-  def map_Hash_2(hash, pblock)
-      hash.map {|x, y| pblock.call(nil, x, y) }
+  def map_Hash_2(hash)
+      hash.map {|x, y| yield(x, y) }
   end
 
-  def map_Enumerable_1(enumerable, pblock)
+  def map_Enumerable_1(enumerable)
     result = []
     index = 0
     enum = asserted_enumerable(enumerable)
     begin
-      loop { result << pblock.call(nil, enum.next) }
+      loop { result << yield(enum.next) }
     rescue StopIteration
     end
     result
   end
 
-  def map_Enumerable_2(enumerable, pblock)
+  def map_Enumerable_2(enumerable)
     result = []
     index = 0
     enum = asserted_enumerable(enumerable)
     begin
       loop do
-        result << pblock.call(nil, index, enum.next)
+        result << yield(index, enum.next)
         index = index +1
       end
     rescue StopIteration

data/lib/puppet/functions/reduce.rb

@@ -65,23 +65,23 @@ Puppet::Functions.create_function(:reduce) do
 
   dispatch :reduce_without_memo do
     param 'Any', :enumerable
-    required_block_param 'Callable[2,2]', :block
+    block_param 'Callable[2,2]', :block
   end
 
   dispatch :reduce_with_memo do
     param 'Any', :enumerable
     param 'Any', :memo
-    required_block_param 'Callable[2,2]', :block
+    block_param 'Callable[2,2]', :block
   end
 
-  def reduce_without_memo(enumerable, pblock)
+  def reduce_without_memo(enumerable)
     enum = asserted_enumerable(enumerable)
-    enum.reduce {|memo, x| pblock.call(nil, memo, x) }
+    enum.reduce {|memo, x| yield(memo, x) }
   end
 
-  def reduce_with_memo(enumerable, given_memo, pblock)
+  def reduce_with_memo(enumerable, given_memo)
     enum = asserted_enumerable(enumerable)
-    enum.reduce(given_memo) {|memo, x| pblock.call(nil, memo, x) }
+    enum.reduce(given_memo) {|memo, x| yield(memo, x) }
   end
 
   def asserted_enumerable(obj)