puppet 6.29.0-universal-darwin → 7.0.0-universal-darwin

data/lib/puppet/functions/partition.rb

@@ -4,22 +4,14 @@
 # the second containing the rest.
 Puppet::Functions.create_function(:partition) do
   # @param collection A collection of things to partition.
-  # @example Partition array of empty strings, results in e.g. `[[''], [b, c]]`
-  #   ```puppet
+  # @example Partition array of empty strings, results in e.g. [[''], [b, c]]
   #   ['', b, c].partition |$s| { $s.empty }
-  #   ```
-  # @example Partition array of strings using index, results in e.g. `[['', 'ab'], ['b']]`
-  #   ```puppet
+  # @example Partition array of strings using index, results in e.g. [['', 'ab'], ['b']]
   #   ['', b, ab].partition |$i, $s| { $i == 2 or $s.empty }
-  #   ```
-  # @example Partition hash of strings by key-value pair, results in e.g. `[[['b', []]], [['a', [1, 2]]]]`
-  #   ```puppet
+  # @example Partition hash of strings by key-value pair, results in e.g. [[['b', []]], [['a', [1, 2]]]]
   #   { a => [1, 2], b => [] }.partition |$kv| { $kv[1].empty }
-  #   ```
-  # @example Partition hash of strings by key and value, results in e.g. `[[['b', []]], [['a', [1, 2]]]]`
-  #   ```puppet
+  # @example Partition hash of strings by key and value, results in e.g. [[['b', []]], [['a', [1, 2]]]]
   #   { a => [1, 2], b => [] }.partition |$k, $v| { $v.empty }
-  #   ```
   dispatch :partition_1 do
     required_param 'Collection', :collection
     block_param 'Callable[1,1]', :block

data/lib/puppet/functions/require.rb

@@ -4,13 +4,13 @@
 # The relationship metaparameters work well for specifying relationships
 # between individual resources, but they can be clumsy for specifying
 # relationships between classes.  This function is a superset of the
-# `include` function, adding a class relationship so that the requiring
+# 'include' function, adding a class relationship so that the requiring
 # class depends on the required class.
 #
-# Warning: using `require` in place of `include` can lead to unwanted dependency cycles.
+# Warning: using require in place of include can lead to unwanted dependency cycles.
 #
-# For instance, the following manifest, with `require` instead of `include`, would produce a nasty
-# dependence cycle, because `notify` imposes a `before` between `File[/foo]` and `Service[foo]`:
+# For instance the following manifest, with 'require' instead of 'include' would produce a nasty
+# dependence cycle, because notify imposes a before between File[/foo] and Service[foo]:
 #
 # ```puppet
 # class myservice {
@@ -32,7 +32,7 @@
 # resource and relationship expressions.
 #
 # - Since 4.0.0 Class and Resource types, absolute names
-# - Since 4.7.0 Returns an `Array[Type[Class]]` with references to the required classes
+# - Since 4.7.0 Returns an Array[Type[Class]] with references to the required classes
 #
 Puppet::Functions.create_function(:require, Puppet::Functions::InternalFunction) do
   dispatch :require_impl do

data/lib/puppet/functions/sort.rb

@@ -2,9 +2,9 @@
 # Please note: This function is based on Ruby String comparison and as such may not be entirely UTF8 compatible.
 # To ensure compatibility please use this function with Ruby 2.4.0 or greater - https://bugs.ruby-lang.org/issues/10085.
 #
-# This function is compatible with the function `sort()` in `stdlib`.
+# This function is compatible with the function sort() in stdlib.
 # * Comparison of characters in a string always uses a system locale and may not be what is expected for a particular locale
-# * Sorting is based on Ruby's `<=>` operator unless a lambda is given that performs the comparison.
+# * Sorting is based on Ruby's <=> operator unless a lambda is given that performs the comparison.
 #   * comparison of strings is case dependent (use lambda with `compare($a,$b)` to ignore case)
 #   * comparison of mixed data types raises an error (if there is the need to sort mixed data types use a lambda)
 #
@@ -49,7 +49,7 @@
 #   }
 # })
 # ```
