From 9fa70ae43f14a9b13343ae67ab8d1520f43ebb4d Mon Sep 17 00:00:00 2001
From: Martin Hellmich <mhellmic@cern.ch>
Date: Mon, 18 Feb 2013 16:02:15 +0100
Subject: changed .count to .size to support legacy ruby

---
 lib/puppet/provider/file_line/ruby.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'lib/puppet')

diff --git a/lib/puppet/provider/file_line/ruby.rb b/lib/puppet/provider/file_line/ruby.rb
index e21eaa8..a3219d3 100644
--- a/lib/puppet/provider/file_line/ruby.rb
+++ b/lib/puppet/provider/file_line/ruby.rb
@@ -34,7 +34,7 @@ Puppet::Type.type(:file_line).provide(:ruby) do
 
   def handle_create_with_match()
     regex = resource[:match] ? Regexp.new(resource[:match]) : nil
-    match_count = lines.select { |l| regex.match(l) }.count
+    match_count = lines.select { |l| regex.match(l) }.size
     if match_count > 1
       raise Puppet::Error, "More than one line in file '#{resource[:path]}' matches pattern '#{resource[:match]}'"
     end
-- 
cgit v1.2.3


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.
---
 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 'lib/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 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 'lib/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 'lib/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 'lib/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 'lib/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 'lib/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 a83318d3ee41683118a55a2b15769c97efbcf6d9 Mon Sep 17 00:00:00 2001
From: Richard Soderberg <rsoderberg@mozilla.com>
Date: Tue, 26 Mar 2013 15:49:09 -0700
Subject: prefix: fix doc typo Examles -> Examples

---
 README.markdown                       | 2 +-
 lib/puppet/parser/functions/prefix.rb | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'lib/puppet')

diff --git a/README.markdown b/README.markdown
index 2f93db4..336d0ab 100644
--- a/README.markdown
+++ b/README.markdown
@@ -479,7 +479,7 @@ prefix
 ------
 This function applies a prefix to all elements in an array.
 
-*Examles:*
+*Examples:*
 
     prefix(['a','b','c'], 'p')
 
diff --git a/lib/puppet/parser/functions/prefix.rb b/lib/puppet/parser/functions/prefix.rb
index 4593976..243cf18 100644
--- a/lib/puppet/parser/functions/prefix.rb
+++ b/lib/puppet/parser/functions/prefix.rb
@@ -6,7 +6,7 @@ module Puppet::Parser::Functions
   newfunction(:prefix, :type => :rvalue, :doc => <<-EOS
 This function applies a prefix to all elements in an array.
 
-*Examles:*
+*Examples:*
 
     prefix(['a','b','c'], 'p')
 
-- 
cgit v1.2.3


From 29402f31e73a426dcc449216010834884d0251ec Mon Sep 17 00:00:00 2001
From: Adrien Thebo <git@somethingsinistral.net>
Date: Wed, 27 Mar 2013 13:37:25 -0700
Subject: (maint) better error reporting for prefix and suffix

When prefix and suffix did error checking with positional arguments,
they would not report the position of the argument that failed to
validate. This commit changes the messages to indicate which argument
failed.
---
 lib/puppet/parser/functions/prefix.rb | 4 ++--
 lib/puppet/parser/functions/suffix.rb | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'lib/puppet')

diff --git a/lib/puppet/parser/functions/prefix.rb b/lib/puppet/parser/functions/prefix.rb
index 243cf18..62211ae 100644
--- a/lib/puppet/parser/functions/prefix.rb
+++ b/lib/puppet/parser/functions/prefix.rb
@@ -21,14 +21,14 @@ Will return: ['pa','pb','pc']
     array = arguments[0]
 
     unless array.is_a?(Array)
-      raise(Puppet::ParseError, 'prefix(): Requires array to work with')
+      raise Puppet::ParseError, "prefix(): expected first argument to be an Array, got #{array.inspect}"
     end
 
     prefix = arguments[1] if arguments[1]
 
     if prefix
       unless prefix.is_a?(String)
