puppet-retrospec 0.7.0 → 0.7.2

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

@@ -0,0 +1,31 @@
+Puppet::Parser::Functions::newfunction(
+  :assert_type,
+  :type => :rvalue,
+  :arity => -3,
+  :doc => "Returns the given value if it is an instance of the given type, and raises an error otherwise.
+Optionally, if a block is given (accepting two parameters), it will be called instead of raising
+an error. This to enable giving the user richer feedback, or to supply a default value.
+
+Example: assert that `$b` is a non empty `String` and assign to `$a`:
+
+  $a = assert_type(String[1], $b)
+
+Example using custom error message:
+
+  $a = assert_type(String[1], $b) |$expected, $actual| {
+    fail('The name cannot be empty')
+  }
+
+Example, using a warning and a default:
+
+  $a = assert_type(String[1], $b) |$expected, $actual| {
+    warning('Name is empty, using default')
+    'anonymous'
+  }
+
+See the documentation for 'The Puppet Type System' for more information about types.
+- since Puppet 3.7
+- requires future parser/evaluator
+") do |args|
+  function_fail(["assert_type() is only available when parser/evaluator future is in effect"])
+end

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

@@ -0,0 +1,36 @@
+# Called within a class definition, establishes a containment
+# relationship with another class
+
+Puppet::Parser::Functions::newfunction(
+  :contain,
+  :arity => -2,
+  :doc => "Contain one or more classes inside the current class. If any of
+these classes are undeclared, they will be declared as if called with the
+`include` function. Accepts a class name, an array of class names, or a
+comma-separated list of class names.
+
+A contained class will not be applied before the containing class is
+begun, and will be finished before the containing class is finished.
+
+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 |classes|
+  scope = self
+
+  # Make call patterns uniform and protected against nested arrays, also make
+  # names absolute if so desired.
+  classes = transform_and_assert_classnames(classes.is_a?(Array) ? classes.flatten : [classes])
+
+  containing_resource = scope.resource
+
+  # This is the same as calling the include function but faster and does not rely on the include
+  # function (which is a statement) to return something (it should not).
+  (compiler.evaluate_classes(classes, self, false) || []).each do |resource|
+    if ! scope.catalog.edge?(containing_resource, resource)
+      scope.catalog.add_edge(containing_resource, resource)
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc => <<-'ENDHEREDOC') do |args|
+    Converts a hash into a set of resources and adds them to the catalog.
+
+    This function takes two mandatory arguments: a resource type, and a hash describing
+    a set of resources. The hash should be in the form `{title => {parameters} }`:
+
+        # A hash of user resources:
+        $myusers = {
+          'nick' => { uid    => '1330',
+                      gid    => allstaff,
+                      groups => ['developers', 'operations', 'release'], },
+          'dan'  => { uid    => '1308',
+                      gid    => allstaff,
+                      groups => ['developers', 'prosvc', 'release'], },
+        }
+
+        create_resources(user, $myusers)
+
+    A third, optional parameter may be given, also as a hash:
+
+        $defaults = {
+          'ensure'   => present,
+          'provider' => 'ldap',
+        }
+
+        create_resources(user, $myusers, $defaults)
+
+    The values given on the third argument are added to the parameters of each resource
+    present in the set given on the second argument. If a parameter is present on both
+    the second and third arguments, the one on the second argument takes precedence.
+
+    This function can be used to create defined resources and classes, as well
+    as native resources.
+
+    Virtual and Exported resources may be created by prefixing the type name
+    with @ or @@ respectively.  For example, the $myusers hash may be exported
+    in the following manner:
+
+        create_resources("@@user", $myusers)
+
+    The $myusers may be declared as virtual resources using:
+
+        create_resources("@user", $myusers)
+
+  ENDHEREDOC
+  raise ArgumentError, ("create_resources(): wrong number of arguments (#{args.length}; must be 2 or 3)") if args.length > 3
+  raise ArgumentError, ('create_resources(): second argument must be a hash') unless args[1].is_a?(Hash)
+  if args.length == 3
+    raise ArgumentError, ('create_resources(): third argument, if provided, must be a hash') unless args[2].is_a?(Hash)
+  end
+
+
+  type, instances, defaults = args
+  defaults ||= {}
+
+  resource = Puppet::Parser::AST::Resource.new(:type => type.sub(/^@{1,2}/, '').downcase, :instances =>
+    instances.collect do |title, params|
+      Puppet::Parser::AST::ResourceInstance.new(
+        :title => Puppet::Parser::AST::Leaf.new(:value => title),
+        :parameters => defaults.merge(params).collect do |name, value|
+          Puppet::Parser::AST::ResourceParam.new(
+            :param => name,
+            :value => Puppet::Parser::AST::Leaf.new(:value => value))
+        end)
+    end)
+
+  if type.start_with? '@@'
+    resource.exported = true
+  elsif type.start_with? '@'
+    resource.virtual = true
+  end
+
+  begin
+    resource.safeevaluate(self)
+  rescue Puppet::ParseError => internal_error
+    if internal_error.original.nil?
+      raise internal_error
+    else
+      raise internal_error.original
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# Test whether a given class or definition is defined
+Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :arity => -2, :doc => "Determine whether
+  a given class or resource type is defined. This function can also determine whether a
+  specific resource has been declared, or whether a variable has been assigned a value
+  (including undef...as opposed to never having been assigned anything). Returns true
+  or false. Accepts class names, type names, resource references, and variable
+  reference strings of the form '$name'.  When more than one argument is
+  supplied, defined() returns true if any are defined.
+
+  The `defined` function checks both native and defined types, including types
+  provided as plugins via modules. Types and classes are both checked using their names:
+
+      defined(\"file\")
+      defined(\"customtype\")
+      defined(\"foo\")
+      defined(\"foo::bar\")
+      defined(\'$name\')
+
+  Resource declarations are checked using resource references, e.g.
+  `defined( File['/tmp/myfile'] )`. Checking whether a given resource
+  has been declared is, unfortunately, dependent on the parse order of
+  the configuration, and the following code will not work:
+
+      if defined(File['/tmp/foo']) {
+          notify { \"This configuration includes the /tmp/foo file.\":}
+      }
+      file { \"/tmp/foo\":
+          ensure => present,
+      }
+
+  However, this order requirement refers to parse order only, and ordering of
+  resources in the configuration graph (e.g. with `before` or `require`) does not
+  affect the behavior of `defined`.
+
+  If the future parser is in effect, you may also search using types:
+
+      defined(Resource[\'file\',\'/some/file\'])
+      defined(File[\'/some/file\'])
+      defined(Class[\'foo\'])
+
+ - Since 2.7.0
+ - Since 3.6.0 variable reference and future parser types") do |vals|
+    vals = [vals] unless vals.is_a?(Array)
+    vals.any? do |val|
+      case val
+      when String
+        if m = /^\$(.+)$/.match(val)
+          exist?(m[1])
+        else
+          find_resource_type(val) or find_definition(val) or find_hostclass(val)
+        end
+      when Puppet::Resource
+        compiler.findresource(val.type, val.title)
+      else
+        if Puppet[:parser] == 'future'
+          case val
+          when Puppet::Pops::Types::PResourceType
+            raise ArgumentError, "The given resource type is a reference to all kind of types" if val.type_name.nil?
+            if val.title.nil?
+              find_builtin_resource_type(val.type_name) || find_definition(val.type_name)
+            else
+              compiler.findresource(val.type_name, val.title)
+            end
+          when Puppet::Pops::Types::PHostClassType
+            raise  ArgumentError, "The given class type is a reference to all classes" if val.class_name.nil?
+            find_hostclass(val.class_name)
+          end
+        else
+          raise ArgumentError, "Invalid argument of type '#{val.class}' to 'defined'"
+        end
+      end
+    end
+end

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

@@ -0,0 +1,5 @@
+require 'puppet/util/checksums'
+Puppet::Parser::Functions::newfunction(:digest, :type => :rvalue, :arity => 1, :doc => "Returns a hash value from a provided string using the digest_algorithm setting from the Puppet config file.") do |args|
+  algo = Puppet[:digest_algorithm]
+  Puppet::Util::Checksums.method(algo.intern).call args[0]
+end

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

@@ -0,0 +1,48 @@
+Puppet::Parser::Functions::newfunction(
+  :each,
+  :type => :rvalue,
+  :arity => -3,
+  :doc => <<-DOC
+Applies a parameterized block to each element in a sequence of selected entries from the first
+argument and returns the first argument.
+
+This function takes two mandatory arguments: the first should be an Array or a Hash or something that is
+of enumerable type (integer, Integer range, or String), and the second
+a parameterized block as produced by the puppet syntax:
+
+      $a.each |$x| { ... }
+      each($a) |$x| { ... }
+
+When the first argument is an Array (or of enumerable type other than Hash), the parameterized block
+should define one or two block parameters.
+For each application of the block, the next element from the array is selected, and it is passed to
+the block if the block has one parameter. If the block has two parameters, the first is the elements
+index, and the second the value. The index starts from 0.
+
+      $a.each |$index, $value| { ... }
+      each($a) |$index, $value| { ... }
+
+When the first argument is a Hash, the parameterized block should define one or two parameters.
+When one parameter is defined, the iteration is performed with each entry as an array of `[key, value]`,
+and when two parameters are defined the iteration is performed with key and value.
+
+      $a.each |$entry|       { ..."key ${$entry[0]}, value ${$entry[1]}" }
+      $a.each |$key, $value| { ..."key ${key}, value ${value}" }
+
+Example using each:
+
+      [1,2,3].each |$val| { ... }                       # 1, 2, 3
+      [5,6,7].each |$index, $val| { ... }               # (0, 5), (1, 6), (2, 7)
+      {a=>1, b=>2, c=>3}].each |$val| { ... }           # ['a', 1], ['b', 2], ['c', 3]
+      {a=>1, b=>2, c=>3}.each |$key, $val| { ... }      # ('a', 1), ('b', 2), ('c', 3)
+      Integer[ 10, 20 ].each |$index, $value| { ... }   # (0, 10), (1, 11) ...
+      "hello".each |$char| { ... }                      # 'h', 'e', 'l', 'l', 'o'
+      3.each |$number| { ... }                          # 0, 1, 2
+
+- since 3.2 for Array and Hash
+- since 3.5 for other enumerables
+- note requires `parser = future`
+DOC
+) do |args|
+  function_fail(["each() is only available when parser/evaluator future is in effect"])
+end

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

@@ -0,0 +1,45 @@
+Puppet::Parser::Functions::newfunction(:epp, :type => :rvalue, :arity => -2, :doc =>
+"Evaluates an Embedded Puppet Template (EPP) file and returns the rendered text result as a String.
+
+The first argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
+reference, which will load `<TEMPLATE FILE>` from a module's `templates`
+directory. (For example, the reference `apache/vhost.conf.epp` will load the
+file `<MODULES DIRECTORY>/apache/templates/vhost.conf.epp`.)
+
+The second argument is optional; if present, it should be a hash containing parameters for the
+template. (See below.)
+
+EPP supports the following tags:
+
+* `<%= puppet expression %>` - This tag renders the value of the expression it contains.
+* `<% puppet expression(s) %>` - This tag will execute the expression(s) it contains, but renders nothing.
+* `<%# comment %>` - The tag and its content renders nothing.
+* `<%%` or `%%>` - Renders a literal `<%` or `%>` respectively.
+* `<%-` - Same as `<%` but suppresses any leading whitespace.
+* `-%>` - Same as `%>` but suppresses any trailing whitespace on the same line (including line break).
+* `<%- |parameters| -%>` - When placed as the first tag declares the template's parameters.
+
+File based EPP supports the following visibilities of variables in scope:
+
+* Global scope (i.e. top + node scopes) - global scope is always visible
+* Global + all given arguments - if the EPP template does not declare parameters, and arguments are given
+* Global + declared parameters - if the EPP declares parameters, given argument names must match
+
+EPP supports parameters by placing an optional parameter list as the very first element in the EPP. As an example,
+`<%- |$x, $y, $z = 'unicorn'| -%>` when placed first in the EPP text declares that the parameters `x` and `y` must be
+given as template arguments when calling `inline_epp`, and that `z` if not given as a template argument
+defaults to `'unicorn'`. Template parameters are available as variables, e.g.arguments `$x`, `$y` and `$z` in the example.
+Note that `<%-` must be used or any leading whitespace will be interpreted as text
+
+Arguments are passed to the template by calling `epp` with a Hash as the last argument, where parameters
+are bound to values, e.g. `epp('...', {'x'=>10, 'y'=>20})`. Excess arguments may be given
+(i.e. undeclared parameters) only if the EPP templates does not declare any parameters at all.
+Template parameters shadow variables in outer scopes. File based epp does never have access to variables in the
+scope where the `epp` function is called from.
+
+- See function inline_epp for examples of EPP
+- Since 3.5
+- Requires Future Parser") do |args|
+
+  function_fail(["epp() is only available when parser/evaluator future is in effect"])
+end

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

@@ -0,0 +1,153 @@
+require 'csv'
+
+module Puppet::Parser::Functions
+  newfunction(:extlookup,
+  :type => :rvalue,
+  :arity => -2,
+  :doc => "This is a parser function to read data from external files, this version
+uses CSV files but the concept can easily be adjust for databases, yaml
+or any other queryable data source.
+
+The object of this is to make it obvious when it's being used, rather than
+magically loading data in when a module is loaded I prefer to look at the code
+and see statements like:
+
+    $snmp_contact = extlookup(\"snmp_contact\")
+
+The above snippet will load the snmp_contact value from CSV files, this in its
+own is useful but a common construct in puppet manifests is something like this:
+
+    case $domain {
+      \"myclient.com\": { $snmp_contact = \"John Doe <john@myclient.com>\" }
+      default:        { $snmp_contact = \"My Support <support@my.com>\" }
+    }
+
+Over time there will be a lot of this kind of thing spread all over your manifests
+and adding an additional client involves grepping through manifests to find all the
+places where you have constructs like this.
+
+This is a data problem and shouldn't be handled in code, and using this function you
+can do just that.
+
+First you configure it in site.pp:
+
+    $extlookup_datadir = \"/etc/puppet/manifests/extdata\"
+    $extlookup_precedence = [\"%{fqdn}\", \"domain_%{domain}\", \"common\"]
+
+The array tells the code how to resolve values, first it will try to find it in
+web1.myclient.com.csv then in domain_myclient.com.csv and finally in common.csv
+
+Now create the following data files in /etc/puppet/manifests/extdata:
+
+    domain_myclient.com.csv:
+      snmp_contact,John Doe <john@myclient.com>
+      root_contact,support@%{domain}
+      client_trusted_ips,192.168.1.130,192.168.10.0/24
+
+    common.csv:
+      snmp_contact,My Support <support@my.com>
+      root_contact,support@my.com
+
+Now you can replace the case statement with the simple single line to achieve
+the exact same outcome:
+
+    $snmp_contact = extlookup(\"snmp_contact\")
+
+The above code shows some other features, you can use any fact or variable that
+is in scope by simply using %{varname} in your data files, you can return arrays
+by just having multiple values in the csv after the initial variable name.
+
+In the event that a variable is nowhere to be found a critical error will be raised
+that will prevent your manifest from compiling, this is to avoid accidentally putting
+in empty values etc.  You can however specify a default value:
+
+    $ntp_servers = extlookup(\"ntp_servers\", \"1.${country}.pool.ntp.org\")
+
+In this case it will default to \"1.${country}.pool.ntp.org\" if nothing is defined in
+any data file.
+
+You can also specify an additional data file to search first before any others at use
+time, for example:
+
+    $version = extlookup(\"rsyslog_version\", \"present\", \"packages\")
+    package{\"rsyslog\": ensure => $version }
+
+This will look for a version configured in packages.csv and then in the rest as configured
+by $extlookup_precedence if it's not found anywhere it will default to `present`, this kind
+of use case makes puppet a lot nicer for managing large amounts of packages since you do not
+need to edit a load of manifests to do simple things like adjust a desired version number.
+
+Precedence values can have variables embedded in them in the form %{fqdn}, you could for example do:
+
+    $extlookup_precedence = [\"hosts/%{fqdn}\", \"common\"]
+
+This will result in /path/to/extdata/hosts/your.box.com.csv being searched.
+
+This is for back compatibility to interpolate variables with %. % interpolation is a workaround for a problem that has been fixed: Puppet variable interpolation at top scope used to only happen on each run.") do |args|
+
+  key = args[0]
+
+  default  = args[1]
+  datafile = args[2]
+
+  raise ArgumentError, ("extlookup(): wrong number of arguments (#{args.length}; must be <= 3)") if args.length > 3
+
+  extlookup_datadir = undef_as('',self['::extlookup_datadir'])
+
+  extlookup_precedence = undef_as([],self['::extlookup_precedence']).collect { |var| var.gsub(/%\{(.+?)\}/) { self["::#{$1}"] } }
+
+  datafiles = Array.new
+
+  # if we got a custom data file, put it first in the array of search files
+  if datafile != ""
+    datafiles << extlookup_datadir + "/#{datafile}.csv" if Puppet::FileSystem.exist?(extlookup_datadir + "/#{datafile}.csv")
+  end
+
+  extlookup_precedence.each do |d|
+    datafiles << extlookup_datadir + "/#{d}.csv"
+  end
+
+  desired = nil
+
+  datafiles.each do |file|
+    if desired.nil?
+      if Puppet::FileSystem.exist?(file)
+        result = CSV.read(file).find_all do |r|
+          r[0] == key
+        end
+
+        # return just the single result if theres just one,
+        # else take all the fields in the csv and build an array
+        if result.length > 0
+          if result[0].length == 2
+            val = result[0][1].to_s
+
+            # parse %{}'s in the CSV into local variables using the current scope
+            while val =~ /%\{(.+?)\}/
+              val.gsub!(/%\{#{$1}\}/, self[$1])
+            end
+
+            desired = val
+          elsif result[0].length > 1
+            length = result[0].length
+            cells = result[0][1,length]
+
+            # Individual cells in a CSV result are a weird data type and throws
+            # puppets yaml parsing, so just map it all to plain old strings
+            desired = cells.map do |c|
+              # parse %{}'s in the CSV into local variables using the current scope
+              while c =~ /%\{(.+?)\}/
+                c.gsub!(/%\{#{$1}\}/, self[$1])
+              end
+
+              c.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+
+  desired || default or raise Puppet::ParseError, "No match found for '#{key}' in any data file during extlookup()"
+  end
+end