puppet 3.1.1 → 3.2.0.rc1

data/lib/puppet/parser/functions/fqdn_rand.rb

@@ -8,6 +8,6 @@ Puppet::Parser::Functions::newfunction(:fqdn_rand, :arity => -2, :type => :rvalu
       $random_number = fqdn_rand(30)
       $random_number_seed = fqdn_rand(30,30)") do |args|
     max = args.shift.to_i
-    srand(Digest::MD5.hexdigest([self['::fqdn'],args].join(':')).hex)
-    rand(max).to_s
+    seed = Digest::MD5.hexdigest([self['::fqdn'],args].join(':')).hex
+    Puppet::Util.deterministic_rand(seed,max)
 end

data/lib/puppet/parser/functions/hiera.rb

@@ -1,6 +1,24 @@
+require 'hiera_puppet'
+
 module Puppet::Parser::Functions
-  newfunction(:hiera, :type => :rvalue, :arity => -2) do |*args|
-    require 'hiera_puppet'
+  newfunction(:hiera, :type => :rvalue, :arity => -2, :doc => "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). 
+
+  In addition to the required `key` argument, `hiera` accepts two additional
+  arguments:
+
+  - a `default` argument in the second position, providing a value to be
+    returned in the absence of matches to the `key` argument
+  - an `override` 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.
+
+  More thorough examples of `hiera` are available at:  
+  <http://docs.puppetlabs.com/hiera/1/puppet.html#hiera-lookup-functions>
+  ") do |*args|
     key, default, override = HieraPuppet.parse_args(args)
     HieraPuppet.lookup(key, default, self, override, :priority)
   end

data/lib/puppet/parser/functions/hiera_array.rb

@@ -1,6 +1,25 @@
+require 'hiera_puppet'
+
 module Puppet::Parser::Functions
-  newfunction(:hiera_array, :type => :rvalue, :arity => -2) do |*args|
-    require 'hiera_puppet'
+  newfunction(:hiera_array, :type => :rvalue, :arity => -2,:doc => "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.
+  
+  In addition to the required `key` argument, `hiera_array` accepts two additional 
+  arguments:
+  
+  - a `default` argument in the second position, providing a string or array to be returned 
+    in the absence of  matches to the `key` argument
+  - an `override` 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.
+    
+  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>
+  ") do |*args|
     key, default, override = HieraPuppet.parse_args(args)
     HieraPuppet.lookup(key, default, self, override, :array)
   end

data/lib/puppet/parser/functions/hiera_hash.rb

@@ -1,6 +1,27 @@
+require 'hiera_puppet'
+
 module Puppet::Parser::Functions
-  newfunction(:hiera_hash, :type => :rvalue, :arity => -2) do |*args|
-    require 'hiera_puppet'
+  newfunction(:hiera_hash, :type => :rvalue, :arity => -2, :doc => 
+  "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.
+  
+  In addition to the required `key` argument, `hiera_hash` accepts two additional 
+  arguments:
+  
+  - a `default` argument in the second position, providing a  hash to be returned in the 
+  absence of any matches for the `key` argument
+  - an `override` argument in the third position, providing  a data source to insert at 
+  the top of the hierarchy, even if it would not ordinarily match during a Hiera data 
+  source lookup. If Hiera doesn't find a match in the named override data source, it will 
+  continue to search through the rest of the hierarchy.
+    
+  `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>
+  ") do |*args|
     key, default, override = HieraPuppet.parse_args(args)
     HieraPuppet.lookup(key, default, self, override, :hash)
   end

data/lib/puppet/parser/functions/hiera_include.rb

@@ -1,6 +1,37 @@
+require 'hiera_puppet'
+
 module Puppet::Parser::Functions
-  newfunction(:hiera_include, :arity => -2) do |*args|
-    require 'hiera_puppet'
+  newfunction(:hiera_include, :arity => -2, :doc => "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
+
+  In addition to the required `key` argument, `hiera_include` accepts two additional
+  arguments:
+
+  - a `default` argument in the second position, providing an array to be returned
+    in the absence of matches to the `key` argument
+  - an `override` 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.
+
+  More thorough examples of `hiera_include` are available at:
+  <http://docs.puppetlabs.com/hiera/1/puppet.html#hiera-lookup-functions>
+  ") do |*args|
     key, default, override = HieraPuppet.parse_args(args)
     if answer = HieraPuppet.lookup(key, default, self, override, :array)
       method = Puppet::Parser::Functions.function(:include)

data/lib/puppet/parser/functions/inline_template.rb

@@ -1,9 +1,9 @@
 Puppet::Parser::Functions::newfunction(:inline_template, :type => :rvalue, :arity => -2, :doc =>
-  "Evaluate a template string and return its value.  See 
-  [the templating docs](http://docs.puppetlabs.com/guides/templating.html) for 
-  more information.  Note that if multiple template strings are specified, their 
+  "Evaluate a template string and return its value.  See
+  [the templating docs](http://docs.puppetlabs.com/guides/templating.html) for
+  more information.  Note that if multiple template strings are specified, their
   output is all concatenated and returned as the output of the function.") do |vals|
-  
+
   require 'erb'
 
     vals.collect do |string|

data/lib/puppet/parser/functions/reduce.rb

@@ -0,0 +1,74 @@
+Puppet::Parser::Functions::newfunction(
+:reduce,
+:type => :rvalue,
+:arity => -2,
+:doc => <<-'ENDHEREDOC') do |args|
+  Applies a parameterized block to each element in a sequence of entries from the first
+  argument (_the collection_) and returns the last result of the invocation of the parameterized block.
+
+  This function takes two mandatory arguments: the first should be an Array or a Hash, and the last
+  a parameterized block as produced by the puppet syntax:
+
+    $a.reduce |$memo, $x| { ... }
+
+  When the first argument is an Array, 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.
+
+  If no 'start memo' is given, the first invocation of the parameterized block will be given the first and second
+  elements of the collection, and if the collection has fewer than 2 elements, the first
+  element is produced as the result of the reduction without invocation of the block.
+
+  On each subsequent invocations, the produced value of the invoked parameterized block is given as the memo in the
+  next invocation.
+
+  *Examples*
+
+    # 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]
+
+  It is possible to provide a starting 'memo' as an argument.
+
+  *Examples*
+    # 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]
+
+  Since 3.2
+  ENDHEREDOC
+
+  require 'puppet/parser/ast/lambda'
+  case args.length
+  when 2
+    pblock = args[1]
+  when 3
+    pblock = args[2]
+  else
+    raise ArgumentError, ("reduce(): wrong number of arguments (#{args.length}; must be 2 or 3)")
+  end
+  unless pblock.is_a? Puppet::Parser::AST::Lambda
+    raise ArgumentError, ("reduce(): wrong argument type (#{args[1].class}; must be a parameterized block.")
+  end
+  receiver = args[0]
+  unless [Array, Hash].include?(receiver.class)
+    raise ArgumentError, ("collect(): wrong argument type (#{args[0].class}; must be an Array or a Hash.")
+  end
+  if args.length == 3
+    receiver.reduce(args[1]) {|memo, x| pblock.call(self, memo, x) }
+  else
+    receiver.reduce {|memo, x| pblock.call(self, memo, x) }
+  end
+end

data/lib/puppet/parser/functions/reject.rb

@@ -0,0 +1,46 @@
+require 'puppet/parser/ast/lambda'
+
+Puppet::Parser::Functions::newfunction(
+:reject,
+:type => :rvalue,
+:arity => 2,
+:doc => <<-'ENDHEREDOC') do |args|
+  Applies a parameterized block to each element in a sequence of entries from the first
+  argument and returns an array with the entires for which the block did *not* evaluate to true.
+
+  This function takes two mandatory arguments: the first should be an Array or a Hash, and the second
+  a parameterized block as produced by the puppet syntax:
+
+    $a.reject |$x| { ... }
+
+  When the first argument is an Array, the block is called with each entry in turn. When the first argument
+  is a hash the entry is an array with `[key, value]`.
+
+  The returned filtered object is of the same type as the receiver.
+
+  *Examples*
+
+    # selects all that does not end with berry
+    $a = ["rasberry", "blueberry", "orange"]
+    $a.reject |$x| { $x =~ /berry$/ }
+
+  Since 3.2
+  ENDHEREDOC
+
+  receiver = args[0]
+  pblock = args[1]
+
+  raise ArgumentError, ("reject(): wrong argument type (#{pblock.class}; must be a parameterized block.") unless pblock.is_a? Puppet::Parser::AST::Lambda
+
+  case receiver
+  when Array
+    receiver.reject {|x| pblock.call(self, x) }
+  when Hash
+    result = receiver.reject {|x, y| pblock.call(self, [x, y]) }
+    # Ruby 1.8.7 returns Array
+    result = Hash[result] unless result.is_a? Hash
+    result
+  else
+    raise ArgumentError, ("reject(): wrong argument type (#{receiver.class}; must be an Array or a Hash.")
+  end
+end

data/lib/puppet/parser/functions/select.rb

@@ -0,0 +1,46 @@
+require 'puppet/parser/ast/lambda'
+
+Puppet::Parser::Functions::newfunction(
+:select,
+:type => :rvalue,
+:arity => 2,
+:doc => <<-'ENDHEREDOC') do |args|
+  Applies a parameterized block to each element in a sequence of entries from the first
+  argument and returns an array with the entires for which the block evaluates to true.
+
+  This function takes two mandatory arguments: the first should be an Array or a Hash, and the second
+  a parameterized block as produced by the puppet syntax:
+
+    $a.select |$x| { ... }
+
+  When the first argument is an Array, the block is called with each entry in turn. When the first argument
+  is a hash the entry is an array with `[key, value]`.
+
+  The returned filtered object is of the same type as the receiver.
+
+  *Examples*
+
+    # selects all that end with berry
+    $a = ["raspberry", "blueberry", "orange"]
+    $a.select |$x| { $x =~ /berry$/ }
+
+  Since 3.2
+  ENDHEREDOC
+
+  receiver = args[0]
+  pblock = args[1]
+
+  raise ArgumentError, ("select(): wrong argument type (#{pblock.class}; must be a parameterized block.") unless pblock.is_a? Puppet::Parser::AST::Lambda
+
+  case receiver
+  when Array
+    receiver.select {|x| pblock.call(self, x) }
+  when Hash
+    result = receiver.select {|x, y| pblock.call(self, [x, y]) }
+    # Ruby 1.8.7 returns Array
+    result = Hash[result] unless result.is_a? Hash
+    result
+  else
+    raise ArgumentError, ("select(): wrong argument type (#{receiver.class}; must be an Array or a Hash.")
+  end
+end

data/lib/puppet/parser/functions/slice.rb

@@ -0,0 +1,96 @@
+Puppet::Parser::Functions::newfunction(
+:slice,
+:type => :rvalue,
+:arity => -2,
+:doc => <<-'ENDHEREDOC') do |args|
+  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 a Hash, and the second
+  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:
+
+      |$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, 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
+  an array of two arrays with key, value.
+
+      $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.
+
+      slice($[1,2,3,4,5,6], 2) # produces [[1,2], [3,4], [5,6]]
+
+  Since 3.2
+  ENDHEREDOC
+  require 'puppet/parser/ast/lambda'
+  require 'puppet/parser/scope'
+
+  def each_Common(o, slice_size, filler, scope, pblock)
+    serving_size = pblock ? pblock.parameter_count : 1
+    if serving_size == 0
+      raise ArgumentError, "Block must define at least one parameter."
+    end
+    unless serving_size == 1 || serving_size == slice_size
+      raise ArgumentError, "Block must define one parameter, or the same number of parameters as the given size of the slice (#{slice_size})."
+    end
+    enumerator = o.each_slice(slice_size)
+    result = []
+    if serving_size == 1
+      ((o.size.to_f / slice_size).ceil).times do
+        if pblock
+          pblock.call(scope, enumerator.next)
+        else
+          result << enumerator.next
+        end
+      end
+    else
+      ((o.size.to_f / slice_size).ceil).times do
+        a = enumerator.next
+        if a.size < serving_size
+          a = a.dup.fill(filler, a.length...serving_size)
+        end
+        pblock.call(scope, *a)
+      end
+    end
+    if pblock
+      o
+    else
+      result
+    end
+  end
+  raise ArgumentError, ("slice(): wrong number of arguments (#{args.length}; must be 2 or 3)") unless args.length == 2 || args.length == 3
+  if args.length >= 2
+    begin
+      slice_size = Puppet::Parser::Scope.number?(args[1])
+    rescue
+      raise ArgumentError, ("slice(): wrong argument type (#{args[1]}; must be number.")
+    end
+  end
+  raise ArgumentError, ("slice(): wrong argument type (#{args[1]}; must be number.") unless slice_size
+  raise ArgumentError, ("slice(): wrong argument value: #{slice_size}; is not an positive integer number > 0") unless slice_size.is_a?(Fixnum) && slice_size > 0
+  receiver = args[0]
+
+  # the block is optional, ok if nil, function then produces an array
+  pblock = args[2]
+  raise ArgumentError, ("slice(): wrong argument type (#{args[2].class}; must be a parameterized block.") unless pblock.is_a?(Puppet::Parser::AST::Lambda) || args.length == 2
+
+  case receiver
+  when Array
+    each_Common(receiver, slice_size, :undef, self, pblock)
+  when Hash
+    each_Common(receiver, slice_size, [], self, pblock)
+  else
+    raise ArgumentError, ("slice(): wrong argument type (#{args[0].class}; must be an Array or a Hash.")
+  end
+end

data/lib/puppet/parser/functions/template.rb

@@ -1,8 +1,8 @@
 Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :arity => -2, :doc =>
   "Evaluate a template and return its value.  See
-  [the templating docs](http://docs.puppetlabs.com/guides/templating.html) for 
+  [the templating docs](http://docs.puppetlabs.com/guides/templating.html) for
   more information.
-  
+
   Note that if multiple templates are specified, their output is all
   concatenated and returned as the output of the function.") do |vals|
     vals.collect do |file|

data/lib/puppet/parser/grammar.ra

@@ -12,13 +12,13 @@ token IF ELSE IMPORT DEFINE ELSIF VARIABLE CLASS INHERITS NODE BOOLEAN
 token NAME SEMIC CASE DEFAULT AT LCOLLECT RCOLLECT CLASSREF
 token NOT OR AND UNDEF PARROW PLUS MINUS TIMES DIV LSHIFT RSHIFT UMINUS
 token MATCH NOMATCH REGEX IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
-token IN UNLESS
+token IN UNLESS MODULO
 
 prechigh
   right NOT
   nonassoc UMINUS
   left  IN MATCH NOMATCH
-  left  TIMES DIV
+  left  TIMES DIV MODULO
   left  MINUS PLUS
   left  LSHIFT RSHIFT
   left  NOTEQUAL ISEQUAL
@@ -32,7 +32,7 @@ program:    statements_and_declarations
   | nil
 
   statements_and_declarations:   statement_or_declaration {
-    result = ast AST::ASTArray, :children => (val[0] ? [val[0]] : [])
+    result = ast AST::BlockExpression, :children => (val[0] ? [val[0]] : [])
   }
   | statements_and_declarations statement_or_declaration {
     if val[1]
@@ -488,6 +488,9 @@ expression:   rvalue
 }
   | expression TIMES expression {
     result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | expression MODULO expression {
+    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | expression LSHIFT expression {
     result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
@@ -550,7 +553,7 @@ caseopt:        casevalues COLON LBRACE statements RBRACE {
     AST::CaseOpt,
     :value => val[0],
 
-    :statements => ast(AST::ASTArray)
+    :statements => ast(AST::BlockExpression)
   )
 }