puppet 3.6.2 → 3.7.0

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

@@ -1,109 +1,48 @@
 Puppet::Parser::Functions::newfunction(
-:each,
-:type => :rvalue,
-:arity => 2,
-:doc => <<-'ENDHEREDOC') do |args|
-  Applies a parameterized block to each element in a sequence of selected entries from the first
-  argument and returns the first argument.
-
-  This function takes two mandatory arguments: the first should be an Array or a Hash or something that is
-  of enumerable type (integer, Integer range, or String), and the second
-  a parameterized block as produced by the puppet syntax:
-
-        $a.each |$x| { ... }
-        each($a) |$x| { ... }
-
-  When the first argument is an Array (or of enumerable type other than Hash), the parameterized block
-  should define one or two block parameters.
-  For each application of the block, the next element from the array is selected, and it is passed to
-  the block if the block has one parameter. If the block has two parameters, the first is the elements
-  index, and the second the value. The index starts from 0.
-
-        $a.each |$index, $value| { ... }
-        each($a) |$index, $value| { ... }
-
-  When the first argument is a Hash, the parameterized block should define one or two parameters.
-  When one parameter is defined, the iteration is performed with each entry as an array of `[key, value]`,
-  and when two parameters are defined the iteration is performed with key and value.
-
-        $a.each |$entry|       { ..."key ${$entry[0]}, value ${$entry[1]}" }
-        $a.each |$key, $value| { ..."key ${key}, value ${value}" }
-
-  *Examples*
-
-        [1,2,3].each |$val| { ... }                       # 1, 2, 3
-        [5,6,7].each |$index, $val| { ... }               # (0, 5), (1, 6), (2, 7)
-        {a=>1, b=>2, c=>3}].each |$val| { ... }           # ['a', 1], ['b', 2], ['c', 3]
-        {a=>1, b=>2, c=>3}.each |$key, $val| { ... }      # ('a', 1), ('b', 2), ('c', 3)
-        Integer[ 10, 20 ].each |$index, $value| { ... }   # (0, 10), (1, 11) ...
-        "hello".each |$char| { ... }                      # 'h', 'e', 'l', 'l', 'o'
-        3.each |$number| { ... }                          # 0, 1, 2
-
-  - Since 3.2 for Array and Hash
-  - Since 3.5 for other enumerables
-  - requires `parser = future`.
-  ENDHEREDOC
-  require 'puppet/parser/ast/lambda'
-
-  def foreach_Hash(o, scope, pblock, serving_size)
-    enumerator = o.each_pair
-    if serving_size == 1
-      (o.size).times do
-        pblock.call(scope, enumerator.next)
-      end
-    else
-      (o.size).times do
-        pblock.call(scope, *enumerator.next)
-      end
-    end
-  end
-
-  def foreach_Enumerator(enumerator, scope, pblock, serving_size)
-    index = 0
-    if serving_size == 1
-      begin
-        loop { pblock.call(scope, enumerator.next) }
-      rescue StopIteration
-      end
-    else
-      begin
-        loop do
-          pblock.call(scope, index, enumerator.next)
-          index = index +1
-        end
-      rescue StopIteration
-      end
-    end
-  end
-
-  raise ArgumentError, ("each(): wrong number of arguments (#{args.length}; expected 2, got #{args.length})") if args.length != 2
-  receiver = args[0]
-  pblock = args[1]
-  raise ArgumentError, ("each(): wrong argument type (#{args[1].class}; must be a parameterized block.") unless pblock.respond_to?(:puppet_lambda)
-
-  serving_size = pblock.parameter_count
-  if serving_size == 0
-    raise ArgumentError, "each(): block must define at least one parameter; value. Block has 0."
-  end
-
-  case receiver
-  when Hash
-    if serving_size > 2
-      raise ArgumentError, "each(): block must define at most two parameters; key, value. Block has #{serving_size}; "+
-      pblock.parameter_names.join(', ')
-    end
-    foreach_Hash(receiver, self, pblock, serving_size)
-  else
-    if serving_size > 2
-      raise ArgumentError, "each(): block must define at most two parameters; index, value. Block has #{serving_size}; "+
-        pblock.parameter_names.join(', ')
-    end
-    enum = Puppet::Pops::Types::Enumeration.enumerator(receiver)
-    unless enum
-      raise ArgumentError, ("each(): wrong argument type (#{receiver.class}; must be something enumerable.")
-    end
-    foreach_Enumerator(enum, self, pblock, serving_size)
-  end
-  # each always produces the receiver
-  receiver
+  :each,
+  :type => :rvalue,
+  :arity => -3,
+  :doc => <<-DOC
+Applies a parameterized block to each element in a sequence of selected entries from the first
+argument and returns the first argument.
+
+This function takes two mandatory arguments: the first should be an Array or a Hash or something that is
+of enumerable type (integer, Integer range, or String), and the second
+a parameterized block as produced by the puppet syntax:
+
+      $a.each |$x| { ... }
+      each($a) |$x| { ... }
+
+When the first argument is an Array (or of enumerable type other than Hash), the parameterized block
+should define one or two block parameters.
+For each application of the block, the next element from the array is selected, and it is passed to
+the block if the block has one parameter. If the block has two parameters, the first is the elements
+index, and the second the value. The index starts from 0.
+
+      $a.each |$index, $value| { ... }
+      each($a) |$index, $value| { ... }
+
+When the first argument is a Hash, the parameterized block should define one or two parameters.
+When one parameter is defined, the iteration is performed with each entry as an array of `[key, value]`,
+and when two parameters are defined the iteration is performed with key and value.
+
+      $a.each |$entry|       { ..."key ${$entry[0]}, value ${$entry[1]}" }
+      $a.each |$key, $value| { ..."key ${key}, value ${value}" }
+
+Example using each:
+
+      [1,2,3].each |$val| { ... }                       # 1, 2, 3
+      [5,6,7].each |$index, $val| { ... }               # (0, 5), (1, 6), (2, 7)
+      {a=>1, b=>2, c=>3}].each |$val| { ... }           # ['a', 1], ['b', 2], ['c', 3]
+      {a=>1, b=>2, c=>3}.each |$key, $val| { ... }      # ('a', 1), ('b', 2), ('c', 3)
+      Integer[ 10, 20 ].each |$index, $value| { ... }   # (0, 10), (1, 11) ...
+      "hello".each |$char| { ... }                      # 'h', 'e', 'l', 'l', 'o'
+      3.each |$number| { ... }                          # 0, 1, 2
+
+- since 3.2 for Array and Hash
+- since 3.5 for other enumerables
+- note requires `parser = future`
+DOC
+) do |args|
+  function_fail(["each() is only available when parser/evaluator future is in effect"])
 end

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

