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

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

@@ -138,7 +138,7 @@ If you want to make lookup return undef when no value was found instead of raisi
 ENDHEREDOC
 
   unless Puppet[:binder] || Puppet[:parser] == 'future'
-    raise Puppet::ParseError, "The lookup function is only available with settings --binder true, or --parser future" 
+    raise Puppet::ParseError, "The lookup function is only available with settings --binder true, or --parser future"
   end
   Puppet::Pops::Binder::Lookup.lookup(self, args)
 end

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

@@ -1,96 +1,43 @@
-require 'puppet/parser/ast/lambda'
-
 Puppet::Parser::Functions::newfunction(
-:map,
-: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 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]`.
-
-  *Examples*
+  :map,
+  :type => :rvalue,
+  :arity => -3,
+  :doc => <<-DOC
+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.
 
-        # Turns hash into array of values
-        $a.map |$x|{ $x[1] }
+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:
 
-        # Turns hash into array of keys
-        $a.map |$x| { $x[0] }
+      $a.map |$x| { ... }
+      map($a) |$x| { ... }
 
-  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.
+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]`.
 
-  *Examples*
+Example Using map with two arguments
 
-        # Turns hash into array of values
-        $a.map |$key,$val|{ $val }
+     # Turns hash into array of values
+     $a.map |$x|{ $x[1] }
 
-        # Turns hash into array of keys
-        $a.map |$key,$val|{ $key }
+     # Turns hash into array of keys
+     $a.map |$x| { $x[0] }
 
-  - Since 3.4 for Array and Hash
-  - Since 3.5 for other enumerables, and support for blocks with 2 parameters
-  - requires `parser = future`
-  ENDHEREDOC
+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.
 
-  def map_Enumerator(enumerator, scope, pblock, serving_size)
-    result = []
-    index = 0
-    if serving_size == 1
-      begin
-        loop { result << pblock.call(scope, enumerator.next) }
-      rescue StopIteration
-      end
-    else
-      begin
-        loop do
-          result << pblock.call(scope, index, enumerator.next)
-          index = index +1
-        end
-      rescue StopIteration
-      end
-    end
-    result
-  end
+Example Using map with two arguments
 
-  receiver = args[0]
-  pblock = args[1]
+     # Turns hash into array of values
+     $a.map |$key,$val|{ $val }
 
-  raise ArgumentError, ("map(): wrong argument type (#{pblock.class}; must be a parameterized block.") unless pblock.respond_to?(:puppet_lambda)
-  serving_size = pblock.parameter_count
-  if serving_size == 0
-    raise ArgumentError, "map(): block must define at least one parameter; value. Block has 0."
-  end
-  case receiver
-  when Hash
-    if serving_size > 2
-      raise ArgumentError, "map(): block must define at most two parameters; key, value.args Block has #{serving_size}; "+
-      pblock.parameter_names.join(', ')
-    end
-    if serving_size == 1
-      result = receiver.map {|x, y| pblock.call(self, [x, y]) }
-    else
-      result = receiver.map {|x, y| pblock.call(self, x, y) }
-    end
-  else
-    if serving_size > 2
-      raise ArgumentError, "map(): block must define at most two parameters; index, value. Block has #{serving_size}; "+
-      pblock.parameter_names.join(', ')
-    end
+     # Turns hash into array of keys
+     $a.map |$key,$val|{ $key }
 
-    enum = Puppet::Pops::Types::Enumeration.enumerator(receiver)
-    unless enum
-      raise ArgumentError, ("map(): wrong argument type (#{receiver.class}; must be something enumerable.")
-    end
-    result = map_Enumerator(enum, self, pblock, serving_size)
-  end
-  result
+- since 3.4 for Array and Hash
+- since 3.5 for other enumerables, and support for blocks with 2 parameters
+- note requires `parser = future`
+DOC
+) do |args|
+  function_fail(["map() is only available when parser/evaluator future is in effect"])
 end

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

