From e80207bede37e498c32bea6d56c46f1dd709721e Mon Sep 17 00:00:00 2001
From: Uwe Stuehler <ustuehler@team.mobile.de>
Date: Tue, 23 Oct 2012 16:43:03 +0200
Subject: Fix number of arguments check in flatten()

The function only uses the first argument, so raise an error with
too few arguments *and* with too many arguments.
---
 spec/unit/puppet/parser/functions/flatten_spec.rb | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'spec/unit/puppet')

diff --git a/spec/unit/puppet/parser/functions/flatten_spec.rb b/spec/unit/puppet/parser/functions/flatten_spec.rb
index d4dfd20..dba7a6b 100755
--- a/spec/unit/puppet/parser/functions/flatten_spec.rb
+++ b/spec/unit/puppet/parser/functions/flatten_spec.rb
@@ -11,6 +11,10 @@ describe "the flatten function" do
     lambda { scope.function_flatten([]) }.should( raise_error(Puppet::ParseError))
   end
 
+  it "should raise a ParseError if there is more than 1 argument" do
+    lambda { scope.function_flatten([[], []]) }.should( raise_error(Puppet::ParseError))
+  end
+
   it "should flatten a complex data structure" do
     result = scope.function_flatten([["a","b",["c",["d","e"],"f","g"]]])
     result.should(eq(["a","b","c","d","e","f","g"]))
-- 
cgit v1.2.3


From 5a11279cc54e7f9f5d168c75728f990d0bd0b694 Mon Sep 17 00:00:00 2001
From: Uwe Stuehler <ustuehler@team.mobile.de>
Date: Tue, 23 Oct 2012 16:43:03 +0200
Subject: Fix number of arguments check in flatten()

The function only uses the first argument, so raise an error with
too few arguments *and* with too many arguments.
---
 lib/puppet/parser/functions/flatten.rb            | 2 +-
 spec/unit/puppet/parser/functions/flatten_spec.rb | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

(limited to 'spec/unit/puppet')

diff --git a/lib/puppet/parser/functions/flatten.rb b/lib/puppet/parser/functions/flatten.rb
index 781da78..a1ed183 100644
--- a/lib/puppet/parser/functions/flatten.rb
+++ b/lib/puppet/parser/functions/flatten.rb
@@ -16,7 +16,7 @@ Would return: ['a','b','c']
   ) do |arguments|
 
     raise(Puppet::ParseError, "flatten(): Wrong number of arguments " +
-      "given (#{arguments.size} for 1)") if arguments.size < 1
+      "given (#{arguments.size} for 1)") if arguments.size != 1
 
     array = arguments[0]
 
diff --git a/spec/unit/puppet/parser/functions/flatten_spec.rb b/spec/unit/puppet/parser/functions/flatten_spec.rb
index d4dfd20..dba7a6b 100755
--- a/spec/unit/puppet/parser/functions/flatten_spec.rb
+++ b/spec/unit/puppet/parser/functions/flatten_spec.rb
@@ -11,6 +11,10 @@ describe "the flatten function" do
     lambda { scope.function_flatten([]) }.should( raise_error(Puppet::ParseError))
   end
 
+  it "should raise a ParseError if there is more than 1 argument" do
+    lambda { scope.function_flatten([[], []]) }.should( raise_error(Puppet::ParseError))
+  end
+
   it "should flatten a complex data structure" do
     result = scope.function_flatten([["a","b",["c",["d","e"],"f","g"]]])
     result.should(eq(["a","b","c","d","e","f","g"]))
-- 
cgit v1.2.3


From 5d5a4d466ed6530fa8b68162e96bdaaaf35066e1 Mon Sep 17 00:00:00 2001
From: Justin Lambert <jlambert@eml.cc>
Date: Mon, 17 Dec 2012 06:22:36 -0700
Subject: str2bool should return a boolean if called with a boolean

---
 lib/puppet/parser/functions/str2bool.rb            | 5 +++++
 spec/unit/puppet/parser/functions/str2bool_spec.rb | 7 +++++++
 2 files changed, 12 insertions(+)

(limited to 'spec/unit/puppet')

diff --git a/lib/puppet/parser/functions/str2bool.rb b/lib/puppet/parser/functions/str2bool.rb
index c320da6..9ea6dd5 100644
--- a/lib/puppet/parser/functions/str2bool.rb
+++ b/lib/puppet/parser/functions/str2bool.rb
@@ -14,6 +14,11 @@ like: 0, f, n, false, no to 'false'.
       "given (#{arguments.size} for 1)") if arguments.size < 1
 
     string = arguments[0]
