Merge branch 'master' into 4.3.x

Author: hunner

lib/puppet/parser/functions/bool2str.rb

@@ -0,0 +1,27 @@
+#
+# bool2str.rb
+#
+
+module Puppet::Parser::Functions
+  newfunction(:bool2str, :type => :rvalue, :doc => <<-EOS
+    Converts a boolean to a string.
+    Requires a single boolean as an input.
+    EOS
+  ) do |arguments|
+
+    raise(Puppet::ParseError, "bool2str(): Wrong number of arguments " +
+      "given (#{arguments.size} for 1)") if arguments.size < 1
+
+    value = arguments[0]
+    klass = value.class
+
+    # We can have either true or false, and nothing else
+    unless [FalseClass, TrueClass].include?(klass)
+      raise(Puppet::ParseError, 'bool2str(): Requires a boolean to work with')
+    end
+
+    return value.to_s
+  end
+end
+
+# vim: set ts=2 sw=2 et :

lib/puppet/parser/functions/camelcase.rb

@@ -0,0 +1,33 @@
+#
+#  camelcase.rb
+#
+
+module Puppet::Parser::Functions
+  newfunction(:camelcase, :type => :rvalue, :doc => <<-EOS
+Converts the case of a string or all strings in an array to camel case.
+    EOS
+  ) do |arguments|
+
+    raise(Puppet::ParseError, "camelcase(): Wrong number of arguments " +
+      "given (#{arguments.size} for 1)") if arguments.size < 1
+
+    value = arguments[0]
+    klass = value.class
+
+    unless [Array, String].include?(klass)
+      raise(Puppet::ParseError, 'camelcase(): Requires either ' +
+        'array or string to work with')
+    end
+
+    if value.is_a?(Array)
+      # Numbers in Puppet are often string-encoded which is troublesome ...
+      result = value.collect { |i| i.is_a?(String) ? i.split('_').map{|e| e.capitalize}.join : i }
+    else
+      result = value.split('_').map{|e| e.capitalize}.join
+    end
+
+    return result
+  end
+end
+
+# vim: set ts=2 sw=2 et :

spec/functions/abs_spec.rb

