puppet 6.0.5-x64-mingw32 → 8.8.1-x64-mingw32

data/lib/puppet/parser/files.rb

@@ -1,5 +1,6 @@
-module Puppet::Parser::Files
+# frozen_string_literal: true
 
+module Puppet::Parser::Files
   module_function
 
   # Return a list of manifests as absolute filenames matching the given
@@ -14,7 +15,8 @@ module Puppet::Parser::Files
   def find_manifests_in_modules(pattern, environment)
     module_name, file_pattern = split_file_path(pattern)
 
-    if mod = environment.module(module_name)
+    mod = environment.module(module_name)
+    if mod
       [mod.name, mod.match_manifests(file_pattern)]
     else
       [nil, []]
@@ -27,9 +29,10 @@ module Puppet::Parser::Files
   #   * modulename/filename selector: a file is found in the file directory
   #     of the named module.
   #
-  # In the second case a nil is returned if there isn't a file found. In the
-  # first case (absolute path), there is no existence check done and so the
-  # path will be returned even if there isn't a file available.
+  # The check for file existence is performed on the node compiling the
+  # manifest. A node running "puppet apply" compiles its own manifest, but
+  # a node running "puppet agent" depends on the configured puppetserver
+  # for compiling. In either case, a nil is returned if no file is found.
   #
   # @param template [String] the file selector
   # @param environment [Puppet::Node::Environment] the environment in which to search
@@ -37,7 +40,7 @@ module Puppet::Parser::Files
   #
   # @api private
   def find_file(file, environment)
-    find_in_module(file, environment) do |mod,module_file|
+    find_in_module(file, environment) do |mod, module_file|
       mod.file(module_file)
     end
   end
@@ -58,7 +61,7 @@ module Puppet::Parser::Files
   #
   # @api private
   def find_template(template, environment)
-    find_in_module(template, environment) do |mod,template_file|
+    find_in_module(template, environment) do |mod, template_file|
       mod.template(template_file)
     end
   end

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