@@ -1,7 +1,15 @@
 Puppet::Parser::Functions::newfunction(:epp, :type => :rvalue, :arity => -2, :doc =>
 "Evaluates an Embedded Puppet Template (EPP) file and returns the rendered text result as a String.
 
-EPP support the following tags:
+The first argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
+reference, which will load `<TEMPLATE FILE>` from a module's `templates`
+directory. (For example, the reference `apache/vhost.conf.epp` will load the
+file `<MODULES DIRECTORY>/apache/templates/vhost.conf.epp`.)
+
+The second argument is optional; if present, it should be a hash containing parameters for the
+template. (See below.)
+
+EPP supports 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.
@@ -9,7 +17,7 @@ EPP support the following tags:
 * `<%%` 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.
+* `<%- |parameters| -%>` - When placed as the first tag declares the template's parameters.
 
 File based EPP supports the following visibilities of variables in scope:
 
@@ -18,7 +26,7 @@ File based EPP supports the following visibilities of variables in scope:
 * 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
+`<%- |$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
@@ -31,11 +39,7 @@ scope where the `epp` function is called from.
 
 - See function inline_epp for examples of EPP
 - Since 3.5
-- Requires Future Parser") do |arguments|
-  # Requires future parser
-  unless Puppet[:parser] == "future"
-    raise ArgumentError, "epp(): function is only available when --parser future is in effect"
-  end
-  Puppet::Pops::Evaluator::EppEvaluator.epp(self, arguments[0], self.compiler.environment, arguments[1])
+- Requires Future Parser") do |args|
 
+  function_fail(["epp() is only available when parser/evaluator future is in effect"])
 end

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

@@ -1,22 +1,30 @@
-# Returns the contents of a file
-
 Puppet::Parser::Functions::newfunction(
   :file, :arity => -2, :type => :rvalue,
-  :doc => "Return the contents of a file.  Multiple files
-  can be passed, and the first file that exists will be read in."
+  :doc => "Loads a file from a module and returns its contents as a string.
+
+  The argument to this function should be a `<MODULE NAME>/<FILE>`
+  reference, which will load `<FILE>` from a module's `files`
+  directory. (For example, the reference `mysql/mysqltuner.pl` will load the
+  file `<MODULES DIRECTORY>/mysql/files/mysqltuner.pl`.)
+
+  This function can also accept:
+
+  * An absolute path, which can load a file from anywhere on disk.
+  * Multiple arguments, which will return the contents of the **first** file
+  found, skipping any files that don't exist.
+  "
 ) do |vals|
-    ret = nil
+    path = nil
     vals.each do |file|
-      unless Puppet::Util.absolute_path?(file)
-        raise Puppet::ParseError, "Files must be fully qualified"
-      end
-      if Puppet::FileSystem.exist?(file)
-        ret = File.read(file)
+      found = Puppet::Parser::Files.find_file(file, compiler.environment)
+      if found && Puppet::FileSystem.exist?(found)
+        path = found
         break
       end
     end
-    if ret
-      ret
+
+    if path
+      File.read(path)
     else
       raise Puppet::ParseError, "Could not find any files from #{vals.join(", ")}"
     end

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

@@ -1,100 +1,44 @@
-require 'puppet/parser/ast/lambda'
-
 Puppet::Parser::Functions::newfunction(
-:filter,
-: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 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]`.
-
-  *Examples*
+  :filter,
+  :arity => -3,
+  :doc => <<-DOC
+ 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`.
 
-        # selects all that end with berry
-        $a = ["raspberry", "blueberry", "orange"]
-        $a.filter |$x| { $x =~ /berry$/ }          # rasberry, blueberry
+ 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:
 
-  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.
+       $a.filter |$x| { ... }
+       filter($a) |$x| { ... }
 
-  *Examples*
+ 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]`.
 
-        # 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
+ Example Using filter with one parameter
 
-        # 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
+       # selects all that end with berry
+       $a = ["raspberry", "blueberry", "orange"]
+       $a.filter |$x| { $x =~ /berry$/ }          # rasberry, blueberry
 
-  - Since 3.4 for Array and Hash
-  - Since 3.5 for other enumerables
-  - requires `parser = future`
-  ENDHEREDOC
+ 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.
 
-  def filter_Enumerator(enumerator, scope, pblock, serving_size)
-    result = []
-    index = 0
-    if serving_size == 1
-      begin
-        loop { pblock.call(scope, it = enumerator.next) == true ? result << it : nil }
-      rescue StopIteration
-      end
-    else
-      begin
-        loop do
-          pblock.call(scope, index, it = enumerator.next) == true ? result << it : nil
-          index = index +1
-        end
-      rescue StopIteration
-      end
-    end
-    result
-  end
+Example Using filter with two parameters
 
-  receiver = args[0]
-  pblock = args[1]
+     # 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
 
-  raise ArgumentError, ("filter(): 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, "filter(): block must define at least one parameter; value. Block has 0."
-  end
+     # 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
 
-  case receiver
-  when Hash
-    if serving_size > 2
-      raise ArgumentError, "filter(): block must define at most two parameters; key, value. Block has #{serving_size}; "+
-      pblock.parameter_names.join(', ')
-    end
-    if serving_size == 1
-      result = receiver.select {|x, y| pblock.call(self, [x, y]) }
-    else
-      result = receiver.select {|x, y| pblock.call(self, x, y) }
-    end
-    # Ruby 1.8.7 returns Array
-    result = Hash[result] unless result.is_a? Hash
-    result
-  else
-    if serving_size > 2
-      raise ArgumentError, "filter(): block must define at most two parameters; index, value. Block has #{serving_size}; "+
-      pblock.parameter_names.join(', ')
-    end
-    enum = Puppet::Pops::Types::Enumeration.enumerator(receiver)
-    unless enum
-      raise ArgumentError, ("filter(): wrong argument type (#{receiver.class}; must be something enumerable.")
-    end
-    filter_Enumerator(enum, self, pblock, serving_size)
-  end
+- since 3.4 for Array and Hash
+- since 3.5 for other enumerables
+- note requires `parser = future`
+DOC
+) do |args|
+  function_fail(["filter() is only available when parser/evaluator future is in effect"])
 end

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

@@ -17,31 +17,19 @@ and resource-like declarations with the same class.
 The `include` function does not cause classes to be contained in the class
 where they are declared. For that, see the `contain` function. It also
 does not create a dependency relationship between the declared class and the
-surrounding class; for that, see the `require` function.") do |vals|
-    if vals.is_a?(Array)
-      # Protect against array inside array
-      vals = vals.flatten
-    else
-      vals = [vals]
-    end
+surrounding class; for that, see the `require` function.
 
-    # The 'false' disables lazy evaluation.
-    klasses = compiler.evaluate_classes(vals, self, false)
+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.
 
-    missing = vals.find_all do |klass|
-      ! klasses.include?(klass)
-    end
+") do |vals|
 
-    unless missing.empty?
-      # Throw an error if we didn't evaluate all of the classes.
-      str = "Could not find class"
-      str += "es" if missing.length > 1
-
-      str += " " + missing.join(", ")
-
-      if n = namespaces and ! n.empty? and n != [""]
-        str += " in namespaces #{@namespaces.join(", ")}"
-      end
-      self.fail Puppet::ParseError, str
-    end
+  # Unify call patterns (if called with nested arrays), make names absolute if
+  # wanted and evaluate the classes
+  compiler.evaluate_classes(
+  transform_and_assert_classnames(
+      vals.is_a?(Array) ? vals.flatten : [vals]),
+      self, false)
 end

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

@@ -9,7 +9,7 @@ EPP support the following tags:
 * `<%%` 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.
+* `<%- |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:
@@ -20,7 +20,7 @@ are used - see further below:
 * 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
+`<%- |$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
@@ -37,43 +37,40 @@ is subject to expression interpolation before the string is parsed as an EPP tem
     # produces 'Hello local variable world!'
     $x ='local variable'
     inline_epptemplate(@(END:epp))
-    <%-( $x )-%>
+    <%- |$x| -%>
     Hello <%= $x %> world!
     END
 
     # produces 'Hello given argument world!'
     $x ='local variable world'
     inline_epptemplate(@(END:epp), { x =>'given argument'})
-    <%-( $x )-%>
+    <%- |$x| -%>
     Hello <%= $x %> world!
     END
 
     # produces 'Hello given argument world!'
     $x ='local variable world'
     inline_epptemplate(@(END:epp), { x =>'given argument'})
-    <%-( $x )-%>
+    <%- |$x| -%>
     Hello <%= $x %>!
     END
 
     # results in error, missing value for y
     $x ='local variable world'
     inline_epptemplate(@(END:epp), { x =>'given argument'})
-    <%-( $x, $y )-%>
+    <%- |$x, $y| -%>
     Hello <%= $x %>!
     END
 
     # Produces 'Hello given argument planet'
     $x ='local variable world'
     inline_epptemplate(@(END:epp), { x =>'given argument'})
-    <%-( $x, $y=planet)-%>
+    <%- |$x, $y=planet| -%>
     Hello <%= $x %> <%= $y %>!
     END
 
 - Since 3.5
 - Requires Future Parser") do |arguments|
-  # Requires future parser
-  unless Puppet[:parser] == "future"
-    raise ArgumentError, "inline_epp(): function is only available when --parser future is in effect"
-  end
-  Puppet::Pops::Evaluator::EppEvaluator.inline_epp(self, arguments[0], arguments[1])
+
+  function_fail(["inline_epp() is only available when parser/evaluator future is in effect"])
 end