puppet-retrospec 0.7.0 → 0.7.2

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

@@ -0,0 +1,4 @@
+Puppet::Parser::Functions::newfunction(:fail, :arity => -1, :doc => "Fail with a parse error.") do |vals|
+    vals = vals.collect { |s| s.to_s }.join(" ") if vals.is_a? Array
+    raise Puppet::ParseError, vals.to_s
+end

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

@@ -0,0 +1,31 @@
+Puppet::Parser::Functions::newfunction(
+  :file, :arity => -2, :type => :rvalue,
+  :doc => "Loads a file from a module and returns its contents as a string.
+
+  The argument to this function should be a `<MODULE NAME>/<FILE>`
+  reference, which will load `<FILE>` from a module's `files`
+  directory. (For example, the reference `mysql/mysqltuner.pl` will load the
+  file `<MODULES DIRECTORY>/mysql/files/mysqltuner.pl`.)
+
+  This function can also accept:
+
+  * An absolute path, which can load a file from anywhere on disk.
+  * Multiple arguments, which will return the contents of the **first** file
+  found, skipping any files that don't exist.
+  "
+) do |vals|
+    path = nil
+    vals.each do |file|
+      found = Puppet::Parser::Files.find_file(file, compiler.environment)
+      if found && Puppet::FileSystem.exist?(found)
+        path = found
+        break
+      end
+    end
+
+    if path
+      File.read(path)
+    else
+      raise Puppet::ParseError, "Could not find any files from #{vals.join(", ")}"
+    end
+end

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

@@ -0,0 +1,44 @@
+Puppet::Parser::Functions::newfunction(
+  :filter,
+  :arity => -3,
+  :doc => <<-DOC
+ Applies a parameterized block to each element in a sequence of entries from the first
+ argument and returns an array or hash (same type as left operand for array/hash, and array for
+ other enumerable types) with the entries for which the block evaluates to `true`.
+
+ This function takes two mandatory arguments: the first should be an Array, a Hash, or an
+ Enumerable object (integer, Integer range, or String),
+ and the second a parameterized block as produced by the puppet syntax:
+
+       $a.filter |$x| { ... }
+       filter($a) |$x| { ... }
+
+ When the first argument is something other than a Hash, 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 filter with one parameter
+
+       # selects all that end with berry
+       $a = ["raspberry", "blueberry", "orange"]
+       $a.filter |$x| { $x =~ /berry$/ }          # rasberry, blueberry
+
+ If the block defines two parameters, they will be set to `index, value` (with index starting at 0) for all
+ enumerables except Hash, and to `key, value` for a Hash.
+
+Example Using filter with two parameters
+
+     # selects all that end with 'berry' at an even numbered index
+     $a = ["raspberry", "blueberry", "orange"]
+     $a.filter |$index, $x| { $index % 2 == 0 and $x =~ /berry$/ } # raspberry
+
+     # selects all that end with 'berry' and value >= 1
+     $a = {"raspberry"=>0, "blueberry"=>1, "orange"=>1}
+     $a.filter |$key, $x| { $x =~ /berry$/ and $x >= 1 } # blueberry
+
+- since 3.4 for Array and Hash
+- since 3.5 for other enumerables
+- note requires `parser = future`
+DOC
+) do |args|
+  function_fail(["filter() is only available when parser/evaluator future is in effect"])
+end

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

