puppet 6.2.0-x86-mingw32 → 6.3.0-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e98d263dae48f9dd04a443123b8cddc25f3326d63662687379f89a5acabcd444
-  data.tar.gz: 4dd597ab6b1d72f4c4b236d640dc11a997756315ccd700f817ff7a9169a92501
+  metadata.gz: c7c03056fb261cae9f267079355947aa497bb8197647f3a5711c349c8530e99f
+  data.tar.gz: 070f1e085fef0d7e29f721588bfb0ebc78e6e9aa67f7f80183fa47621fdc443d
 SHA512:
-  metadata.gz: 3469c7581d09dded8c5244bd62c4466335e624650f9043e4691e6817e43d4931a37f44972911d17b908c6bebbf26f98d33606c1faac847cf189017f98c9af8ea
-  data.tar.gz: 6761136543b398515c36d0bbdd4018140cce57017abf7122038ac90257c6903a91afdaf974f356d136521ea6f521c7be21bf64fc7be00dd2057d2d0f2e556d50
+  metadata.gz: b22ef3c85a9decfcbc0ff991ec09f3349bb1b0bd97fd8f5f40b8163b42e4ccdfd3e71430dbbc42799f9f3a46c0d61e92e75e50007d9a40c8a0394bd5c87d7e67
+  data.tar.gz: e46983398037419137e70a505ce0887f63200b7828741c63911f3a02381e849e60b2908141074c56a390af982b32d89a56ed16485dcf9f506a3b3e0748b9d423

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,70 @@
+# Community Guidelines and Code of Conduct
+
+We want to keep the Puppet communities awesome, and we need your help to keep it
+that way. While we have specific guidelines for various tools (see links below),
+in general, you should:
+
+* **Be nice**: Be courteous, respectful and polite to fellow community members. No
+  offensive comments related to gender, gender identity or expression, sexual
+  orientation, disability, physical appearance, body size, race, religion; no
+  sexual images in public spaces, real or implied violence, intimidation,
+  oppression, stalking, following, harassing photography or recording, sustained
+  disruption of talks or other events, inappropriate physical contact, doxxing, or
+  unwelcome sexual attention will be tolerated. We like nice people way better
+  than mean ones!
+* **Encourage diversity and participation**: Make everyone in our community feel
+  welcome, regardless of their background, and do everything possible to encourage
+  participation in our community.
+* **Focus on constructive criticisms**: When offering suggestions, whether in online
+  discussions or as comments on a pull request, you should always use welcoming
+  and inclusive language. Be respectful of differing viewpoints and the fact that
+  others may not have the same experiences you do. Offer suggestions for
+  improvement, rather than focusing on mistakes. When others critique your work or
+  ideas, gracefully accept the criticisms and default to assuming good intentions.
+* **Keep it legal**: Basically, don't get us in trouble. Share only content that you
+  own, do not share private or sensitive information, and don't break the law.
+* **Stay on topic**: Keep conversation in a thread on topic, whether that's a pull
+  request or a Slack conversation or anything else. Make sure that you are posting
+  to the correct channel and remember that nobody likes spam.
+
+## Guideline violations --- 3 strikes method
+
+The point of this section is not to find opportunities to punish people, but we
+do need a fair way to deal with people who do harm to our community. Extreme
+violations of a threatening, abusive, destructive, or illegal nature will be
+addressed immediately and are not subject to 3 strikes.
+
+* First occurrence: We'll give you a friendly, but public, reminder that the
+  behavior is inappropriate according to our guidelines.
+* Second occurrence: We'll send you a private message with a warning that any
+  additional violations will result in removal from the community.
+* Third occurrence: Depending on the violation, we might need to delete or ban
+  your account.
+
+Notes:
+
+* Obvious spammers are banned on first occurrence. If we don’t do this, we’ll
+  have spam all over the place.
+* Violations are forgiven after 6 months of good behavior, and we won’t hold a grudge.
+* People who are committing minor formatting / style infractions will get some
+  education, rather than hammering them in the 3 strikes process.
+
+Contact conduct@puppet.com to report abuse or appeal violations. This email list
+goes to Kara Sowles (kara at puppet.com) and Katie Abbott (katie dot abbott at
+puppet.com). In the case of appeals, we know that mistakes happen, and we’ll
+work with you to come up with a fair solution if there has been a
+misunderstanding.
+
+## Full text
+
+See our [full community guidelines](https://puppet.com/community/community-guidelines),
+covering Slack, IRC, events and other forms of community participation.
+
+## Credits
+
+Credit to [01.org](https://01.org/community/participation-guidelines) and
+[meego.com](http://wiki.meego.com/Community_guidelines), since they formed the
+starting point for many of these guidelines.
+
+The Event Code of Conduct is based on the [example policy from the Geek Feminism wiki](http://geekfeminism.wikia.com/wiki/Conference_anti-harassment),
+created by the Ada Initiative and other volunteers. The [PyCon Code of Conduct](https://github.com/python/pycon-code-of-conduct) also served as inspiration.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    puppet (6.2.0)
+    puppet (6.3.0)
       CFPropertyList (~> 2.2)
       facter (>= 2.4.0, < 4)
       fast_gettext (~> 1.1.2)
@@ -34,9 +34,9 @@ GEM
       locale
     hashdiff (0.3.8)
     hiera (3.5.0)
-    hiera-eyaml (2.1.0)
+    hiera-eyaml (3.0.0)
       highline (~> 1.6.19)
-      trollop (~> 2.0)
+      optimist
     highline (1.6.21)
     hocon (1.2.5)
     hpricot (0.8.6)
@@ -53,10 +53,11 @@ GEM
     msgpack (1.2.6)
     multi_json (1.13.1)
     mustache (1.1.0)
-    packaging (0.99.22)
+    optimist (3.0.0)
+    packaging (0.99.23)
       artifactory (~> 2)
       rake (~> 12.3)
-    parallel (1.12.1)
+    parallel (1.13.0)
     parser (2.6.0.0)
       ast (~> 2.4.0)
     powerpack (0.1.2)
@@ -66,7 +67,7 @@ GEM
     public_suffix (3.0.3)
     puppet-resource_api (1.6.2)
       hocon (>= 1.0)
-    puppetserver-ca (1.2.1)
+    puppetserver-ca (1.3.0)
       facter (>= 2.0.1, < 4)
     racc (1.4.9)
     rainbow (2.2.2)
@@ -110,7 +111,6 @@ GEM
     safe_yaml (1.0.4)
     semantic_puppet (1.0.2)
     text (1.3.1)
-    trollop (2.9.9)
     unicode-display_width (1.4.1)
     vcr (2.9.3)
     webmock (1.24.6)

data/lib/puppet/application.rb

@@ -425,7 +425,7 @@ class Application
       Puppet::Util::Log.newdestination(arg)
       options[:setdest] = true
     rescue => detail
-      Puppet.log_exception(detail)
+      Puppet.log_and_raise(detail, _("Could not set logdest to %{dest}.") % { dest: arg })
     end
   end
 

data/lib/puppet/application/lookup.rb

@@ -102,7 +102,7 @@ class Puppet::Application::Lookup < Puppet::Application
   def help
     <<-HELP
 
-puppet-lookup(8) -- #{summary}
+puppet lookup(8) -- #{summary}
 ========
 
 SYNOPSIS

data/lib/puppet/confine/boolean.rb

@@ -0,0 +1,45 @@
+require 'puppet/confine'
+
+# Common module for the Boolean confines. It currently
+# contains just enough code to implement PUP-9336.
+class Puppet::Confine
+  module Boolean
+    # Returns the passing value for the Boolean confine.
+    def passing_value
+      raise NotImplementedError, "The Boolean confine %{confine} must provide the passing value." % { confine: self.class.name }
+    end
+
+    # The Boolean confines 'true' and 'false' let the user specify
+    # two types of values:
+    #     * A lambda for lazy evaluation. This would be something like
+    #         confine :true => lambda { true }
+    #
+    #     * A single Boolean value, or an array of Boolean values. This would
+    #     be something like
+    #         confine :true => true OR confine :true => [true, false, false, true]
+    #
+    # This override distinguishes between the two cases.
+    def values
+      # Note that Puppet::Confine's constructor ensures that @values
+      # will always be an array, even if a lambda's passed in. This is
+      # why we have the length == 1 check.
+      unless @values.length == 1 && @values.first.respond_to?(:call)
+        return @values
+      end
+
+      # We have a lambda. Here, we want to enforce "cache positive"
+      # behavior, which is to cache the result _if_ it evaluates to
+      # the passing value (i.e. the class name).
+
+      return @cached_value unless @cached_value.nil?
+
+      # Double negate to coerce the value into a Boolean
+      calculated_value = !! @values.first.call
+      if calculated_value == passing_value
+        @cached_value = [calculated_value]
+      end
+
+      [calculated_value]
+    end
+  end
+end

data/lib/puppet/confine/false.rb

@@ -1,6 +1,12 @@
-require 'puppet/confine'
+require 'puppet/confine/boolean'
 
 class Puppet::Confine::False < Puppet::Confine
+  include Puppet::Confine::Boolean
+
+  def passing_value
+    false
+  end
+
   def self.summarize(confines)
     confines.inject(0) { |count, confine| count + confine.summary }
   end

data/lib/puppet/confine/true.rb

@@ -1,6 +1,12 @@
-require 'puppet/confine'
+require 'puppet/confine/boolean'
 
 class Puppet::Confine::True < Puppet::Confine
+  include Puppet::Confine::Boolean
+
+  def passing_value
+    true
+  end
+
   def self.summarize(confines)
     confines.inject(0) { |count, confine| count + confine.summary }
   end

data/lib/puppet/defaults.rb

@@ -1452,30 +1452,12 @@ EOT
     :server => {
       :default => "puppet",
       :desc => "The puppet master server to which the puppet agent should connect.",
-      :call_hook => :on_initialize_and_write,
-      :hook => proc { |value|
-        if Puppet.settings.set_by_config?(:server) && Puppet.settings.set_by_config?(:server_list)
-          #TRANSLATOR 'server' and 'server_list' are setting names and should not be translated
-          message = _('Attempted to set both server and server_list.')
-          message += ' ' + _('Server setting will not be used.')
-          Puppet.deprecation_warning(message, :SERVER_DUPLICATION)
-        end
-      }
     },
     :server_list => {
       :default => [],
       :type => :server_list,
       :desc => "The list of puppet master servers to which the puppet agent should connect,
         in the order that they will be tried.",
-      :call_hook => :on_initialize_and_write,
-      :hook => proc { |value|
-        if Puppet.settings.set_by_config?(:server) && Puppet.settings.set_by_config?(:server_list)
-          #TRANSLATOR 'server' and 'server_list' are setting names and should not be translated
-          message = _('Attempted to set both server and server_list.')
-          message += ' ' + _('Server setting will not be used.')
-          Puppet.deprecation_warning(message, :SERVER_DUPLICATION)
-        end
-      }
     },
     :use_srv_records => {
       :default    => false,

data/lib/puppet/functions/call.rb

@@ -69,7 +69,8 @@ Puppet::Functions.create_function(:call, Puppet::Functions::InternalFunction) do
   end
 
   def call_impl_block(scope, function_name, *args, &block)
-    call_function_with_scope(scope, function_name, *args, &block)
+    # The call function must be able to call functions loaded by any loader visible from the calling scope.
+    Puppet::Pops::Parser::EvaluatingParser.new.evaluator.external_call_function(function_name, args, scope, &block)
   end
 
   def call_deferred(scope, deferred)

data/lib/puppet/functions/group_by.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Groups the collection by result of the block. Returns a hash where the keys are the evaluated result from the block
+# and the values are arrays of elements in the collection that correspond to the key.
+Puppet::Functions.create_function(:group_by) do
+  # @param collection A collection of things to group.
+  # @example Group array of strings by length, results in e.g. { 1 => [a, b], 2 => [ab] }
+  #   [a, b, ab].group_by |$s| { $s.length }
+  # @example Group array of strings by length and index, results in e.g. {1 => ['a'], 2 => ['b', 'ab']}
+  #   [a, b, ab].group_by |$i, $s| { $i%2 + $s.length }
+  # @example Group hash iterating by key-value pair, results in e.g. { 2 => [['a', [1, 2]]], 1 => [['b', [1]]] }
+  #   { a => [1, 2], b => [1] }.group_by |$kv| { $kv[1].length }
+  # @example Group hash iterating by key and value, results in e.g. { 2 => [['a', [1, 2]]], 1 => [['b', [1]]] }
+  #   { a => [1, 2], b => [1] }.group_by |$k, $v| { $v.length }
+  dispatch :group_by_1 do
+    required_param 'Collection', :collection
+    block_param 'Callable[1,1]', :block
+    return_type 'Hash'
+  end
+
+  dispatch :group_by_2a do
+    required_param 'Array', :array
+    block_param 'Callable[2,2]', :block
+    return_type 'Hash'
+  end
+
+  dispatch :group_by_2 do
+    required_param 'Collection', :collection
+    block_param 'Callable[2,2]', :block
+    return_type 'Hash'
+  end
+
+  def group_by_1(collection)
+    collection.group_by do |item|
+      yield(item)
+    end.freeze
+  end
+
+  def group_by_2a(array)
+    grouped = array.size.times.zip(array).group_by do |k, v|
+      yield(k, v)
+    end
+
+    grouped.each_with_object({}) do |(k, v), hsh|
+      hsh[k] = v.map { |item| item[1] }
+    end.freeze
+  end
+
+  def group_by_2(collection)
+    collection.group_by do |k, v|
+      yield(k, v)
+    end.freeze
+  end
+end

data/lib/puppet/functions/index.rb

@@ -0,0 +1,167 @@
+# Returns the index (or key in a hash) to a first-found value in an `Iterable` value.
+#
+# When called with a  [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
+# the lambda is called repeatedly using each value in a data structure until the lambda returns a "truthy" value which
+# makes the function return the index or key, or if the end of the iteration is reached, undef is returned.
+#
+# This function can be called in two different ways; with a value to be searched for, or with
+# a lambda that determines if an entry in the iterable matches.
+#
+# When called with a lambda the function takes two mandatory arguments, in this order:
+#
+# 1. An array, hash, string, or other iterable object that the function will iterate over.
+# 2. A lambda, which the function calls for each element in the first argument. It can request one (value) or two (index/key, value) parameters.
+#
+# @example Using the `index` function
+#
+# `$data.index |$parameter| { <PUPPET CODE BLOCK> }`
+#
+# or
+#
+# `index($data) |$parameter| { <PUPPET CODE BLOCK> }`
+#
+# @example Using the `index` function with an Array and a one-parameter lambda
+#
+# ```puppet
+# $data = ["routers", "servers", "workstations"]
+# notice $data.index |$value| { $value == 'servers' } # notices 1
+# notice $data.index |$value| { $value == 'hosts'  }  # notices undef
+# ```
+#
+# @example Using the `index` function with a Hash and a one-parameter lambda
+#
+# ```puppet
+# $data = {types => ["routers", "servers", "workstations"], colors => ['red', 'blue', 'green']}
+# notice $data.index |$value| { 'servers' in $value } # notices 'types'
+# notice $data.index |$value| { 'red' in $value }     # notices 'colors'
+# ```
+# Note that the lambda gets the value and not an array with `[key, value]` as in other
+# iterative functions.
+#
+# Using a lambda that accepts two values works the same way, it simply gets the index/key 
+# as the first parameter, and the value as the second.
+#
+# @example Using the `index` function with an Array and a two-parameter lambda
+#
+# ```puppet
+# # Find the first even numbered index that has a non String value
+# $data = [key1, 1, 3, 5]
+# notice $data.index |$idx, $value| { $idx % 2 == 0 and $value !~ String } # notices 2
+# ```
+#
+# When called on a `String`, the lambda is given each character as a value. What is typically wanted is to
+# find a sequence of characters which is achieved by calling the function with a value to search for instead
+# of giving a lambda.
+#
+#
+# @example Using the `index` function with a String, search for first occurrence of a sequence of characters
+#
+# ```puppet
+# # Find first occurrence of 'ah'
+# $data = "blablahbleh"
+# notice $data.index('ah') # notices 5
+# ```
+#
+# @example Using the `index` function with a String, search for first occurrence of a regular expression
+#
+# ```puppet
+# # Find first occurrence of 'la' or 'le'
+# $data = "blablahbleh"
+# notice $data.index(/l(a|e)/ # notices 1
+# ```
+#
+# When searching in a `String` with a given value that is neither `String` nor `Regexp` the answer is always `undef`.
+# When searching in any other iterable, the value is matched against each value in the iteration using strict
+# Ruby `==` semantics. If Puppet Language semantics are wanted (where string compare is case insensitive) use a
+# lambda and the `==` operator in Puppet.
+#
+# @example Using the `index` function to search for a given value in an Array
+#
+# ```puppet
+# $data = ['routers', 'servers', 'WORKstations']
+# notice $data.index('servers')      # notices 1
+# notice $data.index('workstations') # notices undef (not matching case)
+# ```
+#
+# For an general examples that demonstrates iteration, see the Puppet
+# [iteration](https://puppet.com/docs/puppet/latest/lang_iteration.html)
+# documentation.
+#
+# @since 6.3.0
+#
+Puppet::Functions.create_function(:index) do
+  dispatch :index_Hash_2 do
+    param 'Hash[Any, Any]', :hash
+    block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :index_Hash_1 do
+    param 'Hash[Any, Any]', :hash
+    block_param 'Callable[1,1]', :block
+  end
+
+  dispatch :index_Enumerable_2 do
+    param 'Iterable', :enumerable
+    block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :index_Enumerable_1 do
+    param 'Iterable', :enumerable
+    block_param 'Callable[1,1]', :block
+  end
+
+  dispatch :string_index do
+    param 'String', :str
+    param 'Variant[String,Regexp]', :match
+  end
+
+  dispatch :index_value do
+    param 'Iterable', :enumerable
+    param 'Any', :match
+  end
+
+
+  def index_Hash_1(hash)
+    hash.each_pair { |x, y| return x if yield(y)  }
+    nil
+  end
+
+  def index_Hash_2(hash)
+    hash.each_pair.any? { |x, y| return x if yield(x, y) }
+    nil
+  end
+
+  def index_Enumerable_1(enumerable)
+    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
+    if enum.hash_style?
+      enum.each { |entry| return entry[0] if yield(entry[1]) }
+    else
+      enum.each_with_index { |e, i| return i if yield(e) }
+    end
+    nil
+  end
+
+  def index_Enumerable_2(enumerable)
+    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
+    if enum.hash_style?
+      enum.each { |entry| return entry[0] if yield(*entry) }
+    else
+      enum.each_with_index { |e, i| return i if yield(i, e) }
+    end
+    nil
+  end
+
+  def string_index(str, match)
+    str.index(match)
+  end
+
+  def index_value(enumerable, match)
+    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
+    if enum.hash_style?
+      enum.each { |entry| return entry[0] if entry[1] == match }
+    else
+      enum.each_with_index { |e, i| return i if e == match }
+    end
+    nil
+  end
+end