puppet 3.7.4-x86-mingw32 → 3.7.5-x86-mingw32

data/lib/puppet/functions/scanf.rb

@@ -36,10 +36,10 @@ Puppet::Functions.create_function(:scanf) do
     optional_block_param
   end
 
-  def scanf(data, format, block=nil)
+  def scanf(data, format)
     result = data.scanf(format)
-    if !block.nil?
-      result = block.call({}, result)
+    if block_given?
+      result = yield(result)
     end
     result
   end

data/lib/puppet/functions/slice.rb

@@ -51,15 +51,15 @@ Puppet::Functions.create_function(:slice) do
     optional_block_param
   end
 
-  def slice_Hash(hash, slice_size, pblock = nil)
-    result = slice_Common(hash, slice_size, [], pblock)
-    pblock ? hash : result
+  def slice_Hash(hash, slice_size, &pblock)
+    result = slice_Common(hash, slice_size, [], block_given? ? pblock : nil)
+    block_given? ? hash : result
   end
 
-  def slice_Enumerable(enumerable, slice_size, pblock = nil)
+  def slice_Enumerable(enumerable, slice_size, &pblock)
     enum = asserted_enumerable(enumerable)
-    result = slice_Common(enum, slice_size, nil, pblock)
-    pblock ? enumerable : result
+    result = slice_Common(enum, slice_size, nil, block_given? ? pblock : nil)
+    block_given? ? enumerable : result
   end
 
   def slice_Common(o, slice_size, filler, pblock)
@@ -71,7 +71,7 @@ Puppet::Functions.create_function(:slice) do
       begin
         if pblock
           loop do
-            pblock.call(nil, enumerator.next)
+            pblock.call(enumerator.next)
           end
         else
           loop do
@@ -87,7 +87,7 @@ Puppet::Functions.create_function(:slice) do
           if a.size < serving_size
             a = a.dup.fill(filler, a.length...serving_size)
           end
-          pblock.call(nil, *a)
+          pblock.call(*a)
         end
       rescue StopIteration
       end
@@ -101,7 +101,8 @@ Puppet::Functions.create_function(:slice) do
 
   def asserted_slice_serving_size(pblock, slice_size)
     if pblock
-      serving_size = pblock.last_captures_rest? ? slice_size : pblock.parameter_count
+      arity = pblock.arity
+      serving_size = arity < 0 ? slice_size : arity
     else
       serving_size = 1
     end

data/lib/puppet/functions/with.rb

@@ -12,12 +12,11 @@
 #
 Puppet::Functions.create_function(:with) do
   dispatch :with do
-    param 'Any', 'arg'
-    arg_count(0, :default)
-    required_block_param
+    repeated_param 'Any', :arg
+    block_param
   end
 
   def with(*args)
-    args[-1].call({}, *args[0..-2])
+    yield(*args)
   end
 end

data/lib/puppet/graph/simple_graph.rb

@@ -435,19 +435,19 @@ class Puppet::Graph::SimpleGraph
     graph      = (directed? ? DOT::DOTDigraph : DOT::DOTSubgraph).new(params)
     edge_klass = directed? ? DOT::DOTDirectedEdge : DOT::DOTEdge
     vertices.each do |v|
-      name = v.to_s
+      name = v.ref
       params = {'name'     => '"'+name+'"',
         'fontsize' => fontsize,
         'label'    => name}
-      v_label = v.to_s
+      v_label = v.ref
       params.merge!(v_label) if v_label and v_label.kind_of? Hash
       graph << DOT::DOTNode.new(params)
     end
     edges.each do |e|
