puppet 4.0.0 → 5.0.0

data/lib/puppet/parser/functions/defined.rb

@@ -1,70 +1,107 @@
-# 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 defined, 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 evaluation 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 evaluation order only, and ordering of
-  resources in the configuration graph (e.g. with `before` or `require`) does not
-  affect the behavior of `defined`.
-
-  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
- - Since 4.0.0") 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) || find_definition(val) || find_hostclass(val)
-      end
-    when Puppet::Resource
-      compiler.findresource(val.type, val.title)
-    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)
-    else
-      raise ArgumentError, "Invalid argument of type '#{val.class}' to 'defined'"
-    end
-  end
+Puppet::Parser::Functions::newfunction(
+  :defined,
+  :type => :rvalue,
+  :arity => -2,
+  :doc => <<DOC
+Determines whether a given class or resource type is defined and returns a Boolean
+value. You can also use `defined` to determine whether a specific resource is defined,
+or whether a variable has a value (including `undef`, as opposed to the variable never
+being declared or assigned).
+
+This function takes at least one string argument, which can be a class name, type name,
+resource reference, or variable reference of the form `'$name'`.
+
+The `defined` function checks both native and defined types, including types
+provided by modules. Types and classes are matched by their names. The function matches
+resource declarations by using resource references.
+
+**Examples**: Different types of `defined` function matches
+
+~~~ puppet
+# Matching resource types
+defined("file")
+defined("customtype")
+
+# Matching defines and classes
+defined("foo")
+defined("foo::bar")
+
+# Matching variables
+defined('$name')
+
+# Matching declared resources
+defined(File['/tmp/file'])
+~~~
+
+Puppet depends on the configuration's evaluation order when checking whether a resource
+is declared.
+
+**Example**: Importance of evaluation order when using `defined`
+
+~~~ puppet
+# Assign values to $is_defined_before and $is_defined_after using identical `defined`
+# functions.
+
+$is_defined_before = defined(File['/tmp/file'])
+
+file { "/tmp/file":
+  ensure => present,
+}
+
+$is_defined_after = defined(File['/tmp/file'])
+
+# $is_defined_before returns false, but $is_defined_after returns true.
+~~~
+
+This order requirement only refers to evaluation order. The order of resources in the
+configuration graph (e.g. with `before` or `require`) does not affect the `defined`
+function's behavior.
+
+> **Warning:** Avoid relying on the result of the `defined` function in modules, as you
+> might not be able to guarantee the evaluation order well enough to produce consistent
+> results. This can cause other code that relies on the function's result to behave
+> inconsistently or fail.
+
+If you pass more than one argument to `defined`, the function returns `true` if _any_
+of the arguments are defined. You can also match resources by type, allowing you to
+match conditions of different levels of specificity, such as whether a specific resource
+is of a specific data type.
+
+**Example**: Matching multiple resources and resources by different types with `defined`
+
+~~~ puppet
+file { "/tmp/file1":
+  ensure => file,
+}
+
+$tmp_file = file { "/tmp/file2":
+  ensure => file,
+}
+
+# Each of these statements return `true` ...
+defined(File['/tmp/file1'])
+defined(File['/tmp/file1'],File['/tmp/file2'])
+defined(File['/tmp/file1'],File['/tmp/file2'],File['/tmp/file3'])
+# ... but this returns `false`.
+defined(File['/tmp/file3'])
+
+# Each of these statements returns `true` ...
+defined(Type[Resource['file','/tmp/file2']])
+defined(Resource['file','/tmp/file2'])
+defined(File['/tmp/file2'])
+defined('$tmp_file')
+# ... but each of these returns `false`.
+defined(Type[Resource['exec','/tmp/file2']])
+defined(Resource['exec','/tmp/file2'])
+defined(File['/tmp/file3'])
+defined('$tmp_file2')
+~~~
+
+- Since 2.7.0
+- Since 3.6.0 variable reference and future parser types
+- Since 3.8.1 type specific requests with future parser
+- Since 4.0.0 includes all future parser features
+DOC
+) do |vals|
+  Error.is4x('defined')
 end

data/lib/puppet/parser/functions/dig.rb

