puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/lib/puppet/functions/filter.rb

@@ -0,0 +1,113 @@
+# Applies a parameterized block to each element in a sequence of entries from the first
+# argument and returns an array or hash (same type as left operand for array/hash, and array for
+# other enumerable types) with the entries for which the block evaluates to `true`.
+#
+# This function takes two mandatory arguments: the first should be an Array, a Hash, or an
+# Enumerable object (integer, Integer range, or String),
+# and the second a parameterized block as produced by the puppet syntax:
+#
+#       $a.filter |$x| { ... }
+#       filter($a) |$x| { ... }
+#
+# When the first argument is something other than a Hash, the block is called with each entry in turn.
+# When the first argument is a Hash the entry is an array with `[key, value]`.
+#
+# @example Using filter with one parameter
+#
+#       # selects all that end with berry
+#       $a = ["raspberry", "blueberry", "orange"]
+#       $a.filter |$x| { $x =~ /berry$/ }          # rasberry, blueberry
+#
+# If the block defines two parameters, they will be set to `index, value` (with index starting at 0) for all
+# enumerables except Hash, and to `key, value` for a Hash.
+#
+# @example Using filter with two parameters
+#
+#      # selects all that end with 'berry' at an even numbered index
+#      $a = ["raspberry", "blueberry", "orange"]
+#      $a.filter |$index, $x| { $index % 2 == 0 and $x =~ /berry$/ } # raspberry
+#
+#      # selects all that end with 'berry' and value >= 1
+#      $a = {"raspberry"=>0, "blueberry"=>1, "orange"=>1}
+#      $a.filter |$key, $x| { $x =~ /berry$/ and $x >= 1 } # blueberry
+#
+# @since 3.4 for Array and Hash
+# @since 3.5 for other enumerables
+# @note requires `parser = future`
+#
+Puppet::Functions.create_function(:filter) do
+  dispatch :filter_Hash_2 do
+    param 'Hash[Any, Any]', :hash
+    required_block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :filter_Hash_1 do
+    param 'Hash[Any, Any]', :hash
+    required_block_param 'Callable[1,1]', :block
+  end
+
+  dispatch :filter_Enumerable_2 do
+    param 'Any', :enumerable
+    required_block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :filter_Enumerable_1 do
+    param 'Any', :enumerable
+    required_block_param 'Callable[1,1]', :block
+  end
+
+  def filter_Hash_1(hash, pblock)
+    result = hash.select {|x, y| pblock.call(self, [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) }
+    # Ruby 1.8.7 returns Array
+    result = Hash[result] unless result.is_a? Hash
+    result
+  end
+
+  def filter_Enumerable_1(enumerable, pblock)
+    result = []
+    index = 0
+    enum = asserted_enumerable(enumerable)
+    begin
+      loop do
+        it = enum.next
+        if pblock.call(nil, it) == true
+          result << it
+        end
+      end
+    rescue StopIteration
+    end
+    result
+  end
+
+  def filter_Enumerable_2(enumerable, pblock)
+    result = []
+    index = 0
+    enum = asserted_enumerable(enumerable)
+    begin
+      loop do
+        it = enum.next
+        if pblock.call(nil, index, it) == true
+          result << it
+        end
+        index += 1
+      end
+    rescue StopIteration
+    end
+    result
+  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/inline_epp.rb

@@ -0,0 +1,88 @@
+# Evaluates an Embedded Puppet Template (EPP) string and returns the rendered text result as a String.
+#
+# EPP support the following tags:
+#
+# * `<%= puppet expression %>` - This tag renders the value of the expression it contains.
+# * `<% puppet expression(s) %>` - This tag will execute the expression(s) it contains, but renders nothing.
+# * `<%# comment %>` - The tag and its content renders nothing.
+# * `<%%` or `%%>` - Renders a literal `<%` or `%>` respectively.
+# * `<%-` - Same as `<%` but suppresses any leading whitespace.
+# * `-%>` - Same as `%>` but suppresses any trailing whitespace on the same line (including line break).
+# * `<%- |parameters| -%>` - When placed as the first tag declares the template's parameters.
+#
+# Inline EPP supports the following visibilities of variables in scope which depends on how EPP parameters
+# are used - see further below:
+#
+# * Global scope (i.e. top + node scopes) - global scope is always visible
+# * Global + Enclosing scope - if the EPP template does not declare parameters, and no arguments are given
+# * Global + all given arguments - if the EPP template does not declare parameters, and arguments are given
+# * Global + declared parameters - if the EPP declares parameters, given argument names must match
+#
+# EPP supports parameters by placing an optional parameter list as the very first element in the EPP. As an example,
+# `<%- |$x, $y, $z='unicorn'| -%>` when placed first in the EPP text declares that the parameters `x` and `y` must be
+# given as template arguments when calling `inline_epp`, and that `z` if not given as a template argument
+# defaults to `'unicorn'`. Template parameters are available as variables, e.g.arguments `$x`, `$y` and `$z` in the example.
+# Note that `<%-` must be used or any leading whitespace will be interpreted as text
+#
+# Arguments are passed to the template by calling `inline_epp` with a Hash as the last argument, where parameters
+# are bound to values, e.g. `inline_epp('...', {'x'=>10, 'y'=>20})`. Excess arguments may be given
+# (i.e. undeclared parameters) only if the EPP templates does not declare any parameters at all.
+# Template parameters shadow variables in outer scopes.
+#
+# Note: An inline template is best stated using a single-quoted string, or a heredoc since a double-quoted string
+# is subject to expression interpolation before the string is parsed as an EPP template. Here are examples
+# (using heredoc to define the EPP text):
+#
+# @example Various Examples using `inline_epp`
+#
+#     # produces 'Hello local variable world!'
+#     $x ='local variable'
+#     inline_epptemplate(@(END:epp))
+#     <%- |$x| -%>
+#     Hello <%= $x %> world!
+#     END
+# 
+#     # produces 'Hello given argument world!'
+#     $x ='local variable world'
+#     inline_epptemplate(@(END:epp), { x =>'given argument'})
+#     <%- |$x| -%>
+#     Hello <%= $x %> world!
+#     END
+#
+#     # produces 'Hello given argument world!'
+#     $x ='local variable world'
+#     inline_epptemplate(@(END:epp), { x =>'given argument'})
+#     <%- |$x| -%>
+#     Hello <%= $x %>!
+#     END
+#
+#     # results in error, missing value for y
+#     $x ='local variable world'
+#     inline_epptemplate(@(END:epp), { x =>'given argument'})
+#     <%- |$x, $y| -%>
+#     Hello <%= $x %>!
+#     END
+#
+#     # Produces 'Hello given argument planet'
+#     $x ='local variable world'
+#     inline_epptemplate(@(END:epp), { x =>'given argument'})
+#     <%- |$x, $y=planet| -%>
+#     Hello <%= $x %> <%= $y %>!
+#     END
+#
+# @since 3.5
+# @note Requires Future Parser
+#
+Puppet::Functions.create_function(:inline_epp, Puppet::Functions::InternalFunction) do
+
+  dispatch :inline_epp do
+    scope_param()
+    param 'String', 'template'
+    param 'Hash[Pattern[/^\w+$/], Any]', 'parameters'
+    arg_count(1, 2)
+  end
+
+  def inline_epp(scope, template, parameters = nil)
+    Puppet::Pops::Evaluator::EppEvaluator.inline_epp(scope, template, parameters)
+  end
+end

data/lib/puppet/functions/map.rb

@@ -0,0 +1,97 @@
+# Applies a parameterized block to each element in a sequence of entries from the first
+# argument and returns an array with the result of each invocation of the parameterized block.
+#
+# This function takes two mandatory arguments: the first should be an Array, Hash, or of Enumerable type
+# (integer, Integer range, or String), and the second a parameterized block as produced by the puppet syntax:
+#
+#       $a.map |$x| { ... }
+#       map($a) |$x| { ... }
+#
+# When the first argument `$a` is an Array or of enumerable type, the block is called with each entry in turn.
+# When the first argument is a hash the entry is an array with `[key, value]`.
+#
+# @example Using map with two arguments
+#
+#      # Turns hash into array of values
+#      $a.map |$x|{ $x[1] }
+#
+#      # Turns hash into array of keys
+#      $a.map |$x| { $x[0] }
+#
+# When using a block with 2 parameters, the element's index (starting from 0) for an array, and the key for a hash
+# is given to the block's first parameter, and the value is given to the block's second parameter.args.
+#
+# @example Using map with two arguments
+#
+#      # Turns hash into array of values
+#      $a.map |$key,$val|{ $val }
+#
+#      # Turns hash into array of keys
+#      $a.map |$key,$val|{ $key }
+#
+# @since 3.4 for Array and Hash
+# @since 3.5 for other enumerables, and support for blocks with 2 parameters
+# @note requires `parser = future`
+#
+Puppet::Functions.create_function(:map) do
+  dispatch :map_Hash_2 do
+    param 'Hash[Any, Any]', :hash
+    required_block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :map_Hash_1 do
+    param 'Hash[Any, Any]', :hash
+    required_block_param 'Callable[1,1]', :block
+  end
+
+  dispatch :map_Enumerable_2 do
+    param 'Any', :enumerable
+    required_block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :map_Enumerable_1 do
+    param 'Any', :enumerable
+    required_block_param 'Callable[1,1]', :block
+  end
+
+  def map_Hash_1(hash, pblock)
+    hash.map {|x, y| pblock.call(nil, [x, y]) }
+  end
+
+  def map_Hash_2(hash, pblock)
+      hash.map {|x, y| pblock.call(nil, x, y) }
+  end
+
+  def map_Enumerable_1(enumerable, pblock)
+    result = []
+    index = 0
+    enum = asserted_enumerable(enumerable)
+    begin
+      loop { result << pblock.call(nil, enum.next) }
+    rescue StopIteration
+    end
+    result
+  end
+
+  def map_Enumerable_2(enumerable, pblock)
+    result = []
+    index = 0
+    enum = asserted_enumerable(enumerable)
+    begin
+      loop do
+        result << pblock.call(nil, index, enum.next)
+        index = index +1
+      end
+    rescue StopIteration
+    end
+    result
+  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/match.rb

@@ -0,0 +1,102 @@
+# Returns the match result of matching a String or Array[String] with one of:
+#
+# * Regexp
+# * String - transformed to a Regexp
+# * Pattern type
+# * Regexp type
+#
+# Returns An Array with the entire match at index 0, and each subsequent submatch at index 1-n.
+# If there was no match, nil (ie. undef) is returned. If the value to match is an Array, a array
+# with mapped match results is returned.
+#
+# @example matching
+#   "abc123".match(/([a-z]+)[1-9]+/)  # => ["abc"]
+#   "abc123".match(/([a-z]+)([1-9]+)/)  # => ["abc", "123"]
+#
+# See the documentation for "The Puppet Type System" for more information about types.
+# @since 3.7.0
+#
+Puppet::Functions.create_function(:match) do
+  dispatch :match do
+    param 'String', 'string'
+    param 'Variant[Any, Type]', 'pattern'
+  end
+
+  dispatch :enumerable_match do
+    param 'Array[String]', 'string'
+    param 'Variant[Any, Type]', 'pattern'
+  end
+
+  def initialize(closure_scope, loader)
+    super
+
+    # Make this visitor shared among all instantiations of this function since it is faster.
+    # This can be used because it is not possible to replace
+    # a puppet runtime (where this function is) without a reboot. If you model a function in a module after
+    # this class, use a regular instance variable instead to enable reloading of the module without reboot
+    #
+    @@match_visitor   ||= Puppet::Pops::Visitor.new(self, "match", 1, 1)
+  end
+
+  # Matches given string against given pattern and returns an Array with matches.
+  # @param string [String] the string to match
+  # @param pattern [String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::PRegexpType, Array] the pattern
+  # @return [Array<String>] matches where first match is the entire match, and index 1-n are captures from left to right
+  #
+  def match(string, pattern)
+    @@match_visitor.visit_this_1(self, pattern, string)
+  end
+
+  # Matches given Array[String] against given pattern and returns an Array with mapped match results.
+  #
+  # @param array [Array<String>] the array of strings to match
+  # @param pattern [String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::PRegexpType, Array] the pattern
+  # @return [Array<Array<String, nil>>] Array with matches (see {#match}), non matching entries produce a nil entry
+  #
+  def enumerable_match(array, pattern)
+    array.map {|s| match(s, pattern) }
+  end
+
+  protected
+
+  def match_Object(obj, s)
+    msg = "match() expects pattern of T, where T is String, Regexp, Regexp[r], Pattern[p], or Array[T]. Got #{obj.class}"
+    raise ArgumentError, msg
+  end
+
+  def match_String(pattern_string, s)
+    do_match(s, Regexp.new(pattern_string))
+  end
+
+  def match_Regexp(regexp, s)
+    do_match(s, regexp)
+  end
+
+  def match_PRegexpType(regexp_t, s)
+    raise ArgumentError, "Given Regexp Type has no regular expression" unless regexp_t.pattern
+    do_match(s, regexp_t.regexp)
+  end
+
+  def match_PPatternType(pattern_t, s)
+    # Since we want the actual match result (not just a boolean), an iteration over
+    # Pattern's regular expressions is needed. (They are of PRegexpType)
+    result = nil
+    pattern_t.patterns.find {|pattern| result = match(s, pattern) }
+    result
+  end
+
+  # Returns the first matching entry
+  def match_Array(array, s)
+    result = nil
+    array.flatten.find {|entry| result = match(s, entry) }
+    result
+  end
+
+  private
+
+  def do_match(s, regexp)
+    if result = regexp.match(s)
+      result.to_a
+    end
+  end
+end

data/lib/puppet/functions/reduce.rb

@@ -0,0 +1,94 @@
+# 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
+#
+# @since 3.2 for Array and Hash
+# @since 3.5 for additional enumerable types
+# @note requires `parser = future`.
+#
+Puppet::Functions.create_function(:reduce) do
+
+  dispatch :reduce_without_memo do
+    param 'Any', :enumerable
+    required_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
+  end
+
+  def reduce_without_memo(enumerable, pblock)
+    enum = asserted_enumerable(enumerable)
+    enum.reduce {|memo, x| pblock.call(nil, memo, x) }
+  end
+
+  def reduce_with_memo(enumerable, given_memo, pblock)
+    enum = asserted_enumerable(enumerable)
+    enum.reduce(given_memo) {|memo, x| pblock.call(nil, 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