-      params = {'from'     => '"'+ e.source.to_s + '"',
-        'to'       => '"'+ e.target.to_s + '"',
+      params = {'from'     => '"'+ e.source.ref + '"',
+        'to'       => '"'+ e.target.ref + '"',
         'fontsize' => fontsize }
-      e_label = e.to_s
+      e_label = e.ref
       params.merge!(e_label) if e_label and e_label.kind_of? Hash
       graph << edge_klass.new(params)
     end

data/lib/puppet/metatype/manager.rb

@@ -119,7 +119,7 @@ module Manager
     klass.providerloader = Puppet::Util::Autoload.new(klass, "puppet/provider/#{klass.name.to_s}")
 
     # We have to load everything so that we can figure out the default provider.
-    klass.providerloader.loadall
+    klass.providerloader.loadall Puppet.lookup(:current_environment)
     klass.providify unless klass.providers.empty?
 
     klass

data/lib/puppet/node/environment.rb

@@ -550,7 +550,7 @@ class Puppet::Node::Environment
       if file == NO_MANIFEST
         Puppet::Parser::AST::Hostclass.new('')
       elsif File.directory?(file)
-        if Puppet[:parser] == 'future'
+        if Puppet.future_parser?
           parse_results = Puppet::FileSystem::PathPattern.absolute(File.join(file, '**/*.pp')).glob.sort.map do | file_to_parse |
             parser.file = file_to_parse
             parser.parse

data/lib/puppet/parser/ast/arithmetic_operator.rb

@@ -70,7 +70,7 @@ class Puppet::Parser::AST
     end
 
     def assert_concatenation_supported
-      return if Puppet[:parser] == 'future'
+      return if Puppet.future_parser?
       raise ParseError.new("Unsupported Operation: Array concatenation available with '--parser future' setting only.")
     end
 

data/lib/puppet/parser/ast/collexpr.rb

@@ -9,7 +9,7 @@ class CollExpr < AST::Branch
   attr_accessor :test1, :test2, :oper, :form, :type, :parens
 
   def evaluate(scope)
-    if Puppet[:parser] == 'future'
+    if Puppet.future_parser?
       evaluate4x(scope)
     else
       evaluate3x(scope)

data/lib/puppet/parser/compiler.rb

@@ -150,7 +150,7 @@ class Puppet::Parser::Compiler
 
   # Constructs the overrides for the context
   def context_overrides()
-    if Puppet[:parser] == 'future'
+    if Puppet.future_parser?
       require 'puppet/loaders'
       {
         :current_environment => environment,
@@ -294,7 +294,7 @@ class Puppet::Parser::Compiler
   # Answers if Puppet Binder should be active or not, and if it should and is not active, then it is activated.
   # @return [Boolean] true if the Puppet Binder should be activated
   def is_binder_active?
-    should_be_active = Puppet[:binder] || Puppet[:parser] == 'future'
+    should_be_active = Puppet[:binder] || Puppet.future_parser?
     if should_be_active
       # TODO: this should be in a central place, not just for ParserFactory anymore...
       Puppet::Parser::ParserFactory.assert_rgen_installed()
@@ -447,7 +447,7 @@ class Puppet::Parser::Compiler
   # look for resources, because we want to consider those to be
   # parse errors.
   def fail_on_unevaluated_resource_collections
-    if Puppet[:parser] == 'future'
+    if Puppet.future_parser?
       remaining = @collections.collect(&:unresolved_resources).flatten.compact
     else
       remaining = @collections.collect(&:resources).flatten.compact

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

@@ -70,13 +70,5 @@ Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc =>
     resource.virtual = true
   end
 
-  begin
-    resource.safeevaluate(self)
-  rescue Puppet::ParseError => internal_error
-    if internal_error.original.nil?
-      raise internal_error
-    else
-      raise internal_error.original
-    end
-  end
+  resource.safeevaluate(self)
 end

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

@@ -52,7 +52,7 @@ Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :arity => -2,
       when Puppet::Resource
         compiler.findresource(val.type, val.title)
       else
-        if Puppet[:parser] == 'future'
+        if Puppet.future_parser?
           case val
           when Puppet::Pops::Types::PResourceType
             raise ArgumentError, "The given resource type is a reference to all kind of types" if val.type_name.nil?

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

@@ -3,20 +3,29 @@ require 'hiera_puppet'
 module Puppet::Parser::Functions
   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). 
+  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:
+  The function can be called in one of three ways:
+  1. Using 1 to 3 arguments where the arguments are:
+     'key'      [String] Required
+           The key to lookup.
+     'default`  [Any] Optional
+           A value to return when there's no match for `key`. Optional
+     `override` [Any] Optional
+           An 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.
 
-  - 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.
+  2. Using a 'key' and an optional 'override' parameter like in #1 but with a block to
+     provide the default value. The block is called with one parameter (the key) and
+     should return the value. This option can only be used with the 3x future parser or
+     from 4.0.0.
 
-  More thorough examples of `hiera` are available at:  
+  3. Like #1 but with all arguments passed in an array.
+
+  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)

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

@@ -1,23 +1,33 @@
 require 'hiera_puppet'
 
 module Puppet::Parser::Functions
-  newfunction(:hiera_array, :type => :rvalue, :arity => -2,:doc => "Returns all 
+  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.
-    
+
+  The function can be called in one of three ways:
+  1. Using 1 to 3 arguments where the arguments are:
+     'key'      [String] Required
+           The key to lookup.
+     'default`  [Any] Optional
+           A value to return when there's no match for `key`. Optional
+     `override` [Any] Optional
+           An 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.
+
+  2. Using a 'key' and an optional 'override' parameter like in #1 but with a block to
+     provide the default value. The block is called with one parameter (the key) and
+     should return the value. This option can only be used with the 3x future parser or
+     from 4.0.0.
+
+  3. Like #1 but with all arguments passed in an array.
+
   If any matched value is a hash, puppet will raise a type mismatch error.
 
-  More thorough examples of `hiera` are available at:  
+  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)

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