@@ -0,0 +1,28 @@
+Puppet::Parser::Functions::newfunction(
+  :match,
+  :arity => 2,
+  :doc => <<-DOC
+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 `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
+- note requires future parser
+DOC
+) do |args|
+  function_fail(["match() is only available when parser/evaluator future is in effect"])
+end

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

@@ -1,100 +1,71 @@
 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 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.
-
-  *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]
-
-        # reverse a string
-        "abc".reduce |$memo, $char| { "$char$memo" }
-        #=>"cbe"
-
-  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]
-
-  *Examples*
-
-        Integer[1,4].reduce |$memo, $x| { $memo + $x }
-        #=> 10
-
-  - Since 3.2 for Array and Hash
-  - Since 3.5 for additional enumerable types
-  - requires `parser = future`.
-  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}; expected 2 or 3, got #{args.length})")
-  end
-  unless pblock.respond_to?(:puppet_lambda)
-    raise ArgumentError, ("reduce(): wrong argument type (#{pblock.class}; must be a parameterized block.")
-  end
-  receiver = args[0]
-  enum = Puppet::Pops::Types::Enumeration.enumerator(receiver)
-  unless enum
-    raise ArgumentError, ("reduce(): wrong argument type (#{receiver.class}; must be something enumerable.")
-  end
-
-  serving_size = pblock.parameter_count
-  if serving_size != 2
-    raise ArgumentError, "reduce(): block must define 2 parameters; memo, value. Block has #{serving_size}; "+
-    pblock.parameter_names.join(', ')
-  end
-
-  if args.length == 3
-    enum.reduce(args[1]) {|memo, x| pblock.call(self, memo, x) }
-  else
-    enum.reduce {|memo, x| pblock.call(self, memo, x) }
-  end
+  :reduce,
+  :type => :rvalue,
+  :arity => -3,
+  :doc => <<-DOC
+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`.
+DOC
+) do |args|
+  function_fail(["reduce() is only available when parser/evaluator future is in effect"])
 end

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

@@ -27,12 +27,20 @@ For instance the following manifest, with 'require' instead of 'include' would p
 Note that this function only works with clients 0.25 and later, and it will
 fail if used with earlier clients.
 
+When the future parser is used, you must use the class's full name;
+relative names are no longer allowed. In addition to names in string form,
+you may also directly use Class and Resource Type values that are produced by
+the future parser's resource and relationship expressions.
 ") do |vals|
-  # Verify that the 'include' function is loaded
-  method = Puppet::Parser::Functions.function(:include)
-
-  send(method, vals)
-  vals = [vals] unless vals.is_a?(Array)
+  # Make call patterns uniform and protected against nested arrays, also make
+  # names absolute if so desired.
+  vals = transform_and_assert_classnames(vals.is_a?(Array) ? vals.flatten : [vals])
+
+  # This is the same as calling the include function (but faster) since it again
+  # would otherwise need to perform the optional absolute name transformation
+  # (for no reason since they are already made absolute here).
+  #
+  compiler.evaluate_classes(vals, self, false)
 
   vals.each do |klass|
     # lookup the class in the scopes

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