-# Would notice `[2,3,'a','b']`
+# Would notice [2,3,'a','b']
 #
 # @since 6.0.0 - supporting a lambda to do compare
 #

data/lib/puppet/functions/strftime.rb

@@ -105,7 +105,6 @@
 # **Seconds since the Epoch:**
 #
 # | Format | Meaning |
-# | ------ | ------- |
 # | s | Number of seconds since 1970-01-01 00:00:00 UTC. |
 #
 # **Literal string:**

data/lib/puppet/functions/tree_each.rb

@@ -6,13 +6,13 @@
 #
 # 1. An `Array`, `Hash`, `Iterator`, or `Object` that the function will iterate over.
 # 2. An optional hash with the options:
-#    * `include_containers` => `Optional[Boolean]` # default `true` - if containers should be given to the lambda
-#    * `include_values` => `Optional[Boolean]` # default `true` - if non containers should be given to the lambda
-#    * `include_root` => `Optional[Boolean]` # default `true` - if the root container should be given to the lambda
+#    * `include_containers` => `Optional[Boolean]` # default true - if containers should be given to the lambda
+#    * `include_values` => `Optional[Boolean]` # default true - if non containers should be given to the lambda
+#    * `include_root` => `Optional[Boolean]` # default true - if the root container should be given to the lambda
 #    * `container_type` => `Optional[Type[Variant[Array, Hash, Object]]]` # a type that determines what a container is - can only
 #       be set to a type that matches the default `Variant[Array, Hash, Object]`.
 #    * `order` => `Enum[depth_first, breadth_first]` # default ´depth_first`, the order in which elements are visited
-#    * `include_refs` => `Optional[Boolean]` # default `false`, if attributes in objects marked as bing of `reference` kind
+#    * `include_refs` => Optional[Boolean] # default `false`, if attributes in objects marked as bing of `reference` kind
 #       should be included.
 # 3. An optional lambda, which the function calls for each element in the first argument. It must
 #    accept one or two arguments; either `$path`, and `$value`, or just `$value`.
@@ -46,12 +46,14 @@
 # [1, [2, 3], 4]
 # ```
 #
-# If containers are skipped, results in:
+# Results in:
+#
+# If containers are skipped:
 #
 # * `depth_first` order `1`, `2`, `3`, `4`
 # * `breadth_first` order `1`, `4`,`2`, `3`
 #
-# If containers and root are included, results in:
+# If containers and root, are included:
 #
 # * `depth_first` order `[1, [2, 3], 4]`, `1`, `[2, 3]`, `2`, `3`, `4`
 # * `breadth_first` order `[1, [2, 3], 4]`, `1`, `[2, 3]`, `4`, `2`, `3`
@@ -94,7 +96,7 @@
 #
 # Any Puppet Type system data type can be used to filter what is
 # considered to be a container, but it must be a narrower type than one of
-# the default `Array`, `Hash`, `Object` types - for example it is not possible to make a
+# the default Array, Hash, Object types - for example it is not possible to make a
 # `String` be a container type.
 #
 # @example Only `Array` as container type
@@ -112,6 +114,7 @@
 # * `reverse_each` - get "leaves before root"
 # * `filter` - prune the tree
 # * `map` - transform each element
+# * `reduce` - produce something else
 #
 # Note than when chaining, the value passed on is a `Tuple` with `[path, value]`.
 #

data/lib/puppet/functions/type.rb

@@ -35,10 +35,10 @@
 #
 # 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]]]`
+# 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
 #

data/lib/puppet/functions/unwrap.rb

@@ -1,5 +1,4 @@
 # Unwraps a Sensitive value and returns the wrapped object.
-# Returns the Value itself, if it is not Sensitive.
 #
 # @example Usage of unwrap
 #
@@ -29,17 +28,12 @@
 # @since 4.0.0
 #
 Puppet::Functions.create_function(:unwrap) do
-  dispatch :from_sensitive do
+  dispatch :unwrap do
     param 'Sensitive', :arg
     optional_block_param
   end
 