@@ -1,25 +1,35 @@
 require 'hiera_puppet'
 
 module Puppet::Parser::Functions
-  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 
+  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.
-    
+
+  The function can be called in one of three ways:
+  1. Using 1 to 3 arguments where the arguments are:
+     'key'      [String] Required
+           The key to lookup.
+     'default`  [Any] Optional
+           A value to return when there's no match for `key`. Optional
+     `override` [Any] Optional
+           An 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.
+
+  2. Using a 'key' and an optional 'override' parameter like in #1 but with a block to
+     provide the default value. The block is called with one parameter (the key) and
+     should return the value. This option can only be used with the 3x future parser or
+     from 4.0.0.
+
+  3. Like #1 but with all arguments passed in an array.
+
   `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:  
+  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)

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

@@ -19,15 +19,26 @@ module Puppet::Parser::Functions
               - 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.
+  The function can be called in one of three ways:
+  1. Using 1 to 3 arguments where the arguments are:
+     'key'      [String] Required
+           The key to lookup.
+     'default`  [Any] Optional
+           A value to return when there's no match for `key`. Optional
+     `override` [Any] Optional
+           An 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.
+
+  2. Using a 'key' and an optional 'override' parameter like in #1 but with a block to
+     provide the default value. The block is called with one parameter (the key) and
+     should return the array to be used in the subsequent call to include.
+     This option can only be used with the 3x future parser or
+     from 4.0.0.
+
+  3. Like #1 but with all arguments passed in an array.
 
   More thorough examples of `hiera_include` are available at:
   <http://docs.puppetlabs.com/hiera/1/puppet.html#hiera-lookup-functions>

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

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

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

@@ -8,7 +8,7 @@ Puppet::Parser::Functions::newfunction(:realize, :arity => -2, :doc => "Make a v
     reference; e.g.: `realize User[luke]`." ) do |vals|
 
     vals = [vals] unless vals.is_a?(Array)
-    if Puppet[:parser] == 'future'
+    if Puppet.future_parser?
       coll = Puppet::Pops::Evaluator::Collectors::FixedSetCollector.new(self, vals.flatten)
     else
       coll = Puppet::Parser::Collector.new(self, :nomatter, nil, nil, :virtual)

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

@@ -1,3 +1,5 @@
+require 'scanf'
+
 Puppet::Parser::Functions::newfunction(
   :scanf,
   :type => :rvalue,
@@ -7,17 +9,22 @@ Scans a string and returns an array of one or more converted values as directed
 See the documenation of Ruby's String::scanf method for details about the supported formats (which
 are similar but not identical to the formats used in Puppet's `sprintf` function.
 
-This function takes two mandatory arguments: the first is the String to convert, and the second
-the format String. A parameterized block may optionally be given, which is called with the result
-that is produced by scanf if no block is present, the result of the block is then returned by
-the function.
+This function takes two mandatory arguments: the first is the String to
+convert, and the second the format String. The result of the scan is an Array,
+with each sucessfully scanned and transformed value.args The scanning stops if
+a scan is unsuccesful and the scanned result up to that point is returned. If
+there was no succesful scan at all, the result is an empty Array.
+
+      scanf("42", "%i")[0] == 42
+
 
-The result of the scan is an Array, with each sucessfully scanned and transformed value.args The scanning
-stops if a scan is unsuccesful and the scanned result up to that point is returned. If there was no
-succesful scan at all, the result is an empty Array. The optional code block is typically used to
-assert that the scan was succesful, and either produce the same input, or perform unwrapping of
-the result
+When used with the future parser, an optional parameterized block may be given.  
+The block is called with the result that is produced by scanf if no block is
+present, the result of the block is then returned by the function.
 
+The optional code block is typically used to assert that the scan was
+succesful, and either produce the same input, or perform unwrapping of
+the result:
 
       "42".scanf("%i")
       "42".scanf("%i") |$x| {
@@ -27,9 +34,11 @@ the result
         $x[0]
       }
 
-- since 3.7.4
-- note requires `parser = future`
+- since 3.7.4 with `parser = future`
+- since 3.7.5 with classic parser
 DOC
 ) do |args|
-  function_fail(["scanf() is only available when parser/evaluator future is in effect"])
+  data = args[0]
+  format = args[1]
+  result = data.scanf(format)
 end