puppet 3.4.3 → 3.5.0.rc1

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

@@ -8,13 +8,14 @@ Puppet::Parser::Functions::newfunction(
   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 or a Hash, and the second
-  a parameterized block as produced by the puppet syntax:
+  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, the block is called with each entry in turn. When the first argument
-  is a hash the entry is an array with `[key, value]`.
+  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*
 
@@ -24,21 +25,72 @@ Puppet::Parser::Functions::newfunction(
         # Turns hash into array of keys
         $a.map |$x| { $x[0] }
 
-  - Since 3.4
-  - requires `parser = future`.
+  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.
+
+  *Examples*
+
+        # 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
+  - requires `parser = future`
   ENDHEREDOC
 
+  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
+
   receiver = args[0]
   pblock = args[1]
 
-  raise ArgumentError, ("map(): wrong argument type (#{pblock.class}; must be a parameterized block.") unless pblock.is_a? Puppet::Parser::AST::Lambda
-
+  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 Array
   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
-    raise ArgumentError, ("map(): wrong argument type (#{receiver.class}; must be an Array or a Hash.")
-  end
+    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
 
-  receiver.to_a.map {|x| pblock.call(self, x) }
+    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
 end

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

@@ -4,22 +4,27 @@ Puppet::Parser::Functions::newfunction(
 :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.
+  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 or a Hash, and the last
-  a parameterized block as produced by the puppet syntax:
+  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, 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.
+  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 collection, and if the collection has fewer than 2 elements, the first
+  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 invocations, the produced value of the invoked parameterized block is given as the memo in the
+  On each subsequent invocation, the produced value of the invoked parameterized block is given as the memo in the
   next invocation.
 
   *Examples*
@@ -34,6 +39,10 @@ Puppet::Parser::Functions::newfunction(
         $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*
@@ -48,29 +57,44 @@ Puppet::Parser::Functions::newfunction(
         $a.reduce([na, 4]) |$memo, $entry| { [sum, $memo[1]+$entry[1]] }
         #=> [sum, 10]
 
-  - Since 3.2
+  *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}; must be 2 or 3)")
+    raise ArgumentError, ("reduce(): wrong number of arguments (#{args.length}; expected 2 or 3, got #{args.length})")
   end
-  unless pblock.is_a? Puppet::Parser::AST::Lambda
-    raise ArgumentError, ("reduce(): wrong argument type (#{args[1].class}; must be a parameterized block.")
+  unless pblock.respond_to?(:puppet_lambda)
+    raise ArgumentError, ("reduce(): wrong argument type (#{pblock.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.")
+  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
-    receiver.reduce(args[1]) {|memo, x| pblock.call(self, memo, x) }
+    enum.reduce(args[1]) {|memo, x| pblock.call(self, memo, x) }
   else
-    receiver.reduce {|memo, x| pblock.call(self, memo, x) }
+    enum.reduce {|memo, x| pblock.call(self, memo, x) }
   end
 end

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

@@ -12,4 +12,4 @@ Puppet::Parser::Functions::newfunction(
 
   raise NotImplementedError,
     "The 'select' function has been renamed to 'filter'. Please update your manifests."
-end
+end

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

@@ -7,31 +7,36 @@ Puppet::Parser::Functions::newfunction(
   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 or a Hash, 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| { ... }
 
   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.
+  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| { ... }
 
-  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.
+  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}" }
 
   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]]
+      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]]
 
-  - Since 3.2
+  - Since 3.2 for Array and Hash
+  - Since 3.5 for additional enumerable types
   - requires `parser = future`.
   ENDHEREDOC
   require 'puppet/parser/ast/lambda'
@@ -40,28 +45,38 @@ Puppet::Parser::Functions::newfunction(
   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."
+      raise ArgumentError, "slice(): block must define at least one parameter. Block has 0."
     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})."
+      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
-      ((o.size.to_f / slice_size).ceil).times do
+      begin
         if pblock
-          pblock.call(scope, enumerator.next)
+          loop do
+            pblock.call(scope, enumerator.next)
+          end
         else
-          result << enumerator.next
+          loop do
+            result << enumerator.next
+          end
         end
+      rescue StopIteration
       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)
+      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
-        pblock.call(scope, *a)
+      rescue StopIteration
       end
     end
     if pblock