-  dispatch :from_any do
-    param 'Any', :arg
-    optional_block_param
-  end
-
-  def from_sensitive(arg)
+  def unwrap(arg)
     unwrapped = arg.unwrap
     if block_given?
       yield(unwrapped)
@@ -47,13 +41,4 @@ Puppet::Functions.create_function(:unwrap) do
       unwrapped
     end
   end
-
-  def from_any(arg)
-    unwrapped = arg
-    if block_given?
-      yield(unwrapped)
-    else
-      unwrapped
-    end
-  end
 end

data/lib/puppet/functions/upcase.rb

@@ -22,14 +22,14 @@
 # 'hello'.upcase()
 # upcase('hello')
 # ```
-# Would both result in `"HELLO"`
+# Would both result in "HELLO"
 #
 # @example Converting an Array to upper case
 # ```puppet
 # ['a', 'b'].upcase()
 # upcase(['a', 'b'])
 # ```
-# Would both result in `['A', 'B']`
+# Would both result in ['A', 'B']
 #
 # @example Converting a Hash to upper case
 # ```puppet

data/lib/puppet/functions/versioncmp.rb

@@ -8,9 +8,6 @@ require 'puppet/util/package'
 #
 # Where a and b are arbitrary version strings.
 #
-# Optional parameter ignore_trailing_zeroes is used to ignore unnecessary
-# trailing version numbers like .0 or .0.00
-#
 # This function returns:
 #
 # * `1` if version a is greater than version b
@@ -31,10 +28,9 @@ Puppet::Functions.create_function(:versioncmp) do
   dispatch :versioncmp do
     param 'String', :a
     param 'String', :b
-    optional_param 'Boolean', :ignore_trailing_zeroes
   end
 
-  def versioncmp(a, b, ignore_trailing_zeroes = false)
-    Puppet::Util::Package.versioncmp(a, b, ignore_trailing_zeroes)
+  def versioncmp(a, b)
+    Puppet::Util::Package.versioncmp(a, b)
   end
 end

data/lib/puppet/generate/models/type/type.rb

@@ -49,7 +49,10 @@ module Puppet
               ]
             end]
             @isomorphic = type.isomorphic?
-            @capability = type.is_capability?
+            # continue to emit capability as false when rendering the ERB
+            # template, so that pcore modules generated prior to puppet7 can be
+            # read by puppet7 and vice-versa.
+            @capability = false
           end
 
           def render(template)

data/lib/puppet/generate/type.rb

@@ -134,9 +134,6 @@ module Puppet
         inputs.sort_by! { |input| input.path }
       end
 
-      def self.bad_input?
-        @bad_input
-      end
       # Generates files for the given inputs.
       # If a file is up to date (newer than input) it is kept.
       # If a file is out of date it is regenerated.
@@ -173,8 +170,6 @@ module Puppet
         }
 
         up_to_date = true
-        @bad_input = false
-
         Puppet.notice _('Generating Puppet resource types.')
         inputs.each do |input|
           if !force && input.up_to_date?(outputdir)
@@ -192,7 +187,6 @@ module Puppet
             raise
           rescue Exception => e
             # Log the exception and move on to the next input
-            @bad_input = true
             Puppet.log_exception(e, _("Failed to load custom type '%{type_name}' from '%{input}': %{message}") % { type_name: type_name, input: input, message: e.message })
             next
           end
@@ -211,7 +205,6 @@ module Puppet
           begin
             model = Models::Type::Type.new(type)
           rescue Exception => e
-            @bad_input = true
             # Move on to the next input
             Puppet.log_exception(e, "#{input}: #{e.message}")
             next
@@ -221,7 +214,6 @@ module Puppet
           begin
             result = model.render(templates[input.template_path])
           rescue Exception => e
-            @bad_input = true
             Puppet.log_exception(e)
             raise
           end
@@ -235,7 +227,6 @@ module Puppet
               file.write(result)
             end
           rescue Exception => e
-            @bad_input = true
             Puppet.log_exception(e, _("Failed to generate '%{effective_output_path}': %{message}") % { effective_output_path: effective_output_path, message: e.message })
             # Move on to the next input
             next