Merge branch 'master' into 4.5.x

Author: Travis Fields

.fixtures.yml

@@ -0,0 +1,3 @@
+fixtures:
+  symlinks:
+    stdlib: "#{source_dir}"

.gitignore

@@ -5,3 +5,5 @@ spec/fixtures/
 .vagrant/
 .bundle/
 coverage/
+.idea/
+*.iml

.travis.yml

@@ -1,4 +1,5 @@
 ---
+sudo: false
 language: ruby
 bundler_args: --without system_tests
 script: "bundle exec rake validate && bundle exec rake lint && bundle exec rake spec SPEC_OPTS='--color --format documentation'"

README.markdown

@@ -15,15 +15,15 @@
 class Facter::Util::DotD
   require 'yaml'
 
-  def initialize(dir="/etc/facts.d", cache_file="/tmp/facts_cache.yml")
+  def initialize(dir="/etc/facts.d", cache_file=File.join(Puppet[:libdir], "facts_dot_d.cache"))
     @dir = dir
     @cache_file = cache_file
     @cache = nil
     @types = {".txt" => :txt, ".json" => :json, ".yaml" => :yaml}
   end
 
   def entries
-    Dir.entries(@dir).reject{|f| f =~ /^\.|\.ttl$/}.sort.map {|f| File.join(@dir, f) }
+    Dir.entries(@dir).reject { |f| f =~ /^\.|\.ttl$/ }.sort.map { |f| File.join(@dir, f) }
   rescue
     []
   end
@@ -113,7 +113,7 @@ def script_parser(file)
 
   def cache_save!
     cache = load_cache
-    File.open(@cache_file, "w", 0600) {|f| f.write(YAML.dump(cache)) }
+    File.open(@cache_file, "w", 0600) { |f| f.write(YAML.dump(cache)) }
   rescue
   end
 

lib/facter/facter_dot_d.rb

@@ -0,0 +1,17 @@
+# Returns the type when passed a value.
+#
+# @example how to compare values' types
+#   # compare the types of two values
+#   if type_of($first_value) != type_of($second_value) { fail("first_value and second_value are different types") }
+# @example how to compare against an abstract type
+#   unless type_of($first_value) <= Numeric { fail("first_value must be Numeric") }
+#   unless type_of{$first_value) <= Collection[1] { fail("first_value must be an Array or Hash, and contain at least one element") }
+#
+# See the documentation for "The Puppet Type System" for more information about types.
+# See the `assert_type()` function for flexible ways to assert the type of a value.
+#
+Puppet::Functions.create_function(:type_of) do
+  def type_of(value)
+    Puppet::Pops::Types::TypeCalculator.infer_set(value)
+  end
+end

lib/puppet/functions/type_of.rb

@@ -0,0 +1,34 @@
+module Puppet::Parser::Functions
+  newfunction(:basename, :type => :rvalue, :doc => <<-EOS
+    Strips directory (and optional suffix) from a filename
+    EOS
+  ) do |arguments|
+
+    if arguments.size < 1 then
+      raise(Puppet::ParseError, "basename(): No arguments given")
+    elsif arguments.size > 2 then
+      raise(Puppet::ParseError, "basename(): Too many arguments given (#{arguments.size})")
+    else
+
+      unless arguments[0].is_a?(String)
+        raise(Puppet::ParseError, 'basename(): Requires string as first argument')
+      end
+
+      if arguments.size == 1 then
+        rv = File.basename(arguments[0])
+      elsif arguments.size == 2 then
+
+        unless arguments[1].is_a?(String)
+          raise(Puppet::ParseError, 'basename(): Requires string as second argument')
+        end
+
+        rv = File.basename(arguments[0], arguments[1])
+      end
+
+    end
+
+    return rv
+  end
+end
+
+# vim: set ts=2 sw=2 et :

lib/puppet/parser/functions/basename.rb

@@ -4,31 +4,35 @@
 
 module Puppet::Parser::Functions
   newfunction(:concat, :type => :rvalue, :doc => <<-EOS
-Appends the contents of array 2 onto array 1.
+Appends the contents of multiple arrays into array 1.
 
 *Example:*
 
-    concat(['1','2','3'],['4','5','6'])
+    concat(['1','2','3'],['4','5','6'],['7','8','9'])
 
 Would result in:
 
-  ['1','2','3','4','5','6']
+  ['1','2','3','4','5','6','7','8','9']
     EOS
   ) do |arguments|
 
-    # Check that 2 arguments have been given ...
+    # Check that more than 2 arguments have been given ...
     raise(Puppet::ParseError, "concat(): Wrong number of arguments " +
-      "given (#{arguments.size} for 2)") if arguments.size != 2
+      "given (#{arguments.size} for < 2)") if arguments.size < 2
 
     a = arguments[0]
-    b = arguments[1]
 
     # Check that the first parameter is an array
     unless a.is_a?(Array)
       raise(Puppet::ParseError, 'concat(): Requires array to work with')
     end
 
-    result = a + Array(b)
+    result = a
+    arguments.shift
+
+    arguments.each do |x|
+      result = result + Array(x)
+    end
 
     return result
   end

lib/puppet/parser/functions/concat.rb

@@ -17,27 +17,30 @@ module Puppet::Parser::Functions
     delete({'a'=>1,'b'=>2,'c'=>3}, 'b')
     Would return: {'a'=>1,'c'=>3}
 
+    delete({'a'=>1,'b'=>2,'c'=>3}, ['b','c'])
+    Would return: {'a'=>1}
+
     delete('abracadabra', 'bra')
     Would return: 'acada'
-    EOS
+  EOS
   ) do |arguments|
 
     if (arguments.size != 2) then
       raise(Puppet::ParseError, "delete(): Wrong number of arguments "+
-        "given #{arguments.size} for 2.")
+                                  "given #{arguments.size} for 2.")
     end
 
     collection = arguments[0].dup
-    item = arguments[1]
-
-    case collection
-    when Array, Hash
-      collection.delete item
-    when String
-      collection.gsub! item, ''
-    else
-      raise(TypeError, "delete(): First argument must be an Array, " +
-            "String, or Hash. Given an argument of class #{collection.class}.")
+    Array(arguments[1]).each do |item|
+      case collection
+        when Array, Hash
+          collection.delete item
+        when String
+          collection.gsub! item, ''
+        else
+          raise(TypeError, "delete(): First argument must be an Array, " +
+                             "String, or Hash. Given an argument of class #{collection.class}.")
+      end
     end
     collection
   end

lib/puppet/parser/functions/delete.rb

@@ -36,8 +36,9 @@
   items.each do |item|
     Puppet::Parser::Functions.function(:defined_with_params)
     if function_defined_with_params(["#{type}[#{item}]", params])
-      Puppet.debug("Resource #{type}[#{item}] not created because it already exists")
+      Puppet.debug("Resource #{type}[#{item}] with params #{params} not created because it already exists")
     else
+      Puppet.debug("Create new resource #{type}[#{item}] with params #{params}")
       Puppet::Parser::Functions.function(:create_resources)
       function_create_resources([type.capitalize, { item => params }])
     end