@@ -70,6 +85,7 @@ Puppet::Parser::Functions::newfunction(
       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
@@ -84,14 +100,17 @@ Puppet::Parser::Functions::newfunction(
 
   # 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
+  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 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.")
+    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
 end

data/lib/puppet/parser/grammar.ra

@@ -738,6 +738,7 @@ regex:        REGEX {
 }
 
 hash:        LBRACE hashpairs RBRACE {
+  @lexer.commentpop
   if val[1].instance_of?(AST::ASTHash)
     result = val[1]
   else
@@ -745,12 +746,14 @@ hash:        LBRACE hashpairs RBRACE {
   end
 }
   | LBRACE hashpairs COMMA RBRACE {
+    @lexer.commentpop
     if val[1].instance_of?(AST::ASTHash)
     result = val[1]
   else
     result = ast AST::ASTHash, { :value => val[1] }
   end
 }           | LBRACE RBRACE {
+  @lexer.commentpop
   result = ast AST::ASTHash
 }
 

data/lib/puppet/parser/lexer.rb

@@ -347,7 +347,7 @@ class Puppet::Parser::Lexer
   def file=(file)
     @file = file
     @line = 1
-    contents = Puppet::FileSystem::File.exist?(file) ? File.read(file) : ""
+    contents = Puppet::FileSystem.exist?(file) ? Puppet::FileSystem.read(file) : ""
     @scanner = StringScanner.new(contents)
   end
 
@@ -478,26 +478,27 @@ class Puppet::Parser::Lexer
         next
       end
 
-      lexing_context[:after]         = final_token.name unless newline
-      lexing_context[:string_interpolation_depth] += 1 if final_token.name == :DQPRE
-      lexing_context[:string_interpolation_depth] -= 1 if final_token.name == :DQPOST
+      final_token_name = final_token.name
+      lexing_context[:after]         = final_token_name unless newline
+      lexing_context[:string_interpolation_depth] += 1 if final_token_name == :DQPRE
+      lexing_context[:string_interpolation_depth] -= 1 if final_token_name == :DQPOST
 
       value = token_value[:value]
 
-      if match = @@pairs[value] and final_token.name != :DQUOTE and final_token.name != :SQUOTE
+      if match = @@pairs[value] and final_token_name != :DQUOTE and final_token_name != :SQUOTE
         @expected << match
-      elsif exp = @expected[-1] and exp == value and final_token.name != :DQUOTE and final_token.name != :SQUOTE
+      elsif exp = @expected[-1] and exp == value and final_token_name != :DQUOTE and final_token_name != :SQUOTE
         @expected.pop
       end
 
-      if final_token.name == :LBRACE or final_token.name == :LPAREN
+      if final_token_name == :LBRACE or final_token_name == :LPAREN
         commentpush
       end
-      if final_token.name == :RPAREN
+      if final_token_name == :RPAREN
         commentpop
       end
 
-      yield [final_token.name, token_value]
+      yield [final_token_name, token_value]
 
       if @previous_token
         namestack(value) if @previous_token.name == :CLASS and value != '{'

data/lib/puppet/parser/parser.rb

@@ -20,7 +20,7 @@ module Puppet
   module Parser
     class Parser < Racc::Parser
 
-module_eval(<<'...end grammar.ra/module_eval...', 'grammar.ra', 797)
+module_eval(<<'...end grammar.ra/module_eval...', 'grammar.ra', 799)
 
 # It got too annoying having code in a file that needs to be compiled.
 require 'puppet/parser/parser_support'
@@ -2462,7 +2462,8 @@ module_eval(<<'.,.,', 'grammar.ra', 736)
 
 module_eval(<<'.,.,', 'grammar.ra', 740)
   def _reduce_230(val, _values, result)
-      if val[1].instance_of?(AST::ASTHash)
+      @lexer.commentpop
+  if val[1].instance_of?(AST::ASTHash)
     result = val[1]
   else
     result = ast AST::ASTHash, { :value => val[1] }
@@ -2472,9 +2473,10 @@ module_eval(<<'.,.,', 'grammar.ra', 740)
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 747)
+module_eval(<<'.,.,', 'grammar.ra', 748)
   def _reduce_231(val, _values, result)
-        if val[1].instance_of?(AST::ASTHash)
+        @lexer.commentpop
+    if val[1].instance_of?(AST::ASTHash)
     result = val[1]
   else
     result = ast AST::ASTHash, { :value => val[1] }
@@ -2484,9 +2486,10 @@ module_eval(<<'.,.,', 'grammar.ra', 747)
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 753)
+module_eval(<<'.,.,', 'grammar.ra', 755)
   def _reduce_232(val, _values, result)
-      result = ast AST::ASTHash
+      @lexer.commentpop
+  result = ast AST::ASTHash
 
     result
   end
@@ -2494,7 +2497,7 @@ module_eval(<<'.,.,', 'grammar.ra', 753)
 
 # reduce 233 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 758)
+module_eval(<<'.,.,', 'grammar.ra', 761)
   def _reduce_234(val, _values, result)
         if val[0].instance_of?(AST::ASTHash)
     result = val[0].merge(val[2])
@@ -2507,7 +2510,7 @@ module_eval(<<'.,.,', 'grammar.ra', 758)
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 767)
+module_eval(<<'.,.,', 'grammar.ra', 770)
   def _reduce_235(val, _values, result)
       result = ast AST::ASTHash, { :value => { val[0] => val[2] } }
 
@@ -2515,21 +2518,21 @@ module_eval(<<'.,.,', 'grammar.ra', 767)
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 770)
+module_eval(<<'.,.,', 'grammar.ra', 773)
   def _reduce_236(val, _values, result)
      result = val[0][:value] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 771)
+module_eval(<<'.,.,', 'grammar.ra', 774)
   def _reduce_237(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 774)
+module_eval(<<'.,.,', 'grammar.ra', 777)
   def _reduce_238(val, _values, result)
       result = ast AST::HashOrArrayAccess, :variable => val[0][:value], :key => val[2]
 
@@ -2539,7 +2542,7 @@ module_eval(<<'.,.,', 'grammar.ra', 774)
 
 # reduce 239 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 779)
+module_eval(<<'.,.,', 'grammar.ra', 782)
   def _reduce_240(val, _values, result)
         result = ast AST::HashOrArrayAccess, :variable => val[0], :key => val[2]