@@ -0,0 +1,21 @@
+require 'digest/md5'
+
+Puppet::Parser::Functions::newfunction(:fqdn_rand, :arity => -2, :type => :rvalue, :doc =>
+  "Usage: `fqdn_rand(MAX, [SEED])`. MAX is required and must be a positive
+  integer; SEED is optional and may be any number or string.
+
+  Generates a random whole number greater than or equal to 0 and less than MAX,
+  combining the `$fqdn` fact and the value of SEED for repeatable randomness.
+  (That is, each node will get a different random number from this function, but
+  a given node's result will be the same every time unless its hostname changes.)
+
+  This function is usually used for spacing out runs of resource-intensive cron
+  tasks that run on many nodes, which could cause a thundering herd or degrade
+  other services if they all fire at once. Adding a SEED can be useful when you
+  have more than one such task and need several unrelated random numbers per
+  node. (For example, `fqdn_rand(30)`, `fqdn_rand(30, 'expensive job 1')`, and
+  `fqdn_rand(30, 'expensive job 2')` will produce totally different numbers.)") do |args|
+    max = args.shift.to_i
+    seed = Digest::MD5.hexdigest([self['::fqdn'],args].join(':')).hex
+    Puppet::Util.deterministic_rand(seed,max)
+end

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

@@ -0,0 +1,37 @@
+# Runs an external command and returns the results
+Puppet::Parser::Functions::newfunction(:generate, :arity => -2, :type => :rvalue,
+    :doc => "Calls an external command on the Puppet master and returns
+    the results of the command.  Any arguments are passed to the external command as
+    arguments.  If the generator does not exit with return code of 0,
+    the generator is considered to have failed and a parse error is
+    thrown.  Generators can only have file separators, alphanumerics, dashes,
+    and periods in them.  This function will attempt to protect you from
+    malicious generator calls (e.g., those with '..' in them), but it can
+    never be entirely safe.  No subshell is used to execute
+    generators, so all shell metacharacters are passed directly to
+    the generator.") do |args|
+
+      raise Puppet::ParseError, "Generators must be fully qualified" unless Puppet::Util.absolute_path?(args[0])
+
+      if Puppet.features.microsoft_windows?
+        valid = args[0] =~ /^[a-z]:(?:[\/\\][-.~\w]+)+$/i
+      else
+        valid = args[0] =~ /^[-\/\w.+]+$/
+      end
+
+      unless valid
+        raise Puppet::ParseError,
+          "Generators can only contain alphanumerics, file separators, and dashes"
+      end
+
+      if args[0] =~ /\.\./
+        raise Puppet::ParseError,
+          "Can not use generators with '..' in them."
+      end
+
+      begin
+        Dir.chdir(File.dirname(args[0])) { Puppet::Util::Execution.execute(args).to_str }
+      rescue Puppet::ExecutionFailure => detail
+        raise Puppet::ParseError, "Failed to execute generator #{args[0]}: #{detail}", detail.backtrace
+      end
+end

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

@@ -0,0 +1,26 @@
+require 'hiera_puppet'
+
+module Puppet::Parser::Functions
+  newfunction(:hiera, :type => :rvalue, :arity => -2, :doc => "Performs a
+  standard priority lookup and returns the most specific value for a given key.
+  The returned value can be data of any type (strings, arrays, or hashes). 
+
+  In addition to the required `key` argument, `hiera` accepts two additional
+  arguments:
+
+  - a `default` argument in the second position, providing a value to be
+    returned in the absence of matches to the `key` argument
+  - an `override` argument in the third position, providing a data source
+    to consult for matching values, even if it would not ordinarily be
+    part of the matched hierarchy. If Hiera doesn't find a matching key
+    in the named override data source, it will continue to search through the
+    rest of the hierarchy.
+
+  More thorough examples of `hiera` are available at:  
+  <http://docs.puppetlabs.com/hiera/1/puppet.html#hiera-lookup-functions>
+  ") do |*args|
+    key, default, override = HieraPuppet.parse_args(args)
+    HieraPuppet.lookup(key, default, self, override, :priority)
+  end
+end
+

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

@@ -0,0 +1,27 @@
+require 'hiera_puppet'
+
+module Puppet::Parser::Functions
+  newfunction(:hiera_array, :type => :rvalue, :arity => -2,:doc => "Returns all 
+  matches throughout the hierarchy --- not just the first match --- as a flattened array of unique values.
+  If any of the matched values are arrays, they're flattened and included in the results.
+  
+  In addition to the required `key` argument, `hiera_array` accepts two additional 
+  arguments:
+  
+  - a `default` argument in the second position, providing a string or array to be returned 
+    in the absence of  matches to the `key` argument
+  - an `override` argument in the third position, providing a data source to consult for 
+    matching values, even if it would not ordinarily be part of the matched hierarchy. 
+    If Hiera doesn't find a matching key in the named override data source, it will 
+    continue to search through the rest of the hierarchy.
+    
+  If any matched value is a hash, puppet will raise a type mismatch error.
+
+  More thorough examples of `hiera` are available at:  
+  <http://docs.puppetlabs.com/hiera/1/puppet.html#hiera-lookup-functions>
+  ") do |*args|
+    key, default, override = HieraPuppet.parse_args(args)
+    HieraPuppet.lookup(key, default, self, override, :array)
+  end
+end
+

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

@@ -0,0 +1,29 @@
+require 'hiera_puppet'
+
+module Puppet::Parser::Functions
+  newfunction(:hiera_hash, :type => :rvalue, :arity => -2, :doc => 
+  "Returns a merged hash of matches from throughout the hierarchy. In cases where two or 
+  more hashes share keys, the hierarchy  order determines which key/value pair will be 
+  used in the returned hash, with the pair in the highest priority data source winning.
+  
+  In addition to the required `key` argument, `hiera_hash` accepts two additional 
+  arguments:
+  
+  - a `default` argument in the second position, providing a  hash to be returned in the 
+  absence of any matches for the `key` argument
+  - an `override` argument in the third position, providing  a data source to insert at 
+  the top of the hierarchy, even if it would not ordinarily match during a Hiera data 
+  source lookup. If Hiera doesn't find a match in the named override data source, it will 
+  continue to search through the rest of the hierarchy.
+    
+  `hiera_hash` expects that all values returned will be hashes. If any of the values 
+  found in the data sources are strings or arrays, puppet will raise a type mismatch error.
+
+  More thorough examples of `hiera_hash` are available at:  
+  <http://docs.puppetlabs.com/hiera/1/puppet.html#hiera-lookup-functions>
+  ") do |*args|
+    key, default, override = HieraPuppet.parse_args(args)
+    HieraPuppet.lookup(key, default, self, override, :hash)
+  end
+end
+

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

@@ -0,0 +1,44 @@
+require 'hiera_puppet'
+
+module Puppet::Parser::Functions
+  newfunction(:hiera_include, :arity => -2, :doc => "Assigns classes to a node
+  using an array merge lookup that retrieves the value for a user-specified key
+  from a Hiera data source.
+
+  To use `hiera_include`, the following configuration is required:
+
+  - A key name to use for classes, e.g. `classes`.
+  - A line in the puppet `sites.pp` file (e.g. `/etc/puppet/manifests/sites.pp`)
+    reading `hiera_include('classes')`. Note that this line must be outside any node
+    definition and below any top-scope variables in use for Hiera lookups.
+  - Class keys in the appropriate data sources. In a data source keyed to a node's role,
+    one might have:
+
+            ---
+            classes:
+              - apache
+              - apache::passenger
+
+  In addition to the required `key` argument, `hiera_include` accepts two additional
+  arguments:
+
+  - a `default` argument in the second position, providing an array to be returned
+    in the absence of matches to the `key` argument
+  - an `override` argument in the third position, providing a data source to consult
+    for matching values, even if it would not ordinarily be part of the matched hierarchy.
+    If Hiera doesn't find a matching key in the named override data source, it will continue
+    to search through the rest of the hierarchy.
+
+  More thorough examples of `hiera_include` are available at:
+  <http://docs.puppetlabs.com/hiera/1/puppet.html#hiera-lookup-functions>
+  ") do |*args|
+    key, default, override = HieraPuppet.parse_args(args)
+    if answer = HieraPuppet.lookup(key, default, self, override, :array)
+      method = Puppet::Parser::Functions.function(:include)
+      send(method, [answer])
+    else
+      raise Puppet::ParseError, "Could not find data item #{key}"
+    end
+  end
+end
+

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

@@ -0,0 +1,35 @@
+# Include the specified classes
+Puppet::Parser::Functions::newfunction(:include, :arity => -2, :doc =>
+"Declares one or more classes, causing the resources in them to be
+evaluated and added to the catalog. Accepts a class name, an array of class
+names, or a comma-separated list of class names.
+
+The `include` function can be used multiple times on the same class and will
+only declare a given class once. If a class declared with `include` has any
+parameters, Puppet will automatically look up values for them in Hiera, using
+`<class name>::<parameter name>` as the lookup key.
+
+Contrast this behavior with resource-like class declarations
+(`class {'name': parameter => 'value',}`), which must be used in only one place
+per class and can directly set parameters. You should avoid using both `include`
+and resource-like declarations with the same class.
+
+The `include` function does not cause classes to be contained in the class
+where they are declared. For that, see the `contain` function. It also
+does not create a dependency relationship between the declared class and the
+surrounding class; for that, see the `require` function.
+
+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|
+
+  # Unify call patterns (if called with nested arrays), make names absolute if
+  # wanted and evaluate the classes
+  compiler.evaluate_classes(
+  transform_and_assert_classnames(
+      vals.is_a?(Array) ? vals.flatten : [vals]),
+      self, false)
+end

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

@@ -0,0 +1,76 @@
+Puppet::Parser::Functions::newfunction(:inline_epp, :type => :rvalue, :arity => -2, :doc =>
+"Evaluates an Embedded Puppet Template (EPP) string and returns the rendered text result as a String.
+
+EPP support 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.
+
+Inline EPP supports the following visibilities of variables in scope which depends on how EPP parameters
+are used - see further below:
+
+* Global scope (i.e. top + node scopes) - global scope is always visible
+* Global + Enclosing scope - if the EPP template does not declare parameters, and no arguments are given
+* 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 `inline_epp` with a Hash as the last argument, where parameters
+are bound to values, e.g. `inline_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.
+
+Note: An inline template is best stated using a single-quoted string, or a heredoc since a double-quoted string
+is subject to expression interpolation before the string is parsed as an EPP template. Here are examples
+(using heredoc to define the EPP text):
+
+    # produces 'Hello local variable world!'
+    $x ='local variable'
+    inline_epptemplate(@(END:epp))
+    <%- |$x| -%>
+    Hello <%= $x %> world!
+    END
+
+    # produces 'Hello given argument world!'
+    $x ='local variable world'
+    inline_epptemplate(@(END:epp), { x =>'given argument'})
+    <%- |$x| -%>
+    Hello <%= $x %> world!
+    END
+
+    # produces 'Hello given argument world!'
+    $x ='local variable world'
+    inline_epptemplate(@(END:epp), { x =>'given argument'})
+    <%- |$x| -%>
+    Hello <%= $x %>!
+    END
+
+    # results in error, missing value for y
+    $x ='local variable world'
+    inline_epptemplate(@(END:epp), { x =>'given argument'})
+    <%- |$x, $y| -%>
+    Hello <%= $x %>!
+    END
+
+    # Produces 'Hello given argument planet'
+    $x ='local variable world'
+    inline_epptemplate(@(END:epp), { x =>'given argument'})
+    <%- |$x, $y=planet| -%>
+    Hello <%= $x %> <%= $y %>!
+    END
+
+- Since 3.5
+- Requires Future Parser") do |arguments|
+
+  function_fail(["inline_epp() is only available when parser/evaluator future is in effect"])
+end

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

@@ -0,0 +1,21 @@
+Puppet::Parser::Functions::newfunction(:inline_template, :type => :rvalue, :arity => -2, :doc =>
+  "Evaluate a template string and return its value.  See
+  [the templating docs](http://docs.puppetlabs.com/guides/templating.html) for
+  more information.  Note that if multiple template strings are specified, their
+  output is all concatenated and returned as the output of the function.") do |vals|
+
+  require 'erb'
+
+    vals.collect do |string|
+      # Use a wrapper, so the template can't get access to the full
+      # Scope object.
+
+      wrapper = Puppet::Parser::TemplateWrapper.new(self)
+      begin
+        wrapper.result(string)
+      rescue => detail
+        raise Puppet::ParseError,
+          "Failed to parse inline template: #{detail}", detail.backtrace
+      end
+    end.join("")
+end

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

@@ -0,0 +1,144 @@
+Puppet::Parser::Functions.newfunction(:lookup, :type => :rvalue, :arity => -2, :doc => <<-'ENDHEREDOC') do |args|
+Looks up data defined using Puppet Bindings and Hiera.
+The function is callable with one to three arguments and optionally with a code block to further process the result.
+
+The lookup function can be called in one of these ways:
+
+    lookup(name)
+    lookup(name, type)
+    lookup(name, type, default)
+    lookup(options_hash)
+    lookup(name, options_hash)
+
+The function may optionally be called with a code block / lambda with the following signatures:
+
+    lookup(...) |$result| { ... }
+    lookup(...) |$name, $result| { ... }
+    lookup(...) |$name, $result, $default| { ... }
+
+The longer signatures are useful when the block needs to raise an error (it can report the name), or
+if it needs to know if the given default value was selected.
+
+The code block receives the following three arguments:
+
+* The `$name` is the last name that was looked up (*the* name if only one name was looked up)
+* The `$result` is the looked up value (or the default value if not found).
+* The `$default` is the given default value (`undef` if not given).
+
+The block, if present, is called with the result from the lookup. The value produced by the block is also what is
+produced by the `lookup` function.
+When a block is used, it is the users responsibility to call `error` if the result does not meet additional
+criteria, or if an undef value is not acceptable. If a value is not found, and a default has been
+specified, the default value is given to the block.
+
+The content of the options hash is:
+
+* `name` - The name or array of names to lookup (first found is returned)
+* `type` - The type to assert (a Type or a type specification in string form)
+* `default` - The default value if there was no value found (must comply with the data type)
+* `accept_undef` - (default `false`) An `undef` result is accepted if this options is set to `true`.
+* `override` - a hash with map from names to values that are used instead of the underlying bindings. If the name
+  is found here it wins. Defaults to an empty hash.
+* `extra` - a hash with map from names to values that are used as a last resort to obtain a value. Defaults to an
+  empty hash.
+
+When the call is on the form `lookup(name, options_hash)`, or `lookup(name, type, options_hash)`, the given name
+argument wins over the `options_hash['name']`.
+
+The search order is `override` (if given), then `binder`, then `hiera` and finally `extra` (if given). The first to produce
+a value other than undef for a given name wins.
+
+The type specification is one of:
+
+  * A type in the Puppet Type System, e.g.:
+    * `Integer`, an integral value with optional range e.g.:
+      * `Integer[0, default]` - 0 or positive
+      * `Integer[default, -1]` - negative, 
+      * `Integer[1,100]` - value between 1 and 100 inclusive
+    * `String`- any string
+    * `Float` - floating point number (same signature as for Integer for `Integer` ranges)
+    * `Boolean` - true of false (strict)
+    * `Array` - an array (of Data by default), or parameterized as `Array[<element_type>]`, where
+      `<element_type>` is the expected type of elements
+    * `Hash`,  - a hash (of default `Literal` keys and `Data` values), or parameterized as
+      `Hash[<value_type>]`, `Hash[<key_type>, <value_type>]`, where `<key_type>`, and
+      `<value_type>` are the types of the keys and values respectively
+      (key is `Literal` by default).
+    * `Data` - abstract type representing any `Literal`, `Array[Data]`, or `Hash[Literal, Data]`
+    * `Pattern[<p1>, <p2>, ..., <pn>]` - an enumeration of valid patterns (one or more) where
+       a pattern is a regular expression string or regular expression,
+       e.g. `Pattern['.com$', '.net$']`, `Pattern[/[a-z]+[0-9]+/]` 
+    * `Enum[<s1>, <s2>, ..., <sn>]`, - an enumeration of exact string values (one or more)
+       e.g. `Enum[blue, red, green]`.
+    * `Variant[<t1>, <t2>,...<tn>]` - matches one of the listed types (at least one must be given)
+      e.g. `Variant[Integer[8000,8999], Integer[20000, 99999]]` to accept a value in either range
+    * `Regexp`- a regular expression (i.e. the result is a regular expression, not a string
+       matching a regular expression).
+  * A string containing a type description - one of the types as shown above but in string form.
+
+If the function is called without specifying a default value, and nothing is bound to the given name 
+an error is raised unless the option `accept_undef` is true. If a block is given it must produce an acceptable
+value (or call `error`). If the block does not produce an acceptable value an error is
+raised.
+
+Examples:
+
+When called with one argument; **the name**, it
+returns the bound value with the given name after having  asserted it has the default datatype `Data`:
+
+    lookup('the_name')
+
+When called with two arguments; **the name**, and **the expected type**, it
+returns the bound value with the given name after having asserted it has the given data
+type ('String' in the example):
+
+    lookup('the_name', 'String') # 3.x
+    lookup('the_name', String)   # parser future
+
+When called with three arguments, **the name**, the **expected type**, and a **default**, it
+returns the bound value with the given name, or the default after having asserted the value
+has the given data type (`String` in the example above):
+
+    lookup('the_name', 'String', 'Fred') # 3x
+    lookup('the_name', String, 'Fred')   # parser future
+
+Using a lambda to process the looked up result - asserting that it starts with an upper case letter:
+
+    # only with parser future
+    lookup('the_size', Integer[1,100]) |$result| {
+      if $large_value_allowed and $result > 10
+        { error 'Values larger than 10 are not allowed'}
+      $result
+    }
+
+Including the name in the error
+
+    # only with parser future
+    lookup('the_size', Integer[1,100]) |$name, $result| {
+      if $large_value_allowed and $result > 10
+        { error 'The bound value for '${name}' can not be larger than 10 in this configuration'}
+      $result
+    }
+
+When using a block, the value it produces is also asserted against the given type, and it may not be
+`undef` unless the option `'accept_undef'` is `true`.
+
+All options work as the corresponding (direct) argument. The `first_found` option and
+`accept_undef` are however only available as options.
+
+Using first_found semantics option to return the first name that has a bound value:
+
+    lookup(['apache::port', 'nginx::port'], 'Integer', 80)
+
+If you want to make lookup return undef when no value was found instead of raising an error:
+
+     $are_you_there = lookup('peekaboo', { accept_undef => true} )
+     $are_you_there = lookup('peekaboo', { accept_undef => true}) |$result| { $result }
+
+ENDHEREDOC
+
+  unless Puppet[:binder] || Puppet[:parser] == 'future'
+    raise Puppet::ParseError, "The lookup function is only available with settings --binder true, or --parser future"
+  end
+  Puppet::Pops::Binder::Lookup.lookup(self, args)
+end