@@ -0,0 +1,29 @@
+Puppet::Parser::Functions::newfunction(
+  :dig,
+  :type => :rvalue,
+  :arity => -1,
+  :doc => <<-DOC
+Returns a value for a sequence of given keys/indexes into a structure.
+This function is used to "dig into" a complex data structure by
+using a sequence of keys / indexes to access a value from which
+the next key/index is accessed recursively.
+
+The first encountered `undef` value or key stops the "dig" and `undef` is returned.
+
+An error is raised if an attempt is made to "dig" into
+something other than an `undef` (which immediately returns `undef`), an `Array` or a `Hash`.
+
+**Example:** Using `dig`
+
+```puppet
+$data = {a => { b => [{x => 10, y => 20}, {x => 100, y => 200}]}}
+notice $data.dig(a, b, 1, x)
+```
+
+Would notice the value 100.
+
+* Since 4.5.0
+DOC
+) do |args|
+  Error.is4x('dig')
+end

data/lib/puppet/parser/functions/each.rb

@@ -3,44 +3,102 @@ Puppet::Parser::Functions::newfunction(
   :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.
+Runs a [lambda](http://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+repeatedly using each value in a data structure, then returns the values unchanged.
 
-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:
+This function takes two mandatory arguments, in this order:
 
-      $a.each |$x| { ... }
-      each($a) |$x| { ... }
+1. An array or hash the function will iterate over.
+2. A lambda, which the function calls for each element in the first argument. It can
+request one or two parameters.
 
-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.
+**Example**: Using the `each` function
 
-      $a.each |$index, $value| { ... }
-      each($a) |$index, $value| { ... }
+`$data.each |$parameter| { <PUPPET CODE BLOCK> }`
 
-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.
+or
 
-      $a.each |$entry|       { ..."key ${$entry[0]}, value ${$entry[1]}" }
-      $a.each |$key, $value| { ..."key ${key}, value ${value}" }
+`each($data) |$parameter| { <PUPPET CODE BLOCK> }`
 
-Example using each:
+When the first argument (`$data` in the above example) is an array, Puppet passes each
+value in turn to the lambda, then returns the original values.
 
-      [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
+**Example**: Using the `each` function with an array and a one-parameter lambda
+
+~~~ puppet
+# For the array $data, run a lambda that creates a resource for each item.
+$data = ["routers", "servers", "workstations"]
+$data.each |$item| {
+ notify { $item:
+   message => $item
+ }
+}
+# Puppet creates one resource for each of the three items in $data. Each resource is
+# named after the item's value and uses the item's value in a parameter.
+~~~
+
+When the first argument is a hash, Puppet passes each key and value pair to the lambda
+as an array in the form `[key, value]` and returns the original hash.
+
+**Example**: Using the `each` function with a hash and a one-parameter lambda
+
+~~~ puppet
+# For the hash $data, run a lambda using each item as a key-value array that creates a
+# resource for each item.
+$data = {"rtr" => "Router", "svr" => "Server", "wks" => "Workstation"}
+$data.each |$items| {
+ notify { $items[0]:
+   message => $items[1]
+ }
+}
+# Puppet creates one resource for each of the three items in $data, each named after the
+# item's key and containing a parameter using the item's value.
+~~~
+
+When the first argument is an array and the lambda has two parameters, Puppet passes the
+array's indexes (enumerated from 0) in the first parameter and its values in the second
+parameter.
+
+**Example**: Using the `each` function with an array and a two-parameter lambda
+
+~~~ puppet
+# For the array $data, run a lambda using each item's index and value that creates a
+# resource for each item.
+$data = ["routers", "servers", "workstations"]
+$data.each |$index, $value| {
+ notify { $value:
+   message => $index
+ }
+}
+# Puppet creates one resource for each of the three items in $data, each named after the
+# item's value and containing a parameter using the item's index.
+~~~
+
+When the first argument is a hash, Puppet passes its keys to the first parameter and its
+values to the second parameter.
+
+**Example**: Using the `each` function with a hash and a two-parameter lambda
+
+~~~ puppet
+# For the hash $data, run a lambda using each item's key and value to create a resource
+# for each item.
+$data = {"rtr" => "Router", "svr" => "Server", "wks" => "Workstation"}
+$data.each |$key, $value| {
+ notify { $key:
+   message => $value
+ }
+}
+# Puppet creates one resource for each of the three items in $data, each named after the
+# item's key and containing a parameter using the item's value.
+~~~
+
+For an example that demonstrates how to create multiple `file` resources using `each`,
+see the Puppet
+[iteration](https://docs.puppetlabs.com/puppet/latest/reference/lang_iteration.html)
+documentation.
 
 - Since 4.0.0
 DOC
 ) do |args|
-  function_fail(["each() is only available when parser/evaluator future is in effect"])
+  Error.is4x('each')
 end

data/lib/puppet/parser/functions/epp.rb

@@ -1,44 +1,36 @@
 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.
+"Evaluates an Embedded Puppet (EPP) template file and returns the rendered text
+result as a String.
+
+`epp('<MODULE NAME>/<TEMPLATE FILE>', <PARAMETER HASH>)`
 
 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
+reference, which loads `<TEMPLATE FILE>` from `<MODULE NAME>`'s `templates`
+directory. In most cases, the last argument is optional; if used, it should be a
+[hash](/puppet/latest/reference/lang_data_hash.html) that contains parameters to
+pass to the template.
+
+- See the [template](/puppet/latest/reference/lang_template.html) documentation
+for general template usage information.
+- See the [EPP syntax](/puppet/latest/reference/lang_template_epp.html)
+documentation for examples of EPP.
+
+For example, to call the apache module's `templates/vhost/_docroot.epp`
+template and pass the `docroot` and `virtual_docroot` parameters, call the `epp`
+function like this:
+
+`epp('apache/vhost/_docroot.epp', { 'docroot' => '/var/www/html',
+'virtual_docroot' => '/var/www/example' })`
+
+Puppet produces a syntax error if you pass more parameters than are declared in
+the template's parameter tag. When passing parameters to a template that
+contains a parameter tag, use the same names as the tag's declared parameters.
+
+Parameters are required only if they are declared in the called template's
+parameter tag without default values. Puppet produces an error if the `epp`
+function fails to pass any required parameter.
+
 - Since 4.0.0") do |args|
 
-  function_fail(["epp() is only available when parser/evaluator future is in effect"])
+  Error.is4x('epp')
 end

data/lib/puppet/parser/functions/file.rb

@@ -1,3 +1,5 @@
+require 'puppet/file_system'
+
 Puppet::Parser::Functions::newfunction(
   :file, :arity => -2, :type => :rvalue,
   :doc => "Loads a file from a module and returns its contents as a string.
@@ -24,8 +26,8 @@ Puppet::Parser::Functions::newfunction(
     end
 
     if path
-      File.read(path)
+      Puppet::FileSystem.read_preserve_line_endings(path)
     else
-      raise Puppet::ParseError, "Could not find any files from #{vals.join(", ")}"
+      raise Puppet::ParseError, _("Could not find any files from %{values}") % { values: vals.join(", ") }
     end
 end

data/lib/puppet/parser/functions/filter.rb

@@ -1,42 +1,78 @@
 Puppet::Parser::Functions::newfunction(
   :filter,
+  :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 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`.
+Applies a [lambda](http://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+to every value in a data structure and returns an array or hash containing any elements
+for which the lambda 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:
+This function takes two mandatory arguments, in this order:
 
-       $a.filter |$x| { ... }
-       filter($a) |$x| { ... }
+1. An array or hash the function will iterate over.
+2. A lambda, which the function calls for each element in the first argument. It can
+request one or two parameters.
 
- 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 the `filter` function
 
- Example Using filter with one parameter
+`$filtered_data = $data.filter |$parameter| { <PUPPET CODE BLOCK> }`
 
-       # selects all that end with berry
-       $a = ["raspberry", "blueberry", "orange"]
-       $a.filter |$x| { $x =~ /berry$/ }          # rasberry, blueberry
+or
 
- 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.
+`$filtered_data = filter($data) |$parameter| { <PUPPET CODE BLOCK> }`
 
-Example Using filter with two parameters
+When the first argument (`$data` in the above example) is an array, Puppet passes each
+value in turn to the lambda and returns an array containing the results.
 
-     # 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
+**Example**: Using the `filter` function with an array and a one-parameter lambda
 
-     # 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
+~~~ puppet
+# For the array $data, return an array containing the values that end with "berry"
+$data = ["orange", "blueberry", "raspberry"]
+$filtered_data = $data.filter |$items| { $items =~ /berry$/ }
+# $filtered_data = [blueberry, raspberry]
+~~~
+
+When the first argument is a hash, Puppet passes each key and value pair to the lambda
+as an array in the form `[key, value]` and returns a hash containing the results.
+
+**Example**: Using the `filter` function with a hash and a one-parameter lambda
+
+~~~ puppet
+# For the hash $data, return a hash containing all values of keys that end with "berry"
+$data = { "orange" => 0, "blueberry" => 1, "raspberry" => 2 }
+$filtered_data = $data.filter |$items| { $items[0] =~ /berry$/ }
+# $filtered_data = {blueberry => 1, raspberry => 2}
+
+When the first argument is an array and the lambda has two parameters, Puppet passes the
+array's indexes (enumerated from 0) in the first parameter and its values in the second
+parameter.
+
+**Example**: Using the `filter` function with an array and a two-parameter lambda
+
+~~~ puppet
+# For the array $data, return an array of all keys that both end with "berry" and have
+# an even-numbered index
+$data = ["orange", "blueberry", "raspberry"]
+$filtered_data = $data.filter |$indexes, $values| { $indexes % 2 == 0 and $values =~ /berry$/ }
+# $filtered_data = [raspberry]
+~~~
+
+When the first argument is a hash, Puppet passes its keys to the first parameter and its
+values to the second parameter.
+
+**Example**: Using the `filter` function with a hash and a two-parameter lambda
+
+~~~ puppet
+# For the hash $data, return a hash of all keys that both end with "berry" and have
+# values less than or equal to 1
+$data = { "orange" => 0, "blueberry" => 1, "raspberry" => 2 }
+$filtered_data = $data.filter |$keys, $values| { $keys =~ /berry$/ and $values <= 1 }
+# $filtered_data = {blueberry => 1}
+~~~
 
 - Since 4.0.0
 DOC
 ) do |args|
-  function_fail(["filter() is only available when parser/evaluator future is in effect"])
+  Error.is4x('filter')
 end

data/lib/puppet/parser/functions/find_file.rb

@@ -0,0 +1,28 @@
+Puppet::Parser::Functions::newfunction(
+  :find_file,
+  :type => :rvalue,
+  :arity => -2,
+:doc => <<-DOC
+Finds an existing file from a module and returns its path.
+
+The argument to this function should be a String as a `<MODULE NAME>/<FILE>`
+reference, which will search for `<FILE>` relative to a module's `files`
+directory. (For example, the reference `mysql/mysqltuner.pl` will search for the
+file `<MODULES DIRECTORY>/mysql/files/mysqltuner.pl`.)
+
+This function can also accept:
+
+* An absolute String path, which will check for the existence of a file from anywhere on disk.
+* Multiple String arguments, which will return the path of the **first** file
+  found, skipping non existing files.
+* An array of string paths, which will return the path of the **first** file
+  found from the given paths in the array, skipping non existing files.
+
+The function returns `undef` if none of the given paths were found
+
+- since 4.8.0
+DOC
+) do |args|
+  Error.is4x('find_file')
+end
+

data/lib/puppet/parser/functions/fqdn_rand.rb

@@ -4,7 +4,7 @@ Puppet::Parser::Functions::newfunction(:fqdn_rand, :arity => -2, :type => :rvalu
   "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,
+  Generates a random Integer 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.)
@@ -16,6 +16,6 @@ Puppet::Parser::Functions::newfunction(:fqdn_rand, :arity => -2, :type => :rvalu
   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)
+    seed = Digest::MD5.hexdigest([self['::fqdn'],max,args].join(':')).hex
+    Puppet::Util.deterministic_rand_int(seed,max)
 end

data/lib/puppet/parser/functions/generate.rb

@@ -11,7 +11,8 @@ Puppet::Parser::Functions::newfunction(:generate, :arity => -2, :type => :rvalue
     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])
+      #TRANSLATORS "fully qualified" refers to a fully qualified file system path
+      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
@@ -21,17 +22,17 @@ Puppet::Parser::Functions::newfunction(:generate, :arity => -2, :type => :rvalue
 
       unless valid
         raise Puppet::ParseError,
-          "Generators can only contain alphanumerics, file separators, and dashes"
+          _("Generators can only contain alphanumerics, file separators, and dashes")
       end
 
       if args[0] =~ /\.\./
         raise Puppet::ParseError,
-          "Can not use generators with '..' in them."
+          _("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
+        raise Puppet::ParseError, _("Failed to execute generator %{generator}: %{detail}") % { generator: args[0], detail: detail }, detail.backtrace
       end
 end