@@ -6,20 +6,20 @@
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("abs").should == "function_abs"
+    expect(Puppet::Parser::Functions.function("abs")).to eq("function_abs")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_abs([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_abs([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should convert a negative number into a positive" do
     result = scope.function_abs(["-34"])
-    result.should(eq(34))
+    expect(result).to(eq(34))
   end
 
   it "should do nothing with a positive number" do
     result = scope.function_abs(["5678"])
-    result.should(eq(5678))
+    expect(result).to(eq(5678))
   end
 end

spec/functions/any2array_spec.rb

@@ -5,51 +5,51 @@
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("any2array").should == "function_any2array"
+    expect(Puppet::Parser::Functions.function("any2array")).to eq("function_any2array")
   end
 
   it "should return an empty array if there is less than 1 argument" do
     result = scope.function_any2array([])
-    result.should(eq([]))
+    expect(result).to(eq([]))
   end
 
   it "should convert boolean true to [ true ] " do
     result = scope.function_any2array([true])
-    result.should(eq([true]))
+    expect(result).to(eq([true]))
   end
 
   it "should convert one object to [object]" do
     result = scope.function_any2array(['one'])
-    result.should(eq(['one']))
+    expect(result).to(eq(['one']))
   end
 
   it "should convert multiple objects to [objects]" do
     result = scope.function_any2array(['one', 'two'])
-    result.should(eq(['one', 'two']))
+    expect(result).to(eq(['one', 'two']))
   end
 
   it "should return empty array it was called with" do
     result = scope.function_any2array([[]])
-    result.should(eq([]))
+    expect(result).to(eq([]))
   end
 
   it "should return one-member array it was called with" do
     result = scope.function_any2array([['string']])
-    result.should(eq(['string']))
+    expect(result).to(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']))
+    expect(result).to(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']))
+    expect(result).to(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([]))
+    expect(result).to(eq([]))
   end
 end

spec/functions/base64_spec.rb

@@ -6,7 +6,7 @@
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("base64").should == "function_base64"
+    expect(Puppet::Parser::Functions.function("base64")).to eq("function_base64")
   end
 
   it "should raise a ParseError if there are other than 2 arguments" do
@@ -25,10 +25,10 @@
 
   it "should encode a encoded string" do
     result = scope.function_base64(["encode",'thestring'])
-    result.should =~ /\AdGhlc3RyaW5n\n\Z/
+    expect(result).to match(/\AdGhlc3RyaW5n\n\Z/)
   end
   it "should decode a base64 encoded string" do
     result = scope.function_base64(["decode",'dGhlc3RyaW5n'])
-    result.should == 'thestring'
+    expect(result).to eq('thestring')
   end
 end

spec/functions/bool2num_spec.rb

@@ -5,20 +5,20 @@
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("bool2num").should == "function_bool2num"
+    expect(Puppet::Parser::Functions.function("bool2num")).to eq("function_bool2num")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_bool2num([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_bool2num([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should convert true to 1" do
     result = scope.function_bool2num([true])
-    result.should(eq(1))
+    expect(result).to(eq(1))
   end
 
   it "should convert false to 0" do
     result = scope.function_bool2num([false])
-    result.should(eq(0))
+    expect(result).to(eq(0))
   end
 end

spec/functions/capitalize_spec.rb

@@ -5,15 +5,15 @@
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("capitalize").should == "function_capitalize"
+    expect(Puppet::Parser::Functions.function("capitalize")).to eq("function_capitalize")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_capitalize([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_capitalize([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should capitalize the beginning of a string" do
     result = scope.function_capitalize(["abc"])
-    result.should(eq("Abc"))
+    expect(result).to(eq("Abc"))
   end
 end

spec/functions/chomp_spec.rb

@@ -5,15 +5,15 @@
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("chomp").should == "function_chomp"
+    expect(Puppet::Parser::Functions.function("chomp")).to eq("function_chomp")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_chomp([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_chomp([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should chomp the end of a string" do
     result = scope.function_chomp(["abc\n"])
-    result.should(eq("abc"))
+    expect(result).to(eq("abc"))
   end
 end

spec/functions/chop_spec.rb

@@ -5,15 +5,15 @@
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("chop").should == "function_chop"
+    expect(Puppet::Parser::Functions.function("chop")).to eq("function_chop")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_chop([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_chop([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should chop the end of a string" do
     result = scope.function_chop(["asdf\n"])
-    result.should(eq("asdf"))
+    expect(result).to(eq("asdf"))
   end
 end

spec/functions/concat_spec.rb

@@ -5,26 +5,26 @@
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should raise a ParseError if the client does not provide two arguments" do
-    lambda { scope.function_concat([]) }.should(raise_error(Puppet::ParseError))
+    expect { scope.function_concat([]) }.to(raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError if the first parameter is not an array" do
-    lambda { scope.function_concat([1, []])}.should(raise_error(Puppet::ParseError))
+    expect { scope.function_concat([1, []])}.to(raise_error(Puppet::ParseError))
   end
 
   it "should be able to concat an array" do
     result = scope.function_concat([['1','2','3'],['4','5','6']])
-    result.should(eq(['1','2','3','4','5','6']))
+    expect(result).to(eq(['1','2','3','4','5','6']))
   end
 
   it "should be able to concat a primitive to an array" do
     result = scope.function_concat([['1','2','3'],'4'])
-    result.should(eq(['1','2','3','4']))
+    expect(result).to(eq(['1','2','3','4']))
   end
 
   it "should not accidentally flatten nested arrays" do
     result = scope.function_concat([['1','2','3'],[['4','5'],'6']])
-    result.should(eq(['1','2','3',['4','5'],'6']))
+    expect(result).to(eq(['1','2','3',['4','5'],'6']))
   end
 
 end