puppet 8.3.1-x86-mingw32 → 8.4.0-x86-mingw32

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

@@ -1,39 +1,40 @@
 # frozen_string_literal: true
+
 Puppet::Parser::Functions::newfunction(
   :next,
   :arity => -2,
-  :doc => <<-DOC
-Immediately returns the given optional value from a block (lambda), function, class body or user defined type body.
-If a value is not given, an `undef` value is returned. This function does not return to the immediate caller.
-
-The signal produced to return a value bubbles up through
-the call stack until reaching a code block (lambda), function, class definition or
-definition of a user defined type at which point the value given to the function will
-be produced as the result of that body of code. An error is raised
-if the signal to return a value reaches the end of the call stack.
-
-**Example:** Using `next` in `each`
-
-```puppet
-$data = [1,2,3]
-$data.each |$x| { if $x == 2 { next() } notice $x }
-```
-
-Would notice the values `1` and `3`
-
-**Example:** Using `next` to produce a value
-
-If logic consists of deeply nested conditionals it may be complicated to get out of the innermost conditional.
-A call to `next` can then simplify the logic. This example however, only shows the principle.
-```puppet
-$data = [1,2,3]
-notice $data.map |$x| { if $x == 2 { next($x*100) }; $x*10 }
-```
-Would notice the value `[10, 200, 30]`
-
-* Also see functions `return` and `break`
-* Since 4.8.0
-DOC
-) do |args|
+  :doc => <<~DOC
+    Immediately returns the given optional value from a block (lambda), function, class body or user defined type body.
+    If a value is not given, an `undef` value is returned. This function does not return to the immediate caller.
+    
+    The signal produced to return a value bubbles up through
+    the call stack until reaching a code block (lambda), function, class definition or
+    definition of a user defined type at which point the value given to the function will
+    be produced as the result of that body of code. An error is raised
+    if the signal to return a value reaches the end of the call stack.
+    
+    **Example:** Using `next` in `each`
+    
+    ```puppet
+    $data = [1,2,3]
+    $data.each |$x| { if $x == 2 { next() } notice $x }
+    ```
+    
+    Would notice the values `1` and `3`
+    
+    **Example:** Using `next` to produce a value
+    
+    If logic consists of deeply nested conditionals it may be complicated to get out of the innermost conditional.
+    A call to `next` can then simplify the logic. This example however, only shows the principle.
+    ```puppet
+    $data = [1,2,3]
+    notice $data.map |$x| { if $x == 2 { next($x*100) }; $x*10 }
+    ```
+    Would notice the value `[10, 200, 30]`
+    
+    * Also see functions `return` and `break`
+    * Since 4.8.0
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('next')
 end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # This is just syntactic sugar for a collection, although it will generally
 # be a good bit faster.
 
@@ -7,15 +8,14 @@ Puppet::Parser::Functions::newfunction(:realize, :arity => -2, :doc => "Make a v
     bother with a full collection.  It is slightly faster than a collection,
     and, of course, is a bit shorter.  You must pass the object using a
     reference; e.g.: `realize User[luke]`." ) do |vals|
+  if Puppet[:tasks]
+    raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+      Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+      {:operation => 'realize'})
+  end
 
-    if Puppet[:tasks]
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
-        {:operation => 'realize'})
-    end
-
-    vals = [vals] unless vals.is_a?(Array)
+  vals = [vals] unless vals.is_a?(Array)
 
-    coll = Puppet::Pops::Evaluator::Collectors::FixedSetCollector.new(self, vals.flatten)
-    compiler.add_collection(coll)
+  coll = Puppet::Pops::Evaluator::Collectors::FixedSetCollector.new(self, vals.flatten)
+  compiler.add_collection(coll)
 end

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

@@ -1,138 +1,139 @@
 # frozen_string_literal: true