@@ -1,6 +1,11 @@
 Puppet::Parser::Functions::newfunction(:search, :arity => -2, :doc => "Add another namespace for this class to search.
     This allows you to create classes with sets of definitions and add
-    those classes to another class's search path.") do |vals|
+    those classes to another class's search path.
+
+    Deprecated in Puppet 3.7.0, to be removed in Puppet 4.0.0.") do |vals|
+
+    Puppet.deprecation_warning("The 'search' function is deprecated. See http://links.puppetlabs.com/search-function-deprecation")
+
     vals.each do |val|
       add_namespace(val)
     end

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

@@ -1,116 +1,48 @@
 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.
+  :slice,
+  :type => :rvalue,
+  :arity => -3,
+  :doc => <<-DOC
+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, `$a`, should be an Array, Hash, or something of
-  enumerable type (integer, Integer range, or String), and the second, `$n`, 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:
+This function takes two mandatory arguments: the first, `$a`, should be an Array, Hash, or something of
+enumerable type (integer, Integer range, or String), and the second, `$n`, 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:
 
-      $a.slice($n) |$x| { ... }
-      slice($a) |$x| { ... }
+    $a.slice($n) |$x| { ... }
+    slice($a) |$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 or
-  enumerable type, and to empty arrays for a Hash.
+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 or
+enumerable type, and to empty arrays for a Hash.
 
-      $a.slice(2) |$first, $second| { ... }
+    $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, and value.
+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, and value.
 
-      $a.slice(2) |$entry|          { notice "first ${$entry[0]}, second ${$entry[1]}" }
-      $a.slice(2) |$first, $second| { notice "first ${first}, second ${second}" }
+Example Using slice with Hash
 
-  When called without a block, the function produces a concatenated result of the slices.
+    $a.slice(2) |$entry|          { notice "first ${$entry[0]}, second ${$entry[1]}" }
+    $a.slice(2) |$first, $second| { notice "first ${first}, second ${second}" }
 
-      slice([1,2,3,4,5,6], 2) # produces [[1,2], [3,4], [5,6]]
-      slice(Integer[1,6], 2)  # produces [[1,2], [3,4], [5,6]]
-      slice(4,2)              # produces [[0,1], [2,3]]
-      slice('hello',2)        # produces [[h, e], [l, l], [o]]
+When called without a block, the function produces a concatenated result of the slices.
 
-  - Since 3.2 for Array and Hash
-  - Since 3.5 for additional enumerable types
-  - requires `parser = future`.
-  ENDHEREDOC
-  require 'puppet/parser/ast/lambda'
-  require 'puppet/parser/scope'
+Example Using slice without a block
 
-  def each_Common(o, slice_size, filler, scope, pblock)
-    serving_size = pblock ? pblock.parameter_count : 1
-    if serving_size == 0
-      raise ArgumentError, "slice(): block must define at least one parameter. Block has 0."
-    end
-    unless serving_size == 1 || serving_size == slice_size
-      raise ArgumentError, "slice(): block must define one parameter, or " +
-        "the same number of parameters as the given size of the slice (#{slice_size}). Block has #{serving_size}; "+
-      pblock.parameter_names.join(', ')
-    end
-    enumerator = o.each_slice(slice_size)
-    result = []
-    if serving_size == 1
-      begin
-        if pblock
-          loop do
-            pblock.call(scope, enumerator.next)
-          end
-        else
-          loop do
-            result << enumerator.next
-          end
-        end
-      rescue StopIteration
-      end
-    else
-      begin
-        loop do
-          a = enumerator.next
-          if a.size < serving_size
-            a = a.dup.fill(filler, a.length...serving_size)
-          end
-          pblock.call(scope, *a)
-        end
-      rescue StopIteration
-      end
-    end
-    if pblock
-      o
-    else
-      result
-    end
-  end
+    slice([1,2,3,4,5,6], 2) # produces [[1,2], [3,4], [5,6]]
+    slice(Integer[1,6], 2)  # produces [[1,2], [3,4], [5,6]]
+    slice(4,2)              # produces [[0,1], [2,3]]
+    slice('hello',2)        # produces [[h, e], [l, l], [o]]
 
-  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 a 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.respond_to?(:puppet_lambda) || args.length == 2
-
-  case receiver
-  when Hash
-    each_Common(receiver, slice_size, [], self, pblock)
-  else
-    enum = Puppet::Pops::Types::Enumeration.enumerator(receiver)
-    if enum.nil?
-      raise ArgumentError, ("slice(): given type '#{tc.string(receiver)}' is not enumerable")
-    end
-    result = each_Common(enum, slice_size, :undef, self, pblock)
-    pblock ? receiver : result
-  end
+- since 3.2 for Array and Hash
+- since 3.5 for additional enumerable types
+- note requires `parser = future`.
+DOC
+) do |args|
+  function_fail(["slice() is only available when parser/evaluator future is in effect"])
 end