@@ -1,60 +1,62 @@
-Puppet::Parser::Functions::newfunction(
+# frozen_string_literal: true
+
+Puppet::Parser::Functions.newfunction(
   :assert_type,
   :type => :rvalue,
   :arity => -3,
-  :doc => <<DOC
-Returns the given value if it is of the given
-[data type](https://puppet.com/docs/puppet/latest/lang_data.html), or
-otherwise either raises an error or executes an optional two-parameter
-[lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html).
+  :doc => <<~DOC
+    Returns the given value if it is of the given
+    [data type](https://puppet.com/docs/puppet/latest/lang_data.html), or
+    otherwise either raises an error or executes an optional two-parameter
+    [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html).
 
-The function takes two mandatory arguments, in this order:
+    The function takes two mandatory arguments, in this order:
 
-1. The expected data type.
-2. A value to compare against the expected data type.
+    1. The expected data type.
+    2. A value to compare against the expected data type.
 
-**Example**: Using `assert_type`
+    **Example**: Using `assert_type`
 
-~~~ puppet
-$raw_username = 'Amy Berry'
+    ~~~ puppet
+    $raw_username = 'Amy Berry'
 
-# Assert that $raw_username is a non-empty string and assign it to $valid_username.
-$valid_username = assert_type(String[1], $raw_username)
+    # Assert that $raw_username is a non-empty string and assign it to $valid_username.
+    $valid_username = assert_type(String[1], $raw_username)
 
-# $valid_username contains "Amy Berry".
-# If $raw_username was an empty string or a different data type, the Puppet run would
-# fail with an "Expected type does not match actual" error.
-~~~
+    # $valid_username contains "Amy Berry".
+    # If $raw_username was an empty string or a different data type, the Puppet run would
+    # fail with an "Expected type does not match actual" error.
+    ~~~
 
-You can use an optional lambda to provide enhanced feedback. The lambda takes two
-mandatory parameters, in this order:
+    You can use an optional lambda to provide enhanced feedback. The lambda takes two
+    mandatory parameters, in this order:
 
-1. The expected data type as described in the function's first argument.
-2. The actual data type of the value.
+    1. The expected data type as described in the function's first argument.
+    2. The actual data type of the value.
 
-**Example**: Using `assert_type` with a warning and default value
+    **Example**: Using `assert_type` with a warning and default value
 
-~~~ puppet
-$raw_username = 'Amy Berry'
+    ~~~ puppet
+    $raw_username = 'Amy Berry'
 
-# Assert that $raw_username is a non-empty string and assign it to $valid_username.
-# If it isn't, output a warning describing the problem and use a default value.
-$valid_username = assert_type(String[1], $raw_username) |$expected, $actual| {
-  warning( "The username should be \'${expected}\', not \'${actual}\'. Using 'anonymous'." )
-  'anonymous'
-}
+    # Assert that $raw_username is a non-empty string and assign it to $valid_username.
+    # If it isn't, output a warning describing the problem and use a default value.
+    $valid_username = assert_type(String[1], $raw_username) |$expected, $actual| {
+      warning( "The username should be \'${expected}\', not \'${actual}\'. Using 'anonymous'." )
+      'anonymous'
+    }
 
-# $valid_username contains "Amy Berry".
-# If $raw_username was an empty string, the Puppet run would set $valid_username to
-# "anonymous" and output a warning: "The username should be 'String[1, default]', not
-# 'String[0, 0]'. Using 'anonymous'."
-~~~
+    # $valid_username contains "Amy Berry".
+    # If $raw_username was an empty string, the Puppet run would set $valid_username to
+    # "anonymous" and output a warning: "The username should be 'String[1, default]', not
+    # 'String[0, 0]'. Using 'anonymous'."
+    ~~~
 
-For more information about data types, see the
-[documentation](https://puppet.com/docs/puppet/latest/lang_data.html).
+    For more information about data types, see the
+    [documentation](https://puppet.com/docs/puppet/latest/lang_data.html).
 
-- Since 4.0.0
-DOC
-) do |args|
+    - Since 4.0.0
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('assert_type')
 end

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

@@ -1,24 +1,26 @@
-Puppet::Parser::Functions::newfunction(
+# frozen_string_literal: true
+
+Puppet::Parser::Functions.newfunction(
   :binary_file,
   :type => :rvalue,
   :arity => 1,
-:doc => <<-DOC
-Loads a binary file from a module or file system and returns its contents as a Binary.
+  :doc => <<~DOC
+    Loads a binary file from a module or file system and returns its contents as a Binary.
 
-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`.)
+    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 also accepts an absolute file path that allows reading
-binary file content from anywhere on disk.
+    This function also accepts an absolute file path that allows reading
+    binary file content from anywhere on disk.
 
-An error is raised if the given file does not exists.
+    An error is raised if the given file does not exists.
 
-To search for the existence of files, use the `find_file()` function.
+    To search for the existence of files, use the `find_file()` function.
 
-- since 4.8.0
-DOC
-) do |args|
+    - since 4.8.0
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('binary_file')
 end

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

@@ -1,39 +1,41 @@
-Puppet::Parser::Functions::newfunction(
+# frozen_string_literal: true
+
+Puppet::Parser::Functions.newfunction(
   :break,
   :arity => 0,
-  :doc => <<-DOC
-Breaks the innermost iteration as if it encountered an end of input.
-This function does not return to the caller.
+  :doc => <<~DOC
+    Breaks the innermost iteration as if it encountered an end of input.
+    This function does not return to the caller.
 
-The signal produced to stop the iteration bubbles up through
-the call stack until either terminating the innermost iteration or
-raising an error if the end of the call stack is reached.
+    The signal produced to stop the iteration bubbles up through
+    the call stack until either terminating the innermost iteration or
+    raising an error if the end of the call stack is reached.
 
-The break() function does not accept an argument.
+    The break() function does not accept an argument.
 
-**Example:** Using `break`
+    **Example:** Using `break`
 
-```puppet
-$data = [1,2,3]
-notice $data.map |$x| { if $x == 3 { break() } $x*10 }
-```
+    ```puppet
+    $data = [1,2,3]
+    notice $data.map |$x| { if $x == 3 { break() } $x*10 }
+    ```
 
-Would notice the value `[10, 20]`
+    Would notice the value `[10, 20]`
 
-**Example:** Using a nested `break`
+    **Example:** Using a nested `break`
 
-```puppet
-function break_if_even($x) {
-  if $x % 2 == 0 { break() }
-}
-$data = [1,2,3]
-notice $data.map |$x| { break_if_even($x); $x*10 }
-```
-Would notice the value `[10]`
+    ```puppet
+    function break_if_even($x) {
+      if $x % 2 == 0 { break() }
+    }
+    $data = [1,2,3]
+    notice $data.map |$x| { break_if_even($x); $x*10 }
+    ```
+    Would notice the value `[10]`
 
-* Also see functions `next` and `return`
-* Since 4.8.0
-DOC
-) do |args|
+    * Also see functions `next` and `return`
+    * Since 4.8.0
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('break')
 end

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

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 # Called within a class definition, establishes a containment
 # relationship with another class
 
-Puppet::Parser::Functions::newfunction(
+Puppet::Parser::Functions.newfunction(
   :contain,
   :arity => -2,
   :doc => "Contain one or more classes inside the current class. If any of

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

@@ -1,6 +1,12 @@
-Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc => <<-'ENDHEREDOC') do |args|
+# frozen_string_literal: true
+
+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.
 
+    **Note**: Use this function selectively. It's generally better to write resources in
+     [Puppet](https://puppet.com/docs/puppet/latest/lang_resources.html), as
+     resources created with `create_resource` are difficult to read and troubleshoot.
+
     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} }`:
 
@@ -33,7 +39,7 @@ Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc =>
     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
+    with @ or @@ respectively. For example, the $myusers hash may be exported
     in the following manner:
 
         create_resources("@@user", $myusers)
@@ -42,30 +48,32 @@ Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc =>
 
         create_resources("@user", $myusers)
 
-    Note that `create_resources` will filter out parameter values that are `undef` so that normal
-    data binding and puppet default value expressions are considered (in that order) for the
-    final value of a parameter (just as when setting a parameter to `undef` in a puppet language
+    Note that `create_resources` filters out parameter values that are `undef` so that normal
+    data binding and Puppet default value expressions are considered (in that order) for the
+    final value of a parameter (just as when setting a parameter to `undef` in a Puppet language
     resource declaration).
-  ENDHEREDOC
+ENDHEREDOC
   if Puppet[:tasks]
     raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
       Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
-      {:operation => 'create_resources'})
+      { :operation => 'create_resources' }
+    )
   end
 
   raise ArgumentError, (_("create_resources(): wrong number of arguments (%{count}; must be 2 or 3)") % { count: args.length }) if args.length > 3
-  raise ArgumentError, (_('create_resources(): second argument must be a hash')) unless args[1].is_a?(Hash)
+  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)
+    raise ArgumentError, _('create_resources(): third argument, if provided, must be a hash') unless args[2].is_a?(Hash)
   end
 
   type, instances, defaults = args
   defaults ||= {}
   type_name = type.sub(/^@{1,2}/, '').downcase
 
-  # Get file/line information from the puppet stack (where call comes from in puppet source)
-  # If relayed via other puppet functions in ruby that do not nest their calls, the source position
-  # will be in the original puppet source.
+  # Get file/line information from the Puppet stack (where call comes from in Puppet source)
+  # If relayed via other Puppet functions in ruby that do not nest their calls, the source position
+  # will be in the original Puppet source.
   #
   file, line = Puppet::Pops::PuppetStack.top_of_stack
 
@@ -85,22 +93,22 @@ Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc =>
 
   instances.map do |title, params|
     # Add support for iteration if title is an array
-    resource_titles = title.is_a?(Array) ? title  : [title]
+    resource_titles = title.is_a?(Array) ? title : [title]
     Puppet::Pops::Evaluator::Runtime3ResourceSupport.create_resources(
       file, line,
       self,
       virtual, exported,
       type_name,
       resource_titles,
-      defaults.merge(params).map do |name, value|
+      defaults.merge(params).filter_map do |name, value|
         value = nil if value == :undef
         Puppet::Parser::Resource::Param.new(
-          :name   => name,
-          :value  => value, # wide open to various data types, must be correct
-          :source => self.source, # TODO: support :line => line, :file => file,
-          :add    => false
+          :name => name,
+          :value => value, # wide open to various data types, must be correct
+          :source => source, # TODO: support :line => line, :file => file,
+          :add => false
         )
-      end.compact
-      )
+      end
+    )
   end.flatten.compact
 end

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

@@ -1,107 +1,109 @@
-Puppet::Parser::Functions::newfunction(
+# frozen_string_literal: true
+
+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|
+  :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|
   Puppet::Parser::Functions::Error.is4x('defined')
 end

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

@@ -1,38 +1,40 @@
-Puppet::Parser::Functions::newfunction(
+# frozen_string_literal: true
+
+Puppet::Parser::Functions.newfunction(
   :dig,
   :type => :rvalue,
   :arity => -1,
-  :doc => <<-DOC
-Returns a value for a sequence of given keys/indexes into a structure, such as
-an array or hash.
-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.
+  :doc => <<~DOC
+    Returns a value for a sequence of given keys/indexes into a structure, such as
+    an array or hash.
+    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.
+    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`.
+    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`
+    **Example:** Using `dig`
 
-```puppet
-$data = {a => { b => [{x => 10, y => 20}, {x => 100, y => 200}]}}
-notice $data.dig('a', 'b', 1, 'x')
-```
+    ```puppet
+    $data = {a => { b => [{x => 10, y => 20}, {x => 100, y => 200}]}}
+    notice $data.dig('a', 'b', 1, 'x')
+    ```
 
-Would notice the value 100.
+    Would notice the value 100.
 
-This is roughly equivalent to `$data['a']['b'][1]['x']`. However, a standard
-index will return an error and cause catalog compilation failure if any parent
-of the final key (`'x'`) is `undef`. The `dig` function will return undef,
-rather than failing catalog compilation. This allows you to check if data
-exists in a structure without mandating that it always exists.
+    This is roughly equivalent to `$data['a']['b'][1]['x']`. However, a standard
+    index will return an error and cause catalog compilation failure if any parent
+    of the final key (`'x'`) is `undef`. The `dig` function will return undef,
+    rather than failing catalog compilation. This allows you to check if data
+    exists in a structure without mandating that it always exists.
 
-* Since 4.5.0
-DOC
-) do |args|
+    * Since 4.5.0
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('dig')
 end