+
 Puppet::Parser::Functions::newfunction(
   :reduce,
   :type => :rvalue,
   :arity => -3,
-  :doc => <<-DOC
-Applies a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
-to every value in a data structure from the first argument, carrying over the returned
-value of each iteration, and returns the result of the lambda's final iteration. This
-lets you create a new value or data structure by combining values from the first
-argument's data structure.
-
-This function takes two mandatory arguments, in this order:
-
-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 takes
-two mandatory parameters:
-    1. A memo value that is overwritten after each iteration with the iteration's result.
-    2. A second value that is overwritten after each iteration with the next value in the
-    function's first argument.
-
-**Example**: Using the `reduce` function
-
-`$data.reduce |$memo, $value| { ... }`
-
-or
-
-`reduce($data) |$memo, $value| { ... }`
-
-You can also pass an optional "start memo" value as an argument, such as `start` below:
-
-`$data.reduce(start) |$memo, $value| { ... }`
-
-or
-
-`reduce($data, start) |$memo, $value| { ... }`
-
-When the first argument (`$data` in the above example) is an array, Puppet passes each
-of the data structure's values in turn to the lambda's parameters. When the first
-argument is a hash, Puppet converts each of the hash's values to an array in the form
-`[key, value]`.
-
-If you pass a start memo value, Puppet executes the lambda with the provided memo value
-and the data structure's first value. Otherwise, Puppet passes the structure's first two
-values to the lambda.
-
-Puppet calls the lambda for each of the data structure's remaining values. For each
-call, it passes the result of the previous call as the first parameter ($memo in the
-above examples) and the next value from the data structure as the second parameter
-($value).
-
-If the structure has one value, Puppet returns the value and does not call the lambda.
-
-**Example**: Using the `reduce` function
-
-~~~ puppet
-# Reduce the array $data, returning the sum of all values in the array.
-$data = [1, 2, 3]
-$sum = $data.reduce |$memo, $value| { $memo + $value }
-# $sum contains 6
-
-# Reduce the array $data, returning the sum of a start memo value and all values in the
-# array.
-$data = [1, 2, 3]
-$sum = $data.reduce(4) |$memo, $value| { $memo + $value }
-# $sum contains 10
-
-# Reduce the hash $data, returning the sum of all values and concatenated string of all
-# keys.
-$data = {a => 1, b => 2, c => 3}
-$combine = $data.reduce |$memo, $value| {
-  $string = "${memo[0]}${value[0]}"
-  $number = $memo[1] + $value[1]
-  [$string, $number]
-}
-# $combine contains [abc, 6]
-~~~
-
-**Example**: Using the `reduce` function with a start memo and two-parameter lambda
-
-~~~ puppet
-# Reduce the array $data, returning the sum of all values in the array and starting
-# with $memo set to an arbitrary value instead of $data's first value.
-$data = [1, 2, 3]
-$sum = $data.reduce(4) |$memo, $value| { $memo + $value }
-# At the start of the lambda's first iteration, $memo contains 4 and $value contains 1.
-# After all iterations, $sum contains 10.
-
-# Reduce the hash $data, returning the sum of all values and concatenated string of
-# all keys, and starting with $memo set to an arbitrary array instead of $data's first
-# key-value pair.
-$data = {a => 1, b => 2, c => 3}
-$combine = $data.reduce( [d, 4] ) |$memo, $value| {
-  $string = "${memo[0]}${value[0]}"
-  $number = $memo[1] + $value[1]
-  [$string, $number]
-}
-# At the start of the lambda's first iteration, $memo contains [d, 4] and $value
-# contains [a, 1].
-# $combine contains [dabc, 10]
-~~~
-
-**Example**: Using the `reduce` function to reduce a hash of hashes
-
-~~~ puppet
-# Reduce a hash of hashes $data, merging defaults into the inner hashes.
-$data = {
-  'connection1' => {
-    'username' => 'user1',
-    'password' => 'pass1',
-  },
-  'connection_name2' => {
-    'username' => 'user2',
-    'password' => 'pass2',
-  },
-}
-
-$defaults = {
-  'maxActive' => '20',
-  'maxWait'   => '10000',
-  'username'  => 'defaultuser',
-  'password'  => 'defaultpass',
-}
-
-$merged = $data.reduce( {} ) |$memo, $x| {
-  $memo + { $x[0] => $defaults + $data[$x[0]] }
-}
-# At the start of the lambda's first iteration, $memo is set to {}, and $x is set to
-# the first [key, value] tuple. The key in $data is, therefore, given by $x[0]. In
-# subsequent rounds, $memo retains the value returned by the expression, i.e.
-# $memo + { $x[0] => $defaults + $data[$x[0]] }.
-~~~
-
-- Since 4.0.0
-DOC
-) do |args|
+  :doc => <<~DOC
+    Applies a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
+    to every value in a data structure from the first argument, carrying over the returned
+    value of each iteration, and returns the result of the lambda's final iteration. This
+    lets you create a new value or data structure by combining values from the first
+    argument's data structure.
+    
+    This function takes two mandatory arguments, in this order:
+    
+    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 takes
+    two mandatory parameters:
+        1. A memo value that is overwritten after each iteration with the iteration's result.
+        2. A second value that is overwritten after each iteration with the next value in the
+        function's first argument.
+    
+    **Example**: Using the `reduce` function
+    
+    `$data.reduce |$memo, $value| { ... }`
+    
+    or
+    
+    `reduce($data) |$memo, $value| { ... }`
+    
+    You can also pass an optional "start memo" value as an argument, such as `start` below:
+    
+    `$data.reduce(start) |$memo, $value| { ... }`
+    
+    or
+    
+    `reduce($data, start) |$memo, $value| { ... }`
+    
+    When the first argument (`$data` in the above example) is an array, Puppet passes each
+    of the data structure's values in turn to the lambda's parameters. When the first
+    argument is a hash, Puppet converts each of the hash's values to an array in the form
+    `[key, value]`.
+    
+    If you pass a start memo value, Puppet executes the lambda with the provided memo value
+    and the data structure's first value. Otherwise, Puppet passes the structure's first two
+    values to the lambda.
+    
+    Puppet calls the lambda for each of the data structure's remaining values. For each
+    call, it passes the result of the previous call as the first parameter ($memo in the
+    above examples) and the next value from the data structure as the second parameter
+    ($value).
+    
+    If the structure has one value, Puppet returns the value and does not call the lambda.
+    
+    **Example**: Using the `reduce` function
+    
+    ~~~ puppet
+    # Reduce the array $data, returning the sum of all values in the array.
+    $data = [1, 2, 3]
+    $sum = $data.reduce |$memo, $value| { $memo + $value }
+    # $sum contains 6
+    
+    # Reduce the array $data, returning the sum of a start memo value and all values in the
+    # array.
+    $data = [1, 2, 3]
+    $sum = $data.reduce(4) |$memo, $value| { $memo + $value }
+    # $sum contains 10
+    
+    # Reduce the hash $data, returning the sum of all values and concatenated string of all
+    # keys.
+    $data = {a => 1, b => 2, c => 3}
+    $combine = $data.reduce |$memo, $value| {
+      $string = "${memo[0]}${value[0]}"
+      $number = $memo[1] + $value[1]
+      [$string, $number]
+    }
+    # $combine contains [abc, 6]
+    ~~~
+    
+    **Example**: Using the `reduce` function with a start memo and two-parameter lambda
+    
+    ~~~ puppet
+    # Reduce the array $data, returning the sum of all values in the array and starting
+    # with $memo set to an arbitrary value instead of $data's first value.
+    $data = [1, 2, 3]
+    $sum = $data.reduce(4) |$memo, $value| { $memo + $value }
+    # At the start of the lambda's first iteration, $memo contains 4 and $value contains 1.
+    # After all iterations, $sum contains 10.
+    
+    # Reduce the hash $data, returning the sum of all values and concatenated string of
+    # all keys, and starting with $memo set to an arbitrary array instead of $data's first
+    # key-value pair.
+    $data = {a => 1, b => 2, c => 3}
+    $combine = $data.reduce( [d, 4] ) |$memo, $value| {
+      $string = "${memo[0]}${value[0]}"
+      $number = $memo[1] + $value[1]
+      [$string, $number]
+    }
+    # At the start of the lambda's first iteration, $memo contains [d, 4] and $value
+    # contains [a, 1].
+    # $combine contains [dabc, 10]
+    ~~~
+    
+    **Example**: Using the `reduce` function to reduce a hash of hashes
+    
+    ~~~ puppet
+    # Reduce a hash of hashes $data, merging defaults into the inner hashes.
+    $data = {
+      'connection1' => {
+        'username' => 'user1',
+        'password' => 'pass1',
+      },
+      'connection_name2' => {
+        'username' => 'user2',
+        'password' => 'pass2',
+      },
+    }
+    
+    $defaults = {
+      'maxActive' => '20',
+      'maxWait'   => '10000',
+      'username'  => 'defaultuser',
+      'password'  => 'defaultpass',
+    }
+    
+    $merged = $data.reduce( {} ) |$memo, $x| {
+      $memo + { $x[0] => $defaults + $data[$x[0]] }
+    }
+    # At the start of the lambda's first iteration, $memo is set to {}, and $x is set to
+    # the first [key, value] tuple. The key in $data is, therefore, given by $x[0]. In
+    # subsequent rounds, $memo retains the value returned by the expression, i.e.
+    # $memo + { $x[0] => $defaults + $data[$x[0]] }.
+    ~~~
+    
+    - Since 4.0.0
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('reduce')
 end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Copyright (C) 2009 Thomas Bellman
 #
 # Permission is hereby granted, free of charge, to any person obtaining
