Update puppetlabs/stdlib module

[mirror/dsa-puppet.git] / 3rdparty / modules / stdlib / lib / puppet / parser / functions / range.rb

diff --git a/3rdparty/modules/stdlib/lib/puppet/parser/functions/range.rb b/3rdparty/modules/stdlib/lib/puppet/parser/functions/range.rb
index 49fba21..31baee5 100644 (file)
--- a/3rdparty/modules/stdlib/lib/puppet/parser/functions/range.rb
+++ b/3rdparty/modules/stdlib/lib/puppet/parser/functions/range.rb
@@ -1,72 +1,73 @@
 #
 # range.rb
 #
-
 # TODO(Krzysztof Wilczynski): We probably need to approach numeric values differently ...
-
 module Puppet::Parser::Functions
-  newfunction(:range, :type => :rvalue, :doc => <<-EOS
-When given range in the form of (start, stop) it will extrapolate a range as
-an array.
+  newfunction(:range, :type => :rvalue, :doc => <<-DOC
+    When given range in the form of (start, stop) it will extrapolate a range as
+    an array.
+
+    *Examples:*
 
-*Examples:*
+        range("0", "9")
 
-    range("0", "9")
+    Will return: [0,1,2,3,4,5,6,7,8,9]
 
-Will return: [0,1,2,3,4,5,6,7,8,9]
+        range("00", "09")
 
-    range("00", "09")
+    Will return: [0,1,2,3,4,5,6,7,8,9] (Zero padded strings are converted to
+    integers automatically)
 
-Will return: [0,1,2,3,4,5,6,7,8,9] (Zero padded strings are converted to
-integers automatically)
+        range("a", "c")
 
-    range("a", "c")
+    Will return: ["a","b","c"]
 
-Will return: ["a","b","c"]
+        range("host01", "host10")
+    Will return: ["host01", "host02", ..., "host09", "host10"]
+    NB Be explicit in including trailing zeros. Otherwise the underlying ruby function will fail.
 
-    range("host01", "host10")
+    Passing a third argument will cause the generated range to step by that
+    interval, e.g.
 
-Will return: ["host01", "host02", ..., "host09", "host10"]
+        range("0", "9", "2")
 
-Passing a third argument will cause the generated range to step by that
-interval, e.g.
+    Will return: [0,2,4,6,8]
 
-    range("0", "9", "2")
+    The Puppet Language support Integer and Float ranges by using the type system. Those are suitable for
+    iterating a given number of times. Also see the step() function in Puppet for skipping values.
 
-Will return: [0,2,4,6,8]
-    EOS
-  ) do |arguments|
+        Integer[0, 9].each |$x| { notice($x) } # notices 0, 1, 2, ... 9
+    DOC
+             ) do |arguments|
 
-    # We support more than one argument but at least one is mandatory ...
-    raise(Puppet::ParseError, "range(): Wrong number of " +
-      "arguments given (#{arguments.size} for 1)") if arguments.size < 1
+    raise(Puppet::ParseError, 'range(): Wrong number of arguments given (0 for 1)') if arguments.empty?
 
     if arguments.size > 1
       start = arguments[0]
       stop  = arguments[1]
       step  = arguments[2].nil? ? 1 : arguments[2].to_i.abs
 
-      type = '..' # We select simplest type for Range available in Ruby ...
+      type = '..' # Use the simplest type of Range available in Ruby
 
-    elsif arguments.size > 0
+    else # arguments.size == 1
       value = arguments[0]
 
-      if m = value.match(/^(\w+)(\.\.\.?|\-)(\w+)$/)
+      m = value.match(%r{^(\w+)(\.\.\.?|\-)(\w+)$})
+      if m
         start = m[1]
         stop  = m[3]
 
         type = m[2]
-
-      elsif value.match(/^.+$/)
-        raise(Puppet::ParseError, 'range(): Unable to compute range ' +
-          'from the value given')
+        step = 1
+      elsif value =~ %r{^.+$}
+        raise(Puppet::ParseError, "range(): Unable to compute range from the value: #{value}")
       else
-        raise(Puppet::ParseError, 'range(): Unknown format of range given')
+        raise(Puppet::ParseError, "range(): Unknown range format: #{value}")
       end
     end
 
-    # Check whether we have integer value if so then make it so ...
-    if start.to_s.match(/^\d+$/)
+    # If we were given an integer, ensure we work with one
+    if start.to_s =~ %r{^\d+$}
       start = start.to_i
       stop  = stop.to_i
     else
@@ -75,11 +76,11 @@ Will return: [0,2,4,6,8]
     end
 
     range = case type
-      when /^(\.\.|\-)$/ then (start .. stop)
-      when /^(\.\.\.)$/  then (start ... stop) # Exclusive of last element ...
-    end
+            when %r{^(..|-)$} then (start..stop)
+            when '...' then (start...stop) # Exclusive of last element
+            end
 
-    result = range.step(step).collect { |i| i } # Get them all ... Pokemon ...
+    result = range.step(step).to_a
 
     return result
   end