puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/functions/map.rb

@@ -0,0 +1,43 @@
+Puppet::Parser::Functions::newfunction(
+  :map,
+  :type => :rvalue,
+  :arity => -3,
+  :doc => <<-DOC
+Applies a parameterized block to each element in a sequence of entries from the first
+argument and returns an array with the result of each invocation of the parameterized block.
+
+This function takes two mandatory arguments: the first should be an Array, Hash, or of Enumerable type
+(integer, Integer range, or String), and the second a parameterized block as produced by the puppet syntax:
+
+      $a.map |$x| { ... }
+      map($a) |$x| { ... }
+
+When the first argument `$a` is an Array or of enumerable type, the block is called with each entry in turn.
+When the first argument is a hash the entry is an array with `[key, value]`.
+
+Example Using map with two arguments
+
+     # Turns hash into array of values
+     $a.map |$x|{ $x[1] }
+
+     # Turns hash into array of keys
+     $a.map |$x| { $x[0] }
+
+When using a block with 2 parameters, the element's index (starting from 0) for an array, and the key for a hash
+is given to the block's first parameter, and the value is given to the block's second parameter.args.
+
+Example Using map with two arguments
+
+     # Turns hash into array of values
+     $a.map |$key,$val|{ $val }
+
+     # Turns hash into array of keys
+     $a.map |$key,$val|{ $key }
+
+- since 3.4 for Array and Hash
+- since 3.5 for other enumerables, and support for blocks with 2 parameters
+- note requires `parser = future`
+DOC
+) do |args|
+  function_fail(["map() is only available when parser/evaluator future is in effect"])
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/functions/match.rb

@@ -0,0 +1,28 @@
+Puppet::Parser::Functions::newfunction(
+  :match,
+  :arity => 2,
+  :doc => <<-DOC
+Returns the match result of matching a String or Array[String] with one of:
+
+* Regexp
+* String - transformed to a Regexp
+* Pattern type
+* Regexp type
+
+Returns An Array with the entire match at index 0, and each subsequent submatch at index 1-n.
+If there was no match `undef` is returned. If the value to match is an Array, a array
+with mapped match results is returned.
+
+Example matching:
+
+  "abc123".match(/([a-z]+)[1-9]+/)    # => ["abc"]
+  "abc123".match(/([a-z]+)([1-9]+)/)  # => ["abc", "123"]
+
+See the documentation for "The Puppet Type System" for more information about types.
+
+- since 3.7.0
+- note requires future parser
+DOC
+) do |args|
+  function_fail(["match() is only available when parser/evaluator future is in effect"])
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/functions/md5.rb

@@ -0,0 +1,5 @@
+require 'digest/md5'
+
+Puppet::Parser::Functions::newfunction(:md5, :type => :rvalue, :arity => 1, :doc => "Returns a MD5 hash value from a provided string.") do |args|
+      Digest::MD5.hexdigest(args[0])
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/functions/realize.rb