@@ -27,10 +28,10 @@
 
 module Puppet::Parser::Functions
   newfunction(
-  :regsubst, :type => :rvalue,
-  :arity => -4,
+    :regsubst, :type => :rvalue,
+               :arity => -4,
 
-  :doc => "
+               :doc => "
 Perform regexp replacement on a string or array of strings.
 
 * *Parameters* (in order):
@@ -57,7 +58,7 @@ Get the third octet from the node's IP address:
 Put angle brackets around each octet in the node's IP address:
 
     $x = regsubst($ipaddress, '([0-9]+)', '<\\1>', 'G')
-") do |args|
-    Error.is4x('regsubst')
+") do |_args|
+  Error.is4x('regsubst')
 end
 end

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

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
+
 # Requires the specified classes
 
-  Puppet::Parser::Functions::newfunction(
-    :require,
-    :arity => -2,
-    :doc =>"Evaluate one or more classes,  adding the required class as a dependency.
+Puppet::Parser::Functions::newfunction(
+  :require,
+  :arity => -2,
+  :doc => "Evaluate one or more classes,  adding the required class as a dependency.
 
 The relationship metaparameters work well for specifying relationships
 between individual resources, but they can be clumsy for specifying

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

@@ -1,93 +1,94 @@
 # frozen_string_literal: true
+
 Puppet::Parser::Functions::newfunction(
   :return,
   :arity => -2,
-  :doc => <<-DOC
-Immediately returns the given optional value from a function, class body or user defined type body.
-If a value is not given, an `undef` value is returned. This function does not return to the immediate caller.
-If this function is called from within a lambda, the return action is from the scope of the
-function containing the lambda (top scope), not the function accepting the lambda (local scope).
-
-The signal produced to return a value bubbles up through
-the call stack until reaching a function, class definition or
-definition of a user defined type at which point the value given to the function will
-be produced as the result of that body of code. An error is raised
-if the signal to return a value reaches the end of the call stack.
-
-**Example:** Using `return`
-
-```puppet
-function example($x) {
-  # handle trivial cases first for better readability of
-  # what follows
-  if $x == undef or $x == [] or $x == '' {
-    return false
-  }
-  # complex logic to determine if value is true
-  true 
-}
-notice example([]) # would notice false
-notice example(42) # would notice true
-```
-
-**Example:** Using `return` in a class
-
-```puppet
-class example($x) {
-  # handle trivial cases first for better readability of
-  # what follows
-  if $x == undef or $x == [] or $x == '' {
-    # Do some default configuration of this class
-    notice 'foo'
-    return()
-  }
-  # complex logic configuring the class if something more interesting
-  # was given in $x
-  notice 'bar'
-}
-```
-
-When used like this:
-
-```puppet
-class { example: x => [] }
-```
-
-The code would notice `'foo'`, but not `'bar'`.
-
-When used like this:
-
-```puppet
-class { example: x => [some_value] }
-```
-
-The code would notice `'bar'` but not `'foo'`
-
-Note that the returned value is ignored if used in a class or user defined type.
-
-**Example:** Using `return` in a lambda
-
-```puppet
-# Concatenate three strings into a single string formatted as a list.
-function getFruit() {
-  with("apples", "oranges", "bananas") |$x, $y, $z| {
-    return("${x}, ${y}, and ${z}")
-  }
-  notice "not reached"
-}
-$fruit = getFruit()
-notice $fruit
-
-# The output contains "apples, oranges, and bananas".
-# "not reached" is not output because the function returns its value within the
-# calling function's scope, which stops processing the calling function before
-# the `notice "not reached"` statement.
-# Using `return()` outside of a calling function results in an error.
-```
-
-* Also see functions `return` and `break`
-* Since 4.8.0
-DOC
-) do |args|
+  :doc => <<~DOC
+    Immediately returns the given optional value from a function, class body or user defined type body.
+    If a value is not given, an `undef` value is returned. This function does not return to the immediate caller.
+    If this function is called from within a lambda, the return action is from the scope of the
+    function containing the lambda (top scope), not the function accepting the lambda (local scope).
+    
+    The signal produced to return a value bubbles up through
+    the call stack until reaching a function, class definition or
+    definition of a user defined type at which point the value given to the function will
+    be produced as the result of that body of code. An error is raised
+    if the signal to return a value reaches the end of the call stack.
+    
+    **Example:** Using `return`
+    
+    ```puppet
+    function example($x) {
+      # handle trivial cases first for better readability of
+      # what follows
+      if $x == undef or $x == [] or $x == '' {
+        return false
+      }
+      # complex logic to determine if value is true
+      true 
+    }
+    notice example([]) # would notice false
+    notice example(42) # would notice true
+    ```
+    
+    **Example:** Using `return` in a class
+    
+    ```puppet
+    class example($x) {
+      # handle trivial cases first for better readability of
+      # what follows
+      if $x == undef or $x == [] or $x == '' {
+        # Do some default configuration of this class
+        notice 'foo'
+        return()
+      }
+      # complex logic configuring the class if something more interesting
+      # was given in $x
+      notice 'bar'
+    }
+    ```
+    
+    When used like this:
+    
+    ```puppet
+    class { example: x => [] }
+    ```
+    
+    The code would notice `'foo'`, but not `'bar'`.
+    
+    When used like this:
+    
+    ```puppet
+    class { example: x => [some_value] }
+    ```
+    
+    The code would notice `'bar'` but not `'foo'`
+    
+    Note that the returned value is ignored if used in a class or user defined type.
+    
+    **Example:** Using `return` in a lambda
+    
+    ```puppet
+    # Concatenate three strings into a single string formatted as a list.
+    function getFruit() {
+      with("apples", "oranges", "bananas") |$x, $y, $z| {
+        return("${x}, ${y}, and ${z}")
+      }
+      notice "not reached"
+    }
+    $fruit = getFruit()
+    notice $fruit
+    
+    # The output contains "apples, oranges, and bananas".
+    # "not reached" is not output because the function returns its value within the
+    # calling function's scope, which stops processing the calling function before
+    # the `notice "not reached"` statement.
+    # Using `return()` outside of a calling function results in an error.
+    ```
+    
+    * Also see functions `return` and `break`
+    * Since 4.8.0
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('return')
 end