-        raise(Puppet::ParseError, 'prefix(): Requires string to work with')
+        raise Puppet::ParseError, "prefix(): expected second argument to be a String, got #{suffix.inspect}"
       end
     end
 
diff --git a/lib/puppet/parser/functions/suffix.rb b/lib/puppet/parser/functions/suffix.rb
index 5018280..f7792d6 100644
--- a/lib/puppet/parser/functions/suffix.rb
+++ b/lib/puppet/parser/functions/suffix.rb
@@ -21,14 +21,14 @@ Will return: ['ap','bp','cp']
     array = arguments[0]
 
     unless array.is_a?(Array)
-      raise(Puppet::ParseError, 'suffix(): Requires array to work with')
+      raise Puppet::ParseError, "suffix(): expected first argument to be an Array, got #{array.inspect}"
     end
 
     suffix = arguments[1] if arguments[1]
 
     if suffix
-      unless suffix.is_a?(String)
-        raise(Puppet::ParseError, 'suffix(): Requires string to work with')
+      unless suffix.is_a? String
+        raise Puppet::ParseError, "suffix(): expected second argument to be a String, got #{suffix.inspect}"
       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 'lib/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 'lib/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 'lib/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 'lib/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 'lib/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 'lib/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 003cde074c86f034d2730eeb40d676d4e35c6022 Mon Sep 17 00:00:00 2001
From: Amos Shapira <ashapira@atlassian.com>
Date: Sun, 31 Mar 2013 23:47:11 +1100
Subject: (#19998) fix name of function in a comment

---
 lib/puppet/parser/functions/any2array.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'lib/puppet')

diff --git a/lib/puppet/parser/functions/any2array.rb b/lib/puppet/parser/functions/any2array.rb
index d150743..95944e1 100644
--- a/lib/puppet/parser/functions/any2array.rb
+++ b/lib/puppet/parser/functions/any2array.rb
@@ -1,5 +1,5 @@
 #
-# str2bool.rb
+# any2array.rb
 #
 
 module Puppet::Parser::Functions
-- 
cgit v1.2.3


From e7d394b6e9fc3ca07803d18fcf2f5d19b91e92e0 Mon Sep 17 00:00:00 2001
From: Amos Shapira <ashapira@atlassian.com>
Date: Mon, 1 Apr 2013 14:52:07 +1100
Subject: Remove resundant code

---
 lib/puppet/parser/functions/any2array.rb | 2 --
 1 file changed, 2 deletions(-)

(limited to 'lib/puppet')

diff --git a/lib/puppet/parser/functions/any2array.rb b/lib/puppet/parser/functions/any2array.rb
index 95944e1..e71407e 100644
--- a/lib/puppet/parser/functions/any2array.rb
+++ b/lib/puppet/parser/functions/any2array.rb
@@ -23,8 +23,6 @@ converted to arrays of alternating keys and values.
                 result << key << value
             end
             return result
-        else
-            return [arguments[0]]
         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 'lib/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 ddad4455cc914862f16c2e8cae96812e244b0a1d Mon Sep 17 00:00:00 2001
From: Philip Potter <philipgpotter@gmail.com>
Date: Thu, 12 Jul 2012 17:05:23 +0100
Subject: Make the anchor type propagate refresh events

Without this patch the anchor resource does not propogate refresh
events, making it difficult to subscribe to a class which has been
notified by another resource.
---
 lib/puppet/type/anchor.rb | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'lib/puppet')

diff --git a/lib/puppet/type/anchor.rb b/lib/puppet/type/anchor.rb
index 6b81732..fe1e5aa 100644
--- a/lib/puppet/type/anchor.rb
+++ b/lib/puppet/type/anchor.rb
@@ -38,4 +38,9 @@ Puppet::Type.newtype(:anchor) do
     desc "The name of the anchor resource."
   end
 
+  def refresh
+    # We don't do anything with them, but we need this to
+    #   show that we are "refresh aware" and not break the
+    #   chain of propagation.
+  end
 end
-- 
cgit v1.2.3