puppet 4.5.3-universal-darwin → 4.6.1-universal-darwin

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

@@ -46,7 +46,7 @@ resource and relationship expressions.
 
   vals.each do |klass|
     # lookup the class in the scopes
-    if classobj = find_hostclass(klass)
+    if classobj = environment.known_resource_types.find_hostclass(klass)
       klass = classobj.name
     else
       raise Puppet::ParseError, "Could not find class #{klass}"

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

@@ -0,0 +1,83 @@
+Puppet::Parser::Functions::newfunction(
+  :reverse_each,
+  :type => :rvalue,
+  :arity => -1,
+  :doc => <<-DOC
+Reverses the order of the elements of something that is iterable and optionally runs a
+[lambda](http://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) for each
+element.
+
+This function takes one to two arguments:
+
+1. An `Iterable` that the function will iterate over.
+2. An optional lambda, which the function calls for each element in the first argument. It must
+   request one parameter.
+
+**Example:** Using the `reverse_each` function
+
+```puppet
+$data.reverse_each |$parameter| { <PUPPET CODE BLOCK> }
+```
+
+or
+
+```puppet
+$reverse_data = $data.reverse_each
+```
+
+or
+
+```puppet
+reverse_each($data) |$parameter| { <PUPPET CODE BLOCK> }
+```
+
+or
+
+```puppet
+$reverse_data = reverse_each($data)
+```
+
+When no second argument is present, Puppet returns an `Iterable` that represents the reverse
+order of its first argument. This allows methods on `Iterable` to be chained.
+
+When a lamdba is given as the second argument, Puppet iterates the first argument in reverse
+order and passes each value in turn to the lambda, then returns `undef`.
+
+**Example:** Using the `reverse_each` function with an array and a one-parameter lambda
+
+``` puppet
+# Puppet will log a notice for each of the three items
+# in $data in reverse order.
+$data = [1,2,3]
+$data.reverse_each |$item| { notice($item) }
+```
+
+When no second argument is present, Puppet returns a new `Iterable` which allows it to
+be directly chained into another function that takes an `Iterable` as an argument.
+
+**Example:** Using the `reverse_each` function chained with a `map` function.
+
+```puppet
+# For the array $data, return an array containing each
+# value multiplied by 10 in reverse order
+$data = [1,2,3]
+$transformed_data = $data.reverse_each.map |$item| { $item * 10 }
+# $transformed_data is set to [30,20,10]
+```
+
+**Example:** Using `reverse_each` function chained with a `map` in alternative syntax
+
+```puppet
+# For the array $data, return an array containing each
+# value multiplied by 10 in reverse order
+$data = [1,2,3]
+$transformed_data = map(reverse_each($data)) |$item| { $item * 10 }
+# $transformed_data is set to [30,20,10]
+```
+
+* Since 4.4.0
+
+DOC
+) do |args|
+  function_fail(["reverse_each() is only available when parser/evaluator future is in effect"])
+end

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

@@ -6,13 +6,13 @@ Puppet::Parser::Functions::newfunction(
   :arity => 2,
   :doc => <<-DOC
 Scans a string and returns an array of one or more converted values based on the given format string.
-See the documenation of Ruby's String#scanf method for details about the supported formats (which
+See the documentation of Ruby's String#scanf method for details about the supported formats (which
 are similar but not identical to the formats used in Puppet's `sprintf` function.)
 
 This function takes two mandatory arguments: the first is the string to convert, and the second is
-the format string. The result of the scan is an array, with each sucessfully scanned and transformed value.
-The scanning stops if a scan is unsuccesful, and the scanned result up to that point is returned. If there
-was no succesful scan, the result is an empty array.
+the format string. The result of the scan is an array, with each successfully scanned and transformed value.
+The scanning stops if a scan is unsuccessful, and the scanned result up to that point is returned. If there
+was no successful scan, the result is an empty array.
 
    "42".scanf("%i")
 

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

@@ -0,0 +1,84 @@
+Puppet::Parser::Functions::newfunction(
+  :step,
+  :type => :rvalue,
+  :arity => -1,
+  :doc => <<-DOC
+Provides stepping with given interval over elements in an iterable and optionally runs a
+[lambda](http://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) for each
+element.
+
+This function takes two to three arguments:
+
+1. An 'Iterable' that the function will iterate over.
+2. An `Integer` step factor. This must be a positive integer.
+3. An optional lambda, which the function calls for each element in the interval. It must
+   request one parameter.
+
+**Example:** Using the `step` function
+
+```puppet
+$data.step(<n>) |$parameter| { <PUPPET CODE BLOCK> }
+```
+
+or
+
+```puppet
+$stepped_data = $data.step(<n>)
+```
+
+or
+```puppet
+step($data, <n>) |$parameter| { <PUPPET CODE BLOCK> }
+```
+
+or
+
+```puppet
+$stepped_data = step($data, <n>)
+```
+
+When no block is given, Puppet returns an `Iterable` that yields the first element and every nth successor
+element, from its first argument. This allows functions on iterables to be chained.
+When a block is given, Puppet iterates and calls the block with the first element and then with
+every nth successor element. It then returns `undef`.
+
+**Example:** Using the `step` function with an array, a step factor, and a one-parameter block
+
+```puppet
+# For the array $data, call a block with the first element and then with each 3rd successor element
+$data = [1,2,3,4,5,6,7,8]
+$data.step(3) |$item| {
+ notice($item)
+}
+# Puppet notices the values '1', '4', '7'.
+```
+
+When no block is given, Puppet returns a new `Iterable` which allows it to be directly chained into
+another function that takes an `Iterable` as an argument.
+
+**Example:** Using the `step` function chained with a `map` function.
+
+```puppet
+# For the array $data, return an array, set to the first element and each 5th successor element, in reverse
+# order multiplied by 10
+$data = Integer[0,20]
+$transformed_data = $data.step(5).map |$item| { $item * 10 }
+$transformed_data contains [0,50,100,150,200]
+```
+
+**Example:** The same example using `step` function chained with a `map` in alternative syntax
+
+```puppet
+# For the array $data, return an array, set to the first and each 5th
+# successor, in reverse order, multiplied by 10
+$data = Integer[0,20]
+$transformed_data = map(step($data, 5)) |$item| { $item * 10 }
+$transformed_data contains [0,50,100,150,200]
+```
+
+* Since 4.4.0
+
+DOC
+) do |args|
+  function_fail(["step() is only available when parser/evaluator future is in effect"])
+end

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

@@ -0,0 +1,73 @@
+Puppet::Parser::Functions::newfunction(
+  :lest,
+  :type => :rvalue,
+  :arity => -2,
+  :doc => <<-DOC
+Call a [lambda](https://docs.puppet.com/puppet/latest/reference/lang_lambdas.html)
+with the given argument unless the argument is undef. Return `undef` if argument is
+`undef`, and otherwise the result of giving the argument to the lambda.
+
+This is useful to process a sequence of operations where an intermediate
+result may be `undef` (which makes the entire sequence `undef`).
+The `then` function is especially useful with the function `dig` which
+performs in a similar way "digging out" a value in a complex structure.
+
+**Example:** Using `dig` and `then`
+
+```puppet
+$data = {a => { b => [{x => 10, y => 20}, {x => 100, y => 200}]}}
+notice $data.dig(a, b, 1, x).then |$x| { $x * 2 }
+```
+
+Would notice the value 200
+
+Contrast this with:
+
+```puppet
+$data = {a => { b => [{x => 10, y => 20}, {ex => 100, why => 200}]}}
+notice $data.dig(a, b, 1, x).then |$x| { $x * 2 }
+```
+
+Which would notice `undef` since the last lookup of 'x' results in `undef` which
+is returned (without calling the lambda given to the `then` function).
+
+As a result there is no need for conditional logic or a temporary (non local) 
+variable as the result is now either the wanted value (`x`) multiplied
+by 2 or `undef`.
+
+Calls to `then` can be chained. In the next example, a structure is using an offset based on
+using 1 as the index to the first element (instead of 0 which is used in the language).
+We are not sure if user input actually contains an index at all, or if it is
+outside the range of available names.args.
+
+**Example:** Chaining calls to the `then` function
+
+```puppet
+# Names to choose from
+$names = ['Ringo', 'Paul', 'George', 'John']
+
+# Structure where 'beatle 2' is wanted (but where the number refers
+# to 'Paul' because input comes from a source using 1 for the first
+# element).
+
+$data = ['singer', { beatle => 2 }]
+$picked = assert_type(String,
+  # the data we are interested in is the second in the array,
+  # a hash, where we want the value of the key 'beatle'
+  $data.dig(1, 'beatle')
+    # and we want the index in $names before the given index
+    .then |$x| { $names[$x-1] }
+    # so we can construct a string with that beatle's name
+    .then |$x| { "Picked Beatle '${x}'" }
+)
+```
+
+Would notice "Picked Beatle 'Paul'", and would raise an error if the result
+was not a String.
+
+* Since 4.5.0
+
+DOC
+) do |args|
+  function_fail(["then() is only available when parser/evaluator future is in effect"])
+end

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

@@ -0,0 +1,53 @@
+Puppet::Parser::Functions::newfunction(
+  :type,
+  :type => :rvalue,
+  :arity => -1,
+  :doc => <<-DOC
+Returns the data type of a given value with a given degree of generality.
+
+```puppet
+type InferenceFidelity = Enum[generalized, reduced, detailed]
+
+function type(Any $value, InferenceFidelity $fidelity = 'detailed') # returns Type
+```
+
+ **Example:** Using `type`
+
+ ``` puppet
+ notice type(42) =~ Type[Integer]
+ ```
+
+ Would notice `true`.
+
+ By default, the best possible inference is made where all details are retained.
+ This is good when the type is used for further type calculations but is overwhelmingly
+ rich in information if it is used in a error message.
+
+ The optional argument `$fidelity` may be given as (from lowest to highest fidelity):
+
+ * `generalized` - reduces to common type and drops size constraints
+ * `reduced` - reduces to common type in collections
+ * `detailed` - (default) all details about inferred types is retained
+
+ **Example:** Using `type()` with different inference fidelity:
+
+ ``` puppet
+ notice type([3.14, 42], 'generalized')
+ notice type([3.14, 42], 'reduced'')
+ notice type([3.14, 42], 'detailed')
+ notice type([3.14, 42])
+ ```
+
+ Would notice the four values:
+
+ 1. 'Array[Numeric]'
+ 2. 'Array[Numeric, 2, 2]'
+ 3. 'Tuple[Float[3.14], Integer[42,42]]]'
+ 4. 'Tuple[Float[3.14], Integer[42,42]]]'
+
+ * Since 4.4.0
+
+DOC
+) do |args|
+  function_fail(["type() is only available when parser/evaluator future is in effect"])
+end

data/lib/puppet/parser/resource.rb

@@ -7,9 +7,6 @@ class Puppet::Parser::Resource < Puppet::Resource
   require 'puppet/parser/resource/param'
   require 'puppet/util/tagging'
   require 'puppet/parser/yaml_trimmer'
-  require 'puppet/resource/type_collection_helper'
-
-  include Puppet::Resource::TypeCollectionHelper
 
   include Puppet::Util
   include Puppet::Util::MethodHelper
@@ -75,7 +72,7 @@ class Puppet::Parser::Resource < Puppet::Resource
     return if evaluated?
     Puppet::Util::Profiler.profile("Evaluated resource #{self}", [:compiler, :evaluate_resource, self]) do
       @evaluated = true
-      if builtin?
+      if builtin_type?
         devfail "Cannot evaluate a builtin type (#{type})"
       elsif resource_type.nil?
         self.fail "Cannot find definition #{type}"
@@ -109,6 +106,7 @@ class Puppet::Parser::Resource < Puppet::Resource
     @finished = true
     add_defaults
     add_scope_tags
+    replace_sensitive_data
     validate if do_validate
   end
 
@@ -189,7 +187,9 @@ class Puppet::Parser::Resource < Puppet::Resource
       unless value.nil?
         case param.name
         when :before, :subscribe, :notify, :require
-          value = value.flatten if value.is_a?(Array)
+          if value.is_a?(Array)
+            value = value.flatten.reject {|v| v.nil? || v == :undef }
+          end
           result[param.name] = value
         else
           result[param.name] = value
@@ -256,7 +256,7 @@ class Puppet::Parser::Resource < Puppet::Resource
       scope.with_global_scope do |global_scope|
         cns_scope = global_scope.newscope(:source => self, :resource => self)
         cns.to_hash.each { |name, value| cns_scope[name.to_s] = value }
-  
+
         # evaluate mappings in that scope
         resource_type.arguments.keys.each do |name|
           if expr = blueprint[:mappings][name]
@@ -307,6 +307,15 @@ class Puppet::Parser::Resource < Puppet::Resource
     end
   end
 
+  def replace_sensitive_data
+    parameters.each_pair do |name, param|
+      if param.value.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+        @sensitive_parameters << name
+        param.value = param.value.unwrap
+      end
+    end
+  end
+
   # Accept a parameter from an override.
   def override_parameter(param)
     # This can happen if the override is defining a new parameter, rather
@@ -333,7 +342,7 @@ class Puppet::Parser::Resource < Puppet::Resource
     # syntax.  It's important that we use a copy of the new param instance
     # here, not the old one, and not the original new one, so that the source
     # is registered correctly for later overrides but the values aren't
-    # implcitly shared when multiple resources are overrriden at once (see
+    # implicitly shared when multiple resources are overridden at once (see
     # ticket #3556).
     if param.add
       param = param.dup

data/lib/puppet/parser/scope.rb

@@ -6,7 +6,6 @@ require 'forwardable'
 require 'puppet/parser'
 require 'puppet/parser/templatewrapper'
 
-require 'puppet/resource/type_collection_helper'
 require 'puppet/util/methodhelper'
 
 # This class is part of the internal parser/evaluator/compiler functionality of Puppet.
@@ -18,7 +17,6 @@ class Puppet::Parser::Scope
   extend Forwardable
   include Puppet::Util::MethodHelper
 
-  include Puppet::Resource::TypeCollectionHelper
   require 'puppet/parser/resource'
 
   AST = Puppet::Parser::AST
@@ -349,11 +347,11 @@ class Puppet::Parser::Scope
   end
 
   def find_hostclass(name)
-    known_resource_types.find_hostclass(name)
+    environment.known_resource_types.find_hostclass(name)
   end
 
   def find_definition(name)
-    known_resource_types.find_definition(name)
+    environment.known_resource_types.find_definition(name)
   end
 
   def find_global_scope()
@@ -467,7 +465,8 @@ class Puppet::Parser::Scope
   # Look up a defined type.
   def lookuptype(name)
     # This happens a lot, avoid making a call to make a call
-    known_resource_types.find_definition(name) || known_resource_types.find_hostclass(name)
+    krt = environment.known_resource_types
+    krt.find_definition(name) || krt.find_hostclass(name)
   end
 
   def undef_as(x,v)
@@ -976,18 +975,19 @@ class Puppet::Parser::Scope
     end
   end
 
+  # @api private
   def find_resource_type(type)
-    # It still works fine without the type == 'class' short-cut, but it is a lot slower.
-    return nil if ["class", "node"].include? type.to_s.downcase
-    find_builtin_resource_type(type) || find_defined_resource_type(type)
+    raise Puppet::DevError, "Scope#find_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
   end
 
+  # @api private
   def find_builtin_resource_type(type)
-    Puppet::Type.type(type.to_s.downcase.to_sym)
+    raise Puppet::DevError, "Scope#find_builtin_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
   end
 
+  # @api private
   def find_defined_resource_type(type)
-    known_resource_types.find_definition(type.to_s.downcase)
+    raise Puppet::DevError, "Scope#find_defined_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
   end
 
 
@@ -1005,25 +1005,33 @@ class Puppet::Parser::Scope
     end
   end
 
+  # Called from two places:
+  # runtime3support when creating resources
+  # ast::resource - used by create resources ?
+  # @api private
   def resolve_type_and_titles(type, titles)
-    raise ArgumentError, "titles must be an array" unless titles.is_a?(Array)
-
-    case type.downcase
-    when "class"
-      # resolve the titles
-      titles = titles.collect do |a_title|
-        hostclass = find_hostclass(a_title)
-        hostclass ?  hostclass.name : a_title
-      end
-    when "node"
-      # no-op
-    else
-      # resolve the type
-      resource_type = find_resource_type(type)
-      type = resource_type.name if resource_type
-    end
+    raise Puppet::DevError, "Scope#resolve_type_and_title() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
 
-    return [type, titles]
+#    Puppet.deprecation_warning('Scope#resolve_type_and_titles is deprecated.')
+#
+#    raise ArgumentError, "titles must be an array" unless titles.is_a?(Array)
+#
+#    case type.downcase
+#    when "class"
+#      # resolve the titles
+#      titles = titles.collect do |a_title|
+#        hostclass = find_hostclass(a_title)
+#        hostclass ?  hostclass.name : a_title
+#      end
+#    when "node"
+#      # no-op
+#    else
+#      # resolve the type
+#      resource_type = find_resource_type(type)
+#      type = resource_type.name if resource_type
+#    end
+#
+#    return [type, titles]
   end
 
   # Transforms references to classes to the form suitable for
@@ -1056,7 +1064,7 @@ class Puppet::Parser::Scope
       when Puppet::Pops::Types::PResourceType
         assert_class_and_title(name.type_name, name.title)
         name.title.sub(/^([^:]{1,2})/, '::\1')
-      end
+      end.downcase
     end
   end