@@ -0,0 +1,14 @@
+# This is just syntactic sugar for a collection, although it will generally
+# be a good bit faster.
+
+Puppet::Parser::Functions::newfunction(:realize, :arity => -2, :doc => "Make a virtual object real.  This is useful
+    when you want to know the name of the virtual object and don't want to
+    bother with a full collection.  It is slightly faster than a collection,
+    and, of course, is a bit shorter.  You must pass the object using a
+    reference; e.g.: `realize User[luke]`." ) do |vals|
+    coll = Puppet::Parser::Collector.new(self, :nomatter, nil, nil, :virtual)
+    vals = [vals] unless vals.is_a?(Array)
+    coll.resources = vals.flatten
+
+    compiler.add_collection(coll)
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/functions/reduce.rb

@@ -0,0 +1,71 @@
+Puppet::Parser::Functions::newfunction(
+  :reduce,
+  :type => :rvalue,
+  :arity => -3,
+  :doc => <<-DOC
+Applies a parameterized block to each element in a sequence of entries from the first
+argument (_the enumerable_) and returns the last result of the invocation of the parameterized block.
+
+This function takes two mandatory arguments: the first should be an Array, Hash, or something of
+enumerable type, and the last a parameterized block as produced by the puppet syntax:
+
+      $a.reduce |$memo, $x| { ... }
+      reduce($a) |$memo, $x| { ... }
+
+When the first argument is an Array or someting of an enumerable type, the block is called with each entry in turn.
+When the first argument is a hash each entry is converted to an array with `[key, value]` before being
+fed to the block. An optional 'start memo' value may be supplied as an argument between the array/hash
+and mandatory block.
+
+      $a.reduce(start) |$memo, $x| { ... }
+      reduce($a, start) |$memo, $x| { ... }
+
+If no 'start memo' is given, the first invocation of the parameterized block will be given the first and second
+elements of the enumeration, and if the enumerable has fewer than 2 elements, the first
+element is produced as the result of the reduction without invocation of the block.
+
+On each subsequent invocation, the produced value of the invoked parameterized block is given as the memo in the
+next invocation.
+
+Example Using reduce
+
+      # Reduce an array
+      $a = [1,2,3]
+      $a.reduce |$memo, $entry| { $memo + $entry }
+      #=> 6
+
+      # Reduce hash values
+      $a = {a => 1, b => 2, c => 3}
+      $a.reduce |$memo, $entry| { [sum, $memo[1]+$entry[1]] }
+      #=> [sum, 6]
+
+      # reverse a string
+      "abc".reduce |$memo, $char| { "$char$memo" }
+      #=>"cbe"
+
+It is possible to provide a starting 'memo' as an argument.
+
+Example Using reduce with given start 'memo'
+
+      # Reduce an array
+      $a = [1,2,3]
+      $a.reduce(4) |$memo, $entry| { $memo + $entry }
+      #=> 10
+
+      # Reduce hash values
+      $a = {a => 1, b => 2, c => 3}
+      $a.reduce([na, 4]) |$memo, $entry| { [sum, $memo[1]+$entry[1]] }
+      #=> [sum, 10]
+
+Example Using reduce with an Integer range
+
+      Integer[1,4].reduce |$memo, $x| { $memo + $x }
+      #=> 10
+
+- since 3.2 for Array and Hash
+- since 3.5 for additional enumerable types
+- note requires `parser = future`.
+DOC
+) do |args|
+  function_fail(["reduce() is only available when parser/evaluator future is in effect"])
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/functions/regsubst.rb

@@ -0,0 +1,116 @@
+# Copyright (C) 2009 Thomas Bellman
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THOMAS BELLMAN BE LIABLE FOR ANY CLAIM, DAMAGES OR
+# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+#
+# Except as contained in this notice, the name of Thomas Bellman shall
+# not be used in advertising or otherwise to promote the sale, use or
+# other dealings in this Software without prior written authorization
+# from Thomas Bellman.
+
+Puppet::Parser::Functions::newfunction(
+  :regsubst, :type => :rvalue,
+  :arity => -4,
+
+  :doc => "
+Perform regexp replacement on a string or array of strings.
+
+* *Parameters* (in order):
+    * _target_  The string or array of strings to operate on.  If an array, the replacement will be performed on each of the elements in the array, and the return value will be an array.
+    * _regexp_  The regular expression matching the target string.  If you want it anchored at the start and or end of the string, you must do that with ^ and $ yourself.
+    * _replacement_  Replacement string. Can contain backreferences to what was matched using \\0 (whole match), \\1 (first set of parentheses), and so on.
+    * _flags_  Optional. String of single letter flags for how the regexp is interpreted:
+        - *E*         Extended regexps
+        - *I*         Ignore case in regexps
+        - *M*         Multiline regexps
+        - *G*         Global replacement; all occurrences of the regexp in each target string will be replaced.  Without this, only the first occurrence will be replaced.
+    * _encoding_  Optional.  How to handle multibyte characters.  A single-character string with the following values:
+        - *N*         None
+        - *E*         EUC
+        - *S*         SJIS
+        - *U*         UTF-8
+
+* *Examples*
+
+Get the third octet from the node's IP address:
+
+    $i3 = regsubst($ipaddress,'^(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)$','\\3')
+
+Put angle brackets around each octet in the node's IP address:
+
+    $x = regsubst($ipaddress, '([0-9]+)', '<\\1>', 'G')
+") do |args|
+  unless args.length.between?(3, 5)
+
+    raise(
+      ArgumentError,
+
+        "regsubst(): got #{args.length} arguments, expected 3 to 5")
+  end
+  target, regexp, replacement, flags, lang = args
+  reflags = 0
+  operation = :sub
+  if flags == nil
+    flags = []
+  elsif flags.respond_to?(:split)
+    flags = flags.split('')
+  else
+
+    raise(
+      Puppet::ParseError,
+
+        "regsubst(): bad flags parameter #{flags.class}:`#{flags}'")
+  end
+  flags.each do |f|
+    case f
+    when 'G' then operation = :gsub
+    when 'E' then reflags |= Regexp::EXTENDED
+    when 'I' then reflags |= Regexp::IGNORECASE
+    when 'M' then reflags |= Regexp::MULTILINE
+    else raise(Puppet::ParseError, "regsubst(): bad flag `#{f}'")
+    end
+  end
+  begin
+    re = Regexp.compile(regexp, reflags, lang)
+  rescue RegexpError, TypeError
+
+    raise(
+      Puppet::ParseError,
+
+        "regsubst(): Bad regular expression `#{regexp}'")
+  end
+  if target.respond_to?(operation)
+    # String parameter -> string result
+    result = target.send(operation, re, replacement)
+  elsif target.respond_to?(:collect) and
+    target.respond_to?(:all?) and
+    target.all? { |e| e.respond_to?(operation) }
+    # Array parameter -> array result
+    result = target.collect { |e|
+      e.send(operation, re, replacement)
+    }
+  else
+
+    raise(
+      Puppet::ParseError,
+
+        "regsubst(): bad target #{target.class}:`#{target}'")
+  end
+  return result
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/functions/require.rb

@@ -0,0 +1,61 @@
+# Requires the specified classes
+
+  Puppet::Parser::Functions::newfunction(
+    :require,
+    :arity => -2,
+    :doc =>"Evaluate one or more classes,  adding the required class as a dependency.
+
+The relationship metaparameters work well for specifying relationships
+between individual resources, but they can be clumsy for specifying
+relationships between classes.  This function is a superset of the
+'include' function, adding a class relationship so that the requiring
+class depends on the required class.
+
+Warning: using require in place of include can lead to unwanted dependency cycles.
+
+For instance the following manifest, with 'require' instead of 'include' would produce a nasty dependence cycle, because notify imposes a before between File[/foo] and Service[foo]:
+
+    class myservice {
+      service { foo: ensure => running }
+    }
+
+    class otherstuff {
+      include myservice
+      file { '/foo': notify => Service[foo] }
+    }
+
+Note that this function only works with clients 0.25 and later, and it will
+fail if used with earlier clients.
+
+When the future parser is used, you must use the class's full name;
+relative names are no longer allowed. In addition to names in string form,
+you may also directly use Class and Resource Type values that are produced by
+the future parser's resource and relationship expressions.
+") do |vals|
+  # Make call patterns uniform and protected against nested arrays, also make
+  # names absolute if so desired.
+  vals = transform_and_assert_classnames(vals.is_a?(Array) ? vals.flatten : [vals])
+
+  # This is the same as calling the include function (but faster) since it again
+  # would otherwise need to perform the optional absolute name transformation
+  # (for no reason since they are already made absolute here).
+  #
+  compiler.evaluate_classes(vals, self, false)
+
+  vals.each do |klass|
+    # lookup the class in the scopes
+    if classobj = find_hostclass(klass)
+      klass = classobj.name
+    else
+      raise Puppet::ParseError, "Could not find class #{klass}"
+    end
+
+    # This is a bit hackish, in some ways, but it's the only way
+    # to configure a dependency that will make it to the client.
+    # The 'obvious' way is just to add an edge in the catalog,
+    # but that is considered a containment edge, not a dependency
+    # edge, so it usually gets lost on the client.
+    ref = Puppet::Resource.new(:class, klass)
+    resource.set_parameter(:require, [resource[:require]].flatten.compact << ref)
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/functions/search.rb

@@ -0,0 +1,12 @@
+Puppet::Parser::Functions::newfunction(:search, :arity => -2, :doc => "Add another namespace for this class to search.
+    This allows you to create classes with sets of definitions and add
+    those classes to another class's search path.
+
+    Deprecated in Puppet 3.7.0, to be removed in Puppet 4.0.0.") do |vals|
+
+    Puppet.deprecation_warning("The 'search' function is deprecated. See http://links.puppetlabs.com/search-function-deprecation")
+
+    vals.each do |val|
+      add_namespace(val)
+    end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/functions/sha1.rb

@@ -0,0 +1,5 @@
+require 'digest/sha1'
+
+Puppet::Parser::Functions::newfunction(:sha1, :type => :rvalue, :arity => 1, :doc => "Returns a SHA1 hash value from a provided string.") do |args|
+      Digest::SHA1.hexdigest(args[0])
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/functions/shellquote.rb

@@ -0,0 +1,61 @@
+# Copyright (C) 2009 Thomas Bellman
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THOMAS BELLMAN BE LIABLE FOR ANY CLAIM, DAMAGES OR
+# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+#
+# Except as contained in this notice, the name of Thomas Bellman shall
+# not be used in advertising or otherwise to promote the sale, use or
+# other dealings in this Software without prior written authorization
+# from Thomas Bellman.
+
+Puppet::Parser::Functions.newfunction(:shellquote, :type => :rvalue, :arity => -1, :doc => "\
+    Quote and concatenate arguments for use in Bourne shell.
+
+    Each argument is quoted separately, and then all are concatenated
+    with spaces.  If an argument is an array, the elements of that
+    array is interpolated within the rest of the arguments; this makes
+    it possible to have an array of arguments and pass that array to
+    shellquote instead of having to specify each argument
+    individually in the call.
+    ") \
+do |args|
+  safe = 'a-zA-Z0-9@%_+=:,./-'    # Safe unquoted
+  dangerous = '!"`$\\'            # Unsafe inside double quotes
+
+  result = []
+  args.flatten.each do |word|
+    if word.length != 0 and word.count(safe) == word.length
+      result << word
+    elsif word.count(dangerous) == 0
+      result << ('"' + word + '"')
+    elsif word.count("'") == 0
+      result << ("'" + word + "'")
+    else
+      r = '"'
+      word.each_byte do |c|
+        r += "\\" if dangerous.include?(c.chr)
+        r += c.chr
+      end
+      r += '"'
+      result << r
+    end
+  end
+
+  return result.join(" ")
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/functions/slice.rb

@@ -0,0 +1,48 @@
+Puppet::Parser::Functions::newfunction(
+  :slice,
+  :type => :rvalue,
+  :arity => -3,
+  :doc => <<-DOC
+Applies a parameterized block to each _slice_ of elements in a sequence of selected entries from the first
+argument and returns the first argument, or if no block is given returns a new array with a concatenation of
+the slices.
+
+This function takes two mandatory arguments: the first, `$a`, should be an Array, Hash, or something of
+enumerable type (integer, Integer range, or String), and the second, `$n`, the number of elements to include
+in each slice. The optional third argument should be a a parameterized block as produced by the puppet syntax:
+
+    $a.slice($n) |$x| { ... }
+    slice($a) |$x| { ... }
+
+The parameterized block should have either one parameter (receiving an array with the slice), or the same number
+of parameters as specified by the slice size (each parameter receiving its part of the slice).
+In case there are fewer remaining elements than the slice size for the last slice it will contain the remaining
+elements. When the block has multiple parameters, excess parameters are set to undef for an array or
+enumerable type, and to empty arrays for a Hash.
+
+    $a.slice(2) |$first, $second| { ... }
+
+When the first argument is a Hash, each `key,value` entry is counted as one, e.g, a slice size of 2 will produce
+an array of two arrays with key, and value.
+
+Example Using slice with Hash
+
+    $a.slice(2) |$entry|          { notice "first ${$entry[0]}, second ${$entry[1]}" }
+    $a.slice(2) |$first, $second| { notice "first ${first}, second ${second}" }
+
+When called without a block, the function produces a concatenated result of the slices.
+
+Example Using slice without a block
+
+    slice([1,2,3,4,5,6], 2) # produces [[1,2], [3,4], [5,6]]
+    slice(Integer[1,6], 2)  # produces [[1,2], [3,4], [5,6]]
+    slice(4,2)              # produces [[0,1], [2,3]]
+    slice('hello',2)        # produces [[h, e], [l, l], [o]]
+
+- since 3.2 for Array and Hash
+- since 3.5 for additional enumerable types
+- note requires `parser = future`.
+DOC
+) do |args|
+  function_fail(["slice() is only available when parser/evaluator future is in effect"])
+end