+    
+    # If string is already Boolean, return it
+    if !!string == string
+      return string
+    end
 
     unless string.is_a?(String)
       raise(Puppet::ParseError, 'str2bool(): Requires either ' +
diff --git a/spec/unit/puppet/parser/functions/str2bool_spec.rb b/spec/unit/puppet/parser/functions/str2bool_spec.rb
index 2782bbe..ef6350f 100644
--- a/spec/unit/puppet/parser/functions/str2bool_spec.rb
+++ b/spec/unit/puppet/parser/functions/str2bool_spec.rb
@@ -21,4 +21,11 @@ describe "the str2bool function" do
     result = scope.function_str2bool(["undef"])
     result.should(eq(false))
   end
+  
+  it "should return the boolean it was called with" do
+    result = scope.function_str2bool([true])
+    result.should(eq(true))
+    result = scope.function_str2bool([false])
+    result.should(eq(false))
+  end
 end
-- 
cgit v1.2.3


From 961dcab15d3cf00eabeb5a496efc9da051169241 Mon Sep 17 00:00:00 2001
From: Eric Shamow <eric@puppetlabs.com>
Date: Tue, 3 Apr 2012 22:30:46 -0400
Subject: (#13610) Add is_function_available to stdlib

This function provides a simple wrapper around
Puppet::Parser::Functions.function for access within Puppet manifests.
This will allow users to check whether or not a plugin or functionality
such as hiera is installed on the server.
---
 .../parser/functions/is_function_available.rb      | 23 ++++++++++++++++
 .../parser/functions/is_function_available.rb      | 31 ++++++++++++++++++++++
 2 files changed, 54 insertions(+)
 create mode 100644 lib/puppet/parser/functions/is_function_available.rb
 create mode 100644 spec/unit/puppet/parser/functions/is_function_available.rb

(limited to 'spec/unit/puppet')

diff --git a/lib/puppet/parser/functions/is_function_available.rb b/lib/puppet/parser/functions/is_function_available.rb
new file mode 100644
index 0000000..6cbd35c
--- /dev/null
+++ b/lib/puppet/parser/functions/is_function_available.rb
@@ -0,0 +1,23 @@
+#
+# is_function_available.rb
+#
+
+module Puppet::Parser::Functions
+  newfunction(:is_function_available, :type => :rvalue, :doc => <<-EOS
+This function accepts a string as an argument, determines whether the
+Puppet runtime has access to a function by that name.  It returns a
+true if the function exists, false if not.
+    EOS
+  ) do |arguments|
+
+    if (arguments.size != 1) then
+      raise(Puppet::ParseError, "is_function_available?(): Wrong number of arguments "+
+        "given #{arguments.size} for 1")
+    end
+
+    function = Puppet::Parser::Functions.function(arguments[0].to_sym)
+    function.is_a?(String) and not function.empty?
+  end
+end
+
+# vim: set ts=2 sw=2 et :
diff --git a/spec/unit/puppet/parser/functions/is_function_available.rb b/spec/unit/puppet/parser/functions/is_function_available.rb
new file mode 100644
index 0000000..bd40c51
--- /dev/null
+++ b/spec/unit/puppet/parser/functions/is_function_available.rb
@@ -0,0 +1,31 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+describe "the is_function_available function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
+
+  before :each do
+    @scope = Puppet::Parser::Scope.new
+  end
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("is_function_available").should == "function_is_function_available"
+  end
+
+  it "should raise a ParseError if there is less than 1 arguments" do
+    lambda { @scope.function_is_function_available([]) }.should( raise_error(Puppet::ParseError))
+  end
+
+  it "should return false if a nonexistent function is passed" do
+    result = @scope.function_is_function_available(['jeff_mccunes_left_sock'])
+    result.should(eq(false))
+  end
+
+  it "should return true if an available function is passed" do
+    result = @scope.function_is_function_available(['require'])
+    result.should(eq(true))
+  end
+
+end
-- 
cgit v1.2.3


From 05273419e1c8b34115ede15b1d8a8739f6a0db00 Mon Sep 17 00:00:00 2001
From: Kristof Willaert <kristof.willaert@gmail.com>
Date: Tue, 19 Mar 2013 10:00:57 +0100
Subject: Add floor function implementation and unit tests

---
 README.markdown                                 | 14 +++++++++
 lib/puppet/parser/functions/floor.rb            | 20 +++++++++++++
 spec/unit/puppet/parser/functions/floor_spec.rb | 39 +++++++++++++++++++++++++
 3 files changed, 73 insertions(+)
 create mode 100644 lib/puppet/parser/functions/floor.rb
 create mode 100644 spec/unit/puppet/parser/functions/floor_spec.rb

(limited to 'spec/unit/puppet')

diff --git a/README.markdown b/README.markdown
index f1ac6b3..121b784 100644
--- a/README.markdown
+++ b/README.markdown
@@ -196,6 +196,20 @@ as a result.
 Would return: ['a','b','c']
 
 
+- *Type*: rvalue
+
+floor
+-----
+Returns the largest integer less or equal to the argument.
+Takes a single numeric value as an argument.
+
+*Examples:*
+
+    floor('3.8')
+
+Would return: '3'
+
+
 - *Type*: rvalue
 
 fqdn_rotate
diff --git a/lib/puppet/parser/functions/floor.rb b/lib/puppet/parser/functions/floor.rb
new file mode 100644
index 0000000..a401923
--- /dev/null
+++ b/lib/puppet/parser/functions/floor.rb
@@ -0,0 +1,20 @@
+module Puppet::Parser::Functions
+  newfunction(:floor, :type => :rvalue, :doc => <<-EOS
+    Returns the largest integer less or equal to the argument.
+    Takes a single numeric value as an argument.
+    EOS
+  ) do |arguments|
+
+    raise(Puppet::ParseError, "floor(): Wrong number of arguments " +
+          "given (#{arguments.size} for 1)") if arguments.size != 1
+
+    arg = arguments[0]
+
+    raise(Puppet::ParseError, "floor(): Wrong argument type " +
+          "given (#{arg.class} for Numeric)") if arg.is_a?(Numeric) == false
+
+    arg.floor
+  end
+end
+
+# vim: set ts=2 sw=2 et :
diff --git a/spec/unit/puppet/parser/functions/floor_spec.rb b/spec/unit/puppet/parser/functions/floor_spec.rb
new file mode 100644
index 0000000..dbc8c77
--- /dev/null
+++ b/spec/unit/puppet/parser/functions/floor_spec.rb
@@ -0,0 +1,39 @@
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe "the floor function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("floor").should == "function_floor"
+  end
+
+  it "should raise a ParseError if there is less than 1 argument" do
+    lambda { scope.function_floor([]) }.should( raise_error(Puppet::ParseError, /Wrong number of arguments/))
+  end
+
+  it "should should raise a ParseError if input isn't numeric (eg. String)" do
+    lambda { scope.function_floor(["foo"]) }.should( raise_error(Puppet::ParseError, /Wrong argument type/))
+  end
+
+  it "should should raise a ParseError if input isn't numeric (eg. Boolean)" do
+    lambda { scope.function_floor([true]) }.should( raise_error(Puppet::ParseError, /Wrong argument type/))
+  end
+
+  it "should return an integer when a numeric type is passed" do
+    result = scope.function_floor([12.4])
+    result.is_a?(Integer).should(eq(true))
+  end
+
+  it "should return the input when an integer is passed" do
+    result = scope.function_floor([7])
+    result.should(eq(7))
+  end
+
+  it "should return the largest integer less than or equal to the input" do
+    result = scope.function_floor([3.8])
+    result.should(eq(3))
+  end
+end
+
-- 
cgit v1.2.3


From 88a93ac6cdf38045e1cf29325a70e5e4143016b3 Mon Sep 17 00:00:00 2001
From: Richard Soderberg <rsoderberg@mozilla.com>
Date: Tue, 26 Mar 2013 15:45:40 -0700
Subject: add suffix function to accompany the prefix function

---
 README.markdown                                  | 13 +++++++
 lib/puppet/parser/functions/suffix.rb            | 45 ++++++++++++++++++++++++
 spec/unit/puppet/parser/functions/suffix_spec.rb | 19 ++++++++++
 3 files changed, 77 insertions(+)
 create mode 100644 lib/puppet/parser/functions/suffix.rb
 create mode 100644 spec/unit/puppet/parser/functions/suffix_spec.rb

(limited to 'spec/unit/puppet')

diff --git a/README.markdown b/README.markdown
index 121b784..2f93db4 100644
--- a/README.markdown
+++ b/README.markdown
@@ -659,6 +659,19 @@ every string inside an array.
 Would result in: "aaa"
 
 
+- *Type*: rvalue
+
+suffix
+------
+This function applies a suffix to all elements in an array.
+
+*Examples:*
+
+    suffix(['a','b','c'], 'p')
+
+Will return: ['ap','bp','cp']
+
+
 - *Type*: rvalue
 
 swapcase
diff --git a/lib/puppet/parser/functions/suffix.rb b/lib/puppet/parser/functions/suffix.rb
new file mode 100644
index 0000000..5018280
--- /dev/null
+++ b/lib/puppet/parser/functions/suffix.rb
@@ -0,0 +1,45 @@
+#
+# suffix.rb
+#
+
+module Puppet::Parser::Functions
+  newfunction(:suffix, :type => :rvalue, :doc => <<-EOS
+This function applies a suffix to all elements in an array.
+
+*Examples:*
+
+    suffix(['a','b','c'], 'p')
+
+Will return: ['ap','bp','cp']
+    EOS
+  ) do |arguments|
+
+    # Technically we support two arguments but only first is mandatory ...
+    raise(Puppet::ParseError, "suffix(): Wrong number of arguments " +
+      "given (#{arguments.size} for 1)") if arguments.size < 1
+
+    array = arguments[0]
+
+    unless array.is_a?(Array)
+      raise(Puppet::ParseError, 'suffix(): Requires array to work with')
+    end
+
+    suffix = arguments[1] if arguments[1]
+
+    if suffix
+      unless suffix.is_a?(String)
+        raise(Puppet::ParseError, 'suffix(): Requires string to work with')
+      end
+    end
+
+    # Turn everything into string same as join would do ...
+    result = array.collect do |i|
+      i = i.to_s
+      suffix ? i + suffix : i
+    end
+
+    return result
+  end
+end
+
+# vim: set ts=2 sw=2 et :
diff --git a/spec/unit/puppet/parser/functions/suffix_spec.rb b/spec/unit/puppet/parser/functions/suffix_spec.rb
new file mode 100644
index 0000000..c28f719
--- /dev/null
+++ b/spec/unit/puppet/parser/functions/suffix_spec.rb
@@ -0,0 +1,19 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the suffix function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("suffix").should == "function_suffix"
+  end
+
+  it "should raise a ParseError if there is less than 1 arguments" do
+    lambda { scope.function_suffix([]) }.should( raise_error(Puppet::ParseError))
+  end
+
+  it "should return a suffixed array" do
+    result = scope.function_suffix([['a','b','c'], 'p'])
+    result.should(eq(['ap','bp','cp']))
+  end
+end
-- 
cgit v1.2.3


From ff5dd5d75adb3723e106ca20bac4e68466395a56 Mon Sep 17 00:00:00 2001
From: Erik Dalén <dalen@spotify.com>
Date: Wed, 20 Mar 2013 16:36:20 +0100
Subject: Allow comparisons of Numeric and number as String

Puppet passes numbers as String to functions, but it makes more sense to
compare them as Numeric.
But sometimes Puppet passes them as the wrong type, see:
https://projects.puppetlabs.com/issues/19812
---
 lib/puppet/parser/functions/max.rb            | 10 +++++++++-
 lib/puppet/parser/functions/min.rb            | 10 +++++++++-
 spec/unit/puppet/parser/functions/max_spec.rb |  4 ++++
 spec/unit/puppet/parser/functions/min_spec.rb |  4 ++++
 4 files changed, 26 insertions(+), 2 deletions(-)

(limited to 'spec/unit/puppet')

diff --git a/lib/puppet/parser/functions/max.rb b/lib/puppet/parser/functions/max.rb
index 10b6f74..60fb94a 100644
--- a/lib/puppet/parser/functions/max.rb
+++ b/lib/puppet/parser/functions/max.rb
@@ -8,6 +8,14 @@ module Puppet::Parser::Functions
     raise(Puppet::ParseError, "max(): Wrong number of arguments " +
           "need at least one") if args.size == 0
 
-    return args.max
+    # Sometimes we get numbers as numerics and sometimes as strings.
+    # We try to compare them as numbers when possible
+    return args.max do |a,b|
+      if a.to_s =~ /\A-?\d+(.\d+)?\z/ and b.to_s =~ /\A-?\d+(.\d+)?\z/ then
+        a.to_f <=> b.to_f
+      else
+        a.to_s <=> b.to_s
+      end
+    end
   end
 end
diff --git a/lib/puppet/parser/functions/min.rb b/lib/puppet/parser/functions/min.rb
index abf1b62..6bd6ebf 100644
--- a/lib/puppet/parser/functions/min.rb
+++ b/lib/puppet/parser/functions/min.rb
@@ -8,6 +8,14 @@ module Puppet::Parser::Functions
     raise(Puppet::ParseError, "min(): Wrong number of arguments " +
           "need at least one") if args.size == 0
 
-    return args.min
+    # Sometimes we get numbers as numerics and sometimes as strings.
+    # We try to compare them as numbers when possible
+    return args.min do |a,b|
+      if a.to_s =~ /\A^-?\d+(.\d+)?\z/ and b.to_s =~ /\A-?\d+(.\d+)?\z/ then
+        a.to_f <=> b.to_f
+      else
+        a.to_s <=> b.to_s
+      end
+    end
   end
 end
diff --git a/spec/unit/puppet/parser/functions/max_spec.rb b/spec/unit/puppet/parser/functions/max_spec.rb
index 604927e..ff6f2b3 100755
--- a/spec/unit/puppet/parser/functions/max_spec.rb
+++ b/spec/unit/puppet/parser/functions/max_spec.rb
@@ -20,4 +20,8 @@ describe "the max function" do
   it "should be able to compare numbers" do
     scope.function_max([6,8,4]).should(eq(8))
   end
+
+  it "should be able to compare a number with a stringified number" do
+    scope.function_max([1,"2"]).should(eq("2"))
+  end
 end
diff --git a/spec/unit/puppet/parser/functions/min_spec.rb b/spec/unit/puppet/parser/functions/min_spec.rb
index 781422c..71d593e 100755
--- a/spec/unit/puppet/parser/functions/min_spec.rb
+++ b/spec/unit/puppet/parser/functions/min_spec.rb
@@ -20,4 +20,8 @@ describe "the min function" do
   it "should be able to compare numbers" do
     scope.function_min([6,8,4]).should(eq(4))
   end
+
+  it "should be able to compare a number with a stringified number" do
+    scope.function_min([1,"2"]).should(eq(1))
+  end
 end
-- 
cgit v1.2.3


From e6916f83fd35989db4b86dfb10716c9198994389 Mon Sep 17 00:00:00 2001
From: Steve Huff <shuff@vecna.org>
Date: Fri, 29 Mar 2013 10:04:05 -0400
Subject: Enable num2bool to accept numeric input

Also ignore rspec fixtures directory
---
 .gitignore                                         |  1 +
 lib/puppet/parser/functions/num2bool.rb            |  3 ++-
 spec/unit/puppet/parser/functions/num2bool_spec.rb | 24 ++++++++++++++++++++--
 3 files changed, 25 insertions(+), 3 deletions(-)

(limited to 'spec/unit/puppet')

diff --git a/.gitignore b/.gitignore
index 416889c..2e3ca63 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,7 @@ pkg/
 .DS_Store
 metadata.json
 coverage/
+spec/fixtures/
 Gemfile.lock
 .bundle/
 vendor/bundle/
diff --git a/lib/puppet/parser/functions/num2bool.rb b/lib/puppet/parser/functions/num2bool.rb
index 874db22..638f693 100644
--- a/lib/puppet/parser/functions/num2bool.rb
+++ b/lib/puppet/parser/functions/num2bool.rb
@@ -14,7 +14,8 @@ higher then 0 become true.
     raise(Puppet::ParseError, "num2bool(): Wrong number of arguments " +
       "given (#{arguments.size} for 1)") if arguments.size < 1
 
-    number = arguments[0]
+    # Since we're matching against a regex, coerce to String
+    number = arguments[0].to_s
 
     # Only numbers allowed ...
     unless number.match(/^\-?\d+$/)
diff --git a/spec/unit/puppet/parser/functions/num2bool_spec.rb b/spec/unit/puppet/parser/functions/num2bool_spec.rb
index 640c689..e51ee45 100644
--- a/spec/unit/puppet/parser/functions/num2bool_spec.rb
+++ b/spec/unit/puppet/parser/functions/num2bool_spec.rb
@@ -12,13 +12,33 @@ describe "the num2bool function" do
     lambda { scope.function_num2bool([]) }.should( raise_error(Puppet::ParseError))
   end
 
-  it "should return true if 1" do
+  it "should return true if passed string 1" do
     result = scope.function_num2bool(["1"])
     result.should(be_true)
   end
 
-  it "should return false if 0" do
+  it "should return true if passed number 1" do
+    result = scope.function_num2bool([1])
+    result.should(be_true)
+  end
+
+  it "should return false if passed string 0" do
     result = scope.function_num2bool(["0"])
     result.should(be_false)
   end
+
+  it "should return false if passed number 0" do
+    result = scope.function_num2bool([0])
+    result.should(be_false)
+  end
+
+  it "should return false if passed string -1" do
+    result = scope.function_num2bool(["-1"])
+    result.should(be_false)
+  end
+
+  it "should return false if passed number -1" do
+    result = scope.function_num2bool([-1])
+    result.should(be_false)
+  end
 end
-- 
cgit v1.2.3


From 4a5218a8af8c3ffaf9ea2348a3900b19d6a95416 Mon Sep 17 00:00:00 2001
From: Steve Huff <shuff@vecna.org>
Date: Fri, 29 Mar 2013 12:03:33 -0400
Subject: Reworked number-handling logic

No more coercing to String and regex matching.  Instead, we now coerce
to Integer at the beginning or raise an error if we cannot coerce to
Integer.

A consequence of this change is that the function will now accept
blatantly non-numeric strings as input, and return false.  This seems a
bit goofy to me, but it's how String#to_i works.  If we really don't
like this, then I'm open to suggestions.
---
 lib/puppet/parser/functions/num2bool.rb            | 35 +++++++---------------
 spec/unit/puppet/parser/functions/num2bool_spec.rb | 11 ++++++-
 2 files changed, 21 insertions(+), 25 deletions(-)

(limited to 'spec/unit/puppet')

diff --git a/lib/puppet/parser/functions/num2bool.rb b/lib/puppet/parser/functions/num2bool.rb
index 638f693..15dd560 100644
--- a/lib/puppet/parser/functions/num2bool.rb
+++ b/lib/puppet/parser/functions/num2bool.rb
@@ -2,39 +2,26 @@
 # num2bool.rb
 #
 
-# TODO(Krzysztof Wilczynski): We probably need to approach numeric values differently ...
-
 module Puppet::Parser::Functions
   newfunction(:num2bool, :type => :rvalue, :doc => <<-EOS
-This function converts a number into a true boolean. Zero becomes false. Numbers
-higher then 0 become true.
+This function converts a number or a string representation of a number into a
+true boolean. Zero or anything non-numeric becomes false. Numbers higher then 0
+become true.
     EOS
   ) do |arguments|
 
     raise(Puppet::ParseError, "num2bool(): Wrong number of arguments " +
-      "given (#{arguments.size} for 1)") if arguments.size < 1
-
-    # Since we're matching against a regex, coerce to String
-    number = arguments[0].to_s
-
-    # Only numbers allowed ...
-    unless number.match(/^\-?\d+$/)
-      raise(Puppet::ParseError, 'num2bool(): Requires integer to work with')
-    end
+      "given (#{arguments.size} for 1)") if arguments.size != 1
 
-    result = case number
-      when /^0$/
-        false
-      when /^\-?\d+$/
-        # Numbers in Puppet are often string-encoded which is troublesome ...
-        number = number.to_i
-        # We yield true for any positive number and false otherwise ...
-        number > 0 ? true : false
-      else
-        raise(Puppet::ParseError, 'num2bool(): Unknown numeric format given')
+    # we need to get an Integer out of this
+    begin
+      number = arguments[0].to_i
+    rescue NoMethodError
+      raise(Puppet::ParseError, 'num2bool(): Unable to parse number: ' + $!)
     end
 
-    return result
+    # Return true for any positive number and false otherwise
+    return number > 0 ? true : false
   end
 end
 
diff --git a/spec/unit/puppet/parser/functions/num2bool_spec.rb b/spec/unit/puppet/parser/functions/num2bool_spec.rb
index e51ee45..5ce981e 100644
--- a/spec/unit/puppet/parser/functions/num2bool_spec.rb
+++ b/spec/unit/puppet/parser/functions/num2bool_spec.rb
@@ -8,10 +8,14 @@ describe "the num2bool function" do
     Puppet::Parser::Functions.function("num2bool").should == "function_num2bool"
   end
 
-  it "should raise a ParseError if there is less than 1 arguments" do
+  it "should raise a ParseError if there are no arguments" do
     lambda { scope.function_num2bool([]) }.should( raise_error(Puppet::ParseError))
   end
 
+  it "should raise a ParseError if there are more than 1 arguments" do
+    lambda { scope.function_num2bool(["foo","bar"]) }.should( raise_error(Puppet::ParseError))
+  end
+
   it "should return true if passed string 1" do
     result = scope.function_num2bool(["1"])
     result.should(be_true)
@@ -41,4 +45,9 @@ describe "the num2bool function" do
     result = scope.function_num2bool([-1])
     result.should(be_false)
   end
+
+  it "should return false if passed something non-numeric" do
+    result = scope.function_num2bool(["xyzzy"])
+    result.should(be_false)
+  end
 end
-- 
cgit v1.2.3


From 8d217f0012fef332642faf485ad187773a95bcc1 Mon Sep 17 00:00:00 2001
From: Steve Huff <shuff@vecna.org>
Date: Fri, 29 Mar 2013 15:06:36 -0400
Subject: (19864) num2bool match fix

This is a bit more heavy-handed than I might like, but it does appear to
do the right things:

* accepts numeric input appropriately, truncating floats
* matches string input against a regex, then coerces number-looking
  strings to int
* makes a best effort to coerce anything else to a string, then subjects
  it to the same treatment
* raises an error in the event of incorrect number of arguments or
  non-number-looking strings

I've also included some additional unit tests.
---
 lib/puppet/parser/functions/num2bool.rb            | 29 ++++++++++++++----
 spec/unit/puppet/parser/functions/num2bool_spec.rb | 34 ++++++++++++++++++++--
 2 files changed, 56 insertions(+), 7 deletions(-)

(limited to 'spec/unit/puppet')

diff --git a/lib/puppet/parser/functions/num2bool.rb b/lib/puppet/parser/functions/num2bool.rb
index 15dd560..cf98f80 100644
--- a/lib/puppet/parser/functions/num2bool.rb
+++ b/lib/puppet/parser/functions/num2bool.rb
@@ -13,13 +13,32 @@ become true.
     raise(Puppet::ParseError, "num2bool(): Wrong number of arguments " +
       "given (#{arguments.size} for 1)") if arguments.size != 1
 
-    # we need to get an Integer out of this
-    begin
-      number = arguments[0].to_i
-    rescue NoMethodError
-      raise(Puppet::ParseError, 'num2bool(): Unable to parse number: ' + $!)
+    number = arguments[0]
+
+    case number
+    when Numeric
+      # Yay, it's a number
+    when String
+      # Deal with strings later
+    else
+      begin
+        number = number.to_s
+      rescue NoMethodError
+        raise(Puppet::ParseError, 'num2bool(): Unable to parse argument: ' + $!)
+      end
+    end
+
+    case number
+    when String
+      # Only accept strings that look somewhat like numbers
+      unless number =~ /^-?\d+/
+        raise(Puppet::ParseError, "num2bool(): '#{number}' does not look like a number")
+      end
     end
 
+    # Truncate floats
+    number = number.to_i
+
     # Return true for any positive number and false otherwise
     return number > 0 ? true : false
   end
diff --git a/spec/unit/puppet/parser/functions/num2bool_spec.rb b/spec/unit/puppet/parser/functions/num2bool_spec.rb
index 5ce981e..038881f 100644
--- a/spec/unit/puppet/parser/functions/num2bool_spec.rb
+++ b/spec/unit/puppet/parser/functions/num2bool_spec.rb
@@ -16,6 +16,10 @@ describe "the num2bool function" do
     lambda { scope.function_num2bool(["foo","bar"]) }.should( raise_error(Puppet::ParseError))
   end
 
+  it "should raise a ParseError if passed something non-numeric" do
+    lambda { scope.function_num2bool(["xyzzy"]) }.should( raise_error(Puppet::ParseError))
+  end
+
   it "should return true if passed string 1" do
     result = scope.function_num2bool(["1"])
     result.should(be_true)
@@ -26,6 +30,16 @@ describe "the num2bool function" do
     result.should(be_true)
   end
 
+  it "should return true if passed array with string 1" do
+    result = scope.function_num2bool([["1"]])
+    result.should(be_true)
+  end
+
+  it "should return true if passed array with number 1" do
+    result = scope.function_num2bool([[1]])
+    result.should(be_true)
+  end
+
   it "should return false if passed string 0" do
     result = scope.function_num2bool(["0"])
     result.should(be_false)
@@ -36,6 +50,16 @@ describe "the num2bool function" do
     result.should(be_false)
   end
 
+  it "should return false if passed array with string 0" do
+    result = scope.function_num2bool([["0"]])
+    result.should(be_false)
+  end
+
+  it "should return false if passed array with number 0" do
+    result = scope.function_num2bool([[0]])
+    result.should(be_false)
+  end
+
   it "should return false if passed string -1" do
     result = scope.function_num2bool(["-1"])
     result.should(be_false)
@@ -46,8 +70,14 @@ describe "the num2bool function" do
     result.should(be_false)
   end
 
-  it "should return false if passed something non-numeric" do
-    result = scope.function_num2bool(["xyzzy"])
+  it "should return false if passed array with string -1" do
+    result = scope.function_num2bool([["-1"]])
     result.should(be_false)
   end
+
+  it "should return false if passed array with number -1" do
+    result = scope.function_num2bool([[-1]])
+    result.should(be_false)
+  end
+
 end
-- 
cgit v1.2.3


From c372f177708df4c844337e9901646b7b84b86cd8 Mon Sep 17 00:00:00 2001
From: Steve Huff <shuff@vecna.org>
Date: Mon, 1 Apr 2013 11:44:09 -0400
Subject: Cleanup per adrianthebo suggestions

* use Float() to process string arguments
* get rid of doubly nested arrays
* removing needless ternary operator
* improving error message handling
---
 lib/puppet/parser/functions/num2bool.rb            | 22 ++++++-------
 spec/unit/puppet/parser/functions/num2bool_spec.rb | 36 ++++++----------------
 2 files changed, 19 insertions(+), 39 deletions(-)

(limited to 'spec/unit/puppet')

diff --git a/lib/puppet/parser/functions/num2bool.rb b/lib/puppet/parser/functions/num2bool.rb
index cf98f80..af0e6ed 100644
--- a/lib/puppet/parser/functions/num2bool.rb
+++ b/lib/puppet/parser/functions/num2bool.rb
@@ -19,28 +19,24 @@ become true.
     when Numeric
       # Yay, it's a number
     when String
-      # Deal with strings later
+      begin
+        number = Float(number)
+      rescue ArgumentError => ex
+        raise(Puppet::ParseError, "num2bool(): '#{number}' does not look like a number: #{ex.message}")
+      end
     else
       begin
         number = number.to_s
-      rescue NoMethodError
-        raise(Puppet::ParseError, 'num2bool(): Unable to parse argument: ' + $!)
-      end
-    end
-
-    case number
-    when String
-      # Only accept strings that look somewhat like numbers
-      unless number =~ /^-?\d+/
-        raise(Puppet::ParseError, "num2bool(): '#{number}' does not look like a number")
+      rescue NoMethodError => ex
+        raise(Puppet::ParseError, "num2bool(): Unable to parse argument: #{ex.message}")
       end
     end
 
-    # Truncate floats
+    # Truncate Floats
     number = number.to_i
 
     # Return true for any positive number and false otherwise
-    return number > 0 ? true : false
+    return number > 0
   end
 end
 
diff --git a/spec/unit/puppet/parser/functions/num2bool_spec.rb b/spec/unit/puppet/parser/functions/num2bool_spec.rb
index 038881f..b56196d 100644
--- a/spec/unit/puppet/parser/functions/num2bool_spec.rb
+++ b/spec/unit/puppet/parser/functions/num2bool_spec.rb
@@ -25,18 +25,13 @@ describe "the num2bool function" do
     result.should(be_true)
   end
 
-  it "should return true if passed number 1" do
-    result = scope.function_num2bool([1])
-    result.should(be_true)
-  end
-
-  it "should return true if passed array with string 1" do
-    result = scope.function_num2bool([["1"]])
+  it "should return true if passed string 1.5" do
+    result = scope.function_num2bool(["1.5"])
     result.should(be_true)
   end
 
-  it "should return true if passed array with number 1" do
-    result = scope.function_num2bool([[1]])
+  it "should return true if passed number 1" do
+    result = scope.function_num2bool([1])
     result.should(be_true)
   end
 
@@ -50,34 +45,23 @@ describe "the num2bool function" do
     result.should(be_false)
   end
 
-  it "should return false if passed array with string 0" do
-    result = scope.function_num2bool([["0"]])
-    result.should(be_false)
-  end
-
-  it "should return false if passed array with number 0" do
-    result = scope.function_num2bool([[0]])
-    result.should(be_false)
-  end
-
   it "should return false if passed string -1" do
     result = scope.function_num2bool(["-1"])
     result.should(be_false)
   end
 
-  it "should return false if passed number -1" do
-    result = scope.function_num2bool([-1])
+  it "should return false if passed string -1.5" do
+    result = scope.function_num2bool(["-1.5"])
     result.should(be_false)
   end
 
-  it "should return false if passed array with string -1" do
-    result = scope.function_num2bool([["-1"]])
+  it "should return false if passed number -1" do
+    result = scope.function_num2bool([-1])
     result.should(be_false)
   end
 
-  it "should return false if passed array with number -1" do
-    result = scope.function_num2bool([[-1]])
+  it "should return false if passed float -1.5" do
+    result = scope.function_num2bool([-1.5])
     result.should(be_false)
   end
-
 end
-- 
cgit v1.2.3


From 7a2fb80834d3ec4d21efe58e5e8af188e5bdd07c Mon Sep 17 00:00:00 2001
From: Amos Shapira <ashapira@atlassian.com>
Date: Sun, 31 Mar 2013 23:37:30 +1100
Subject: (#19998) Implement any2array

This change is to implement a new function "any2array", which will take any
argument or arguments and create an array which contains it. If the argument
is a single array then it will be returned as-is. If the argument is a single
hash then it will be converted into an array. Otherwise (if there are more than
one argument, or the only argument is not an array or a hash) the function will
return an array containing all the arguments.
---
 lib/puppet/parser/functions/any2array.rb           | 35 ++++++++++++++
 .../unit/puppet/parser/functions/any2array_spec.rb | 55 ++++++++++++++++++++++
 2 files changed, 90 insertions(+)
 create mode 100644 lib/puppet/parser/functions/any2array.rb
 create mode 100644 spec/unit/puppet/parser/functions/any2array_spec.rb

(limited to 'spec/unit/puppet')

diff --git a/lib/puppet/parser/functions/any2array.rb b/lib/puppet/parser/functions/any2array.rb
new file mode 100644
index 0000000..d150743
--- /dev/null
+++ b/lib/puppet/parser/functions/any2array.rb
@@ -0,0 +1,35 @@
+#
+# str2bool.rb
+#
+
+module Puppet::Parser::Functions
+  newfunction(:any2array, :type => :rvalue, :doc => <<-EOS
+This converts any object to an array containing that object. Empty argument
+lists are converted to an empty array. Arrays are left untouched. Hashes are
+converted to arrays of alternating keys and values.
+    EOS
+  ) do |arguments|
+
+    if arguments.empty?
+        return []
+    end
+
+    if arguments.length == 1
+        if arguments[0].kind_of?(Array)
+            return arguments[0]
+        elsif arguments[0].kind_of?(Hash)
+            result = []
+            arguments[0].each do |key, value|
+                result << key << value
+            end
+            return result
+        else
+            return [arguments[0]]
+        end
+    end
+
+    return arguments
+  end
+end
+
+# vim: set ts=2 sw=2 et :
diff --git a/spec/unit/puppet/parser/functions/any2array_spec.rb b/spec/unit/puppet/parser/functions/any2array_spec.rb
new file mode 100644
index 0000000..b266e84
--- /dev/null
+++ b/spec/unit/puppet/parser/functions/any2array_spec.rb
@@ -0,0 +1,55 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the any2array function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("any2array").should == "function_any2array"
+  end
+
+  it "should return an empty array if there is less than 1 argument" do
+    result = scope.function_any2array([])
+    result.should(eq([]))
+  end
+
+  it "should convert boolean true to [ true ] " do
+    result = scope.function_any2array([true])
+    result.should(eq([true]))
+  end
+
+  it "should convert one object to [object]" do
+    result = scope.function_any2array(['one'])
+    result.should(eq(['one']))
+  end
+
+  it "should convert multiple objects to [objects]" do
+    result = scope.function_any2array(['one', 'two'])
+    result.should(eq(['one', 'two']))
+  end
+
+  it "should return empty array it was called with" do
+    result = scope.function_any2array([[]])
+    result.should(eq([]))
+  end
+
+  it "should return one-member array it was called with" do
+    result = scope.function_any2array([['string']])
+    result.should(eq(['string']))
+  end
+
+  it "should return multi-member array it was called with" do
+    result = scope.function_any2array([['one', 'two']])
+    result.should(eq(['one', 'two']))
+  end
+
+  it "should return members of a hash it was called with" do
+    result = scope.function_any2array([{ 'key' => 'value' }])
+    result.should(eq(['key', 'value']))
+  end
+
+  it "should return an empty array if it was called with an empty hash" do
+    result = scope.function_any2array([{ }])
+    result.should(eq([]))
+  end
+end
-- 
cgit v1.2.3


From f28550e78996f908b076cdc9aebcbe584c777cd0 Mon Sep 17 00:00:00 2001
From: Erik Dalén <dalen@spotify.com>
Date: Wed, 10 Apr 2013 14:38:14 +0200
Subject: Add a count function

Similar to the ruby count method on arrays.
---
 lib/puppet/parser/functions/count.rb            | 22 ++++++++++++++++++++
 spec/unit/puppet/parser/functions/count_spec.rb | 27 +++++++++++++++++++++++++
 2 files changed, 49 insertions(+)
 create mode 100644 lib/puppet/parser/functions/count.rb
 create mode 100644 spec/unit/puppet/parser/functions/count_spec.rb

(limited to 'spec/unit/puppet')

diff --git a/lib/puppet/parser/functions/count.rb b/lib/puppet/parser/functions/count.rb
new file mode 100644
index 0000000..52de1b8
--- /dev/null
+++ b/lib/puppet/parser/functions/count.rb
@@ -0,0 +1,22 @@
+module Puppet::Parser::Functions
+  newfunction(:count, :type => :rvalue, :arity => -2, :doc => <<-EOS
+Takes an array as first argument and an optional second argument.
+Count the number of elements in array that matches second argument.
+If called with only an array it counts the number of elements that are not nil/undef.
+    EOS
+  ) do |args|
+
+    if (args.size > 2) then
+      raise(ArgumentError, "count(): Wrong number of arguments "+
+        "given #{args.size} for 1 or 2.")
+    end
+
+    collection, item = args
+
+    if item then
+      collection.count item
+    else
+      collection.count { |obj| obj != nil && obj != :undef && obj != '' }
+    end
+  end
+end
diff --git a/spec/unit/puppet/parser/functions/count_spec.rb b/spec/unit/puppet/parser/functions/count_spec.rb
new file mode 100644
index 0000000..5e4a8b9
--- /dev/null
+++ b/spec/unit/puppet/parser/functions/count_spec.rb
@@ -0,0 +1,27 @@
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe "the count function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("count").should == "function_count"
+  end
+
+  it "should raise a ArgumentError if there is more than 2 arguments" do
+    lambda { scope.function_count(['foo', 'bar', 'baz']) }.should( raise_error(ArgumentError))
+  end
+
+  it "should be able to count arrays" do
+    scope.function_count([["1","2","3"]]).should(eq(3))
+  end
+
+  it "should be able to count matching elements in arrays" do
+    scope.function_count([["1", "2", "2"], "2"]).should(eq(2))
+  end
+
+  it "should not count :undef, nil or empty strings" do
+    scope.function_count([["foo","bar",:undef,nil,""]]).should(eq(2))
+  end
+end
-- 
cgit v1.2.3


From 435226abfdf001bf2475be56d77027c638e93b70 Mon Sep 17 00:00:00 2001
From: Jeff McCune <jeff@puppetlabs.com>
Date: Wed, 10 Apr 2013 14:33:08 -0700
Subject: (maint) Add the behavior for count() with arrays and hashes

Without this patch the expected behavior of the count() function when
dealing with an out of bound array index and with a hash key that does
not exist is implicitly encoded in the spec examples.  This is a problem
because the expected behavior is not clear for something similar to the
following example:

    node default {
      $ary = [ 1, 2, 3 ]
      $ary_undef = $ary[100]
      $hsh = { 'one' => 1 }
      $hsh_undef = $hsh['dne']
      $count = count(['hi', $ary_undef, $hsh_undef])
      notice "Count is ${count}"
    }

This patch addresses the problem by making the expected behavior
explicit in the examples.
---
 spec/unit/puppet/parser/functions/count_spec.rb | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'spec/unit/puppet')

diff --git a/spec/unit/puppet/parser/functions/count_spec.rb b/spec/unit/puppet/parser/functions/count_spec.rb
index 5e4a8b9..2453815 100644
--- a/spec/unit/puppet/parser/functions/count_spec.rb
+++ b/spec/unit/puppet/parser/functions/count_spec.rb
@@ -21,7 +21,11 @@ describe "the count function" do
     scope.function_count([["1", "2", "2"], "2"]).should(eq(2))
   end
 
-  it "should not count :undef, nil or empty strings" do
-    scope.function_count([["foo","bar",:undef,nil,""]]).should(eq(2))
+  it "should not count nil or empty strings" do
+    scope.function_count([["foo","bar",nil,""]]).should(eq(2))
+  end
+
+  it 'does not count an undefined hash key or an out of bound array index (which are both :undef)' do
+    expect(scope.function_count([["foo",:undef,:undef]])).to eq(1)
   end
 end
-- 
cgit v1.2.3