puppet 5.3.7-x86-mingw32 → 5.4.0-x86-mingw32

data/lib/puppet/functions/all.rb

@@ -94,7 +94,11 @@ Puppet::Functions.create_function(:all) do
 
   def all_Enumerable_2(enumerable)
     enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    enum.each_with_index { |e, i| return false unless yield(i, e) }
-    true
+    if enum.hash_style?
+      enum.all? { |entry| yield(*entry) }
+    else
+      enum.each_with_index { |e, i| return false unless yield(i, e) }
+      true
+    end
   end
 end

data/lib/puppet/functions/annotate.rb

@@ -37,7 +37,7 @@
 # ~~~
 #
 # With three arguments, an `Annotation` type, an object, and an the string `clear`, the function will
-# clear the annotatation of the given type in the given object. The old annotation is returned if
+# clear the annotation of the given type in the given object. The old annotation is returned if
 # it existed.
 #
 # @example Using `annotate` with three arguments where third argument is the string 'clear'

data/lib/puppet/functions/any.rb

@@ -27,7 +27,7 @@
 #
 # Would notice `true` if the looked up hash had a value that is neither `false` nor `undef` for at least
 # one of the keys. That is, it is equivalent to the expression
-# `$lookued_up[routers] || $looked_up[servers] || $looked_up[workstations]`.
+# `$looked_up[routers] || $looked_up[servers] || $looked_up[workstations]`.
 #
 # When the first argument is a `Hash`, Puppet passes each key and value pair to the lambda
 # as an array in the form `[key, value]`.
@@ -99,7 +99,11 @@ Puppet::Functions.create_function(:any) do
 
   def any_Enumerable_2(enumerable)
     enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    enum.each_with_index { |e, i| return true if yield(i, e) }
-    false
+    if enum.hash_style?
+      enum.any? { |entry| yield(*entry) }
+    else
+      enum.each_with_index { |e, i| return true if yield(i, e) }
+      false
+    end
   end
 end

data/lib/puppet/functions/contain.rb

@@ -13,6 +13,12 @@ Puppet::Functions.create_function(:contain, Puppet::Functions::InternalFunction)
   end
 
   def contain(scope, *classes)
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:operation => 'contain'})
+    end
+
     # Make call patterns uniform and protected against nested arrays, also make
     # names absolute if so desired.
     classes = scope.transform_and_assert_classnames(classes.flatten)

data/lib/puppet/functions/convert_to.rb

@@ -0,0 +1,32 @@
+# The `convert_to(value, type)` is a convenience function does the same as `new(type, value)`.
+# The difference in the argument ordering allows it to be used in chained style for
+# improved readability "left to right".
+#
+# When the function is given a lambda, it is called with the converted value, and the function
+# returns what the lambda returns, otherwise the converted value.
+#
+# @example 'convert_to' instead of 'new'
+#
+# ~~~ puppet
+#   # using new operator - that is "calling the type" with operator ()
+#   Hash(Array("abc").map |$i,$v| { [$i, $v] })
+#
+#   # using 'convert_to'
+#   "abc".convert_to(Array).map |$i,$v| { [$i, $v] }.convert_to(Hash)
+#
+# ~~~
+#
+# @since 5.4.0
+#
+Puppet::Functions.create_function(:convert_to) do
+  dispatch :convert_to do
+    param 'Any', :value
+    param 'Type', :type
+    optional_block_param 'Callable[1,1]', :block
+  end
+
+  def convert_to(value, type, &block)
+    result = call_function('new', type, value)
+    block_given? ? yield(result) : result
+  end
+end

data/lib/puppet/functions/defined.rb

@@ -105,7 +105,6 @@ Puppet::Functions.create_function(:'defined', Puppet::Functions::InternalFunctio
   end
 
   def is_defined(scope, *vals)
-    env = scope.environment
     vals.any? do |val|
       case val
       when String
@@ -120,7 +119,6 @@ Puppet::Functions.create_function(:'defined', Puppet::Functions::InternalFunctio
             Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_main_class(scope)
           else
             # Find a resource type, definition or class definition
-            krt = scope.environment.known_resource_types
             Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type_or_class(scope, val)
           end
         end
@@ -150,7 +148,6 @@ Puppet::Functions.create_function(:'defined', Puppet::Functions::InternalFunctio
           #
           raise  ArgumentError, _('The given class type is a reference to all classes') if val.type.class_name.nil?
           Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_hostclass(scope, val.type.class_name)
-          #scope.environment.known_resource_types.find_hostclass(val.type.class_name)
         end
       else
         raise ArgumentError, _("Invalid argument of type '%{value_class}' to 'defined'") % { value_class: val.class }

data/lib/puppet/functions/each.rb

@@ -151,13 +151,17 @@ Puppet::Functions.create_function(:each) do
 
   def foreach_Enumerable_2(enumerable)
     enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    index = 0
-    begin
-      loop do
-        yield(index, enum.next)
-        index += 1
+    if enum.hash_style?
+      enum.each { |entry| yield(*entry) }
+    else
+      begin
+        index = 0
+        loop do
+          yield(index, enum.next)
+          index += 1
+        end
+      rescue StopIteration
       end
-    rescue StopIteration
     end
     # produces the receiver
     enumerable

data/lib/puppet/functions/filter.rb

@@ -119,19 +119,25 @@ Puppet::Functions.create_function(:filter) do
   end
 
   def filter_Enumerable_2(enumerable)
-    result = []
-    index = 0
     enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    begin
-      loop do
-        it = enum.next
-        if yield(index, it) == true
-          result << it
+    if enum.hash_style?
+      result = {}
+      enum.each { |k, v| result[k] = v if yield(k, v) == true }
+      result
+    else
+      result = []
+      begin
+        index = 0
+        loop do
+          it = enum.next
+          if yield(index, it) == true
+            result << it
+          end
+          index += 1
         end
-        index += 1
+      rescue StopIteration
       end
-    rescue StopIteration
+      result
     end
-    result
   end
 end

data/lib/puppet/functions/find_file.rb

@@ -19,7 +19,6 @@ Puppet::Functions.create_function(:find_file, Puppet::Functions::InternalFunctio
   end
 
   def find_file(scope, *args)
-    path = nil
     args.each do |file|
       found = Puppet::Parser::Files.find_file(file, scope.compiler.environment)
       if found && Puppet::FileSystem.exist?(found)

data/lib/puppet/functions/include.rb

@@ -11,6 +11,12 @@ Puppet::Functions.create_function(:include, Puppet::Functions::InternalFunction)
   end
 
   def include(scope, *classes)
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:operation => 'include'})
+    end
+
     classes = scope.transform_and_assert_classnames(classes.flatten)
     result = classes.map {|name| Puppet::Pops::Types::TypeFactory.host_class(name) }
     scope.compiler.evaluate_classes(classes, scope, false)

data/lib/puppet/functions/map.rb

@@ -107,7 +107,6 @@ Puppet::Functions.create_function(:map) do
 
   def map_Enumerable_1(enumerable)
     result = []
-    index = 0
     enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
     begin
       loop { result << yield(enum.next) }
@@ -117,16 +116,20 @@ Puppet::Functions.create_function(:map) do
   end
 
   def map_Enumerable_2(enumerable)
-    result = []
-    index = 0
     enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    begin
-      loop do
-        result << yield(index, enum.next)
-        index = index + 1
+    if enum.hash_style?
+      enum.map { |entry| yield(*entry) }
+    else
+      result = []
+      begin
+        index = 0
+        loop do
+          result << yield(index, enum.next)
+          index = index +1
+        end
+      rescue StopIteration
       end
-    rescue StopIteration
+      result
     end
-    result
   end
 end

data/lib/puppet/functions/module_directory.rb

@@ -0,0 +1,41 @@
+# Finds an existing module and returns the path to its root directory.
+#
+# The argument to this function should be a module name String
+# For example, the reference `mysql` will search for the
+# directory `<MODULES DIRECTORY>/mysql` and return the first
+# found on the modulepath.
+#
+# This function can also accept:
+#
+# * Multiple String arguments, which will return the path of the **first** module
+#  found, skipping non existing modules.
+# * An array of module names, which will return the path of the **first** module
+#  found from the given names in the array, skipping non existing modules.
+#
+# The function returns `undef` if none of the given modules were found
+#
+# @since 5.4.0
+#
+Puppet::Functions.create_function(:module_directory, Puppet::Functions::InternalFunction) do
+  dispatch :module_directory do
+    scope_param
+    repeated_param 'String', :names
+  end
+
+  dispatch :module_directory_array do
+    scope_param
+    repeated_param 'Array[String]', :names
+  end
+
+  def module_directory_array(scope, names)
+    module_directory(scope, *names)
+  end
+
+  def module_directory(scope, *names)
+    names.each do |module_name|
+      found = scope.compiler.environment.module(module_name)
+      return found.path if found
+    end
+    nil
+  end
+end

data/lib/puppet/functions/new.rb

@@ -14,10 +14,7 @@ Puppet::Functions.create_function(:new, Puppet::Functions::InternalFunction) do
 
   def new_instance(scope, t, *args)
     return args[0] if args.size == 1 && !t.is_a?(Puppet::Pops::Types::PInitType) && t.instance?(args[0])
-    result = catch :undefined_value do
-      new_function_for_type(t, scope).call(scope, *args)
-    end
-    assert_type(t, result)
+    result = assert_type(t, new_function_for_type(t, scope).call(scope, *args))
     return block_given? ? yield(result) : result
   end
 

data/lib/puppet/functions/regsubst.rb

@@ -66,7 +66,7 @@ Puppet::Functions.create_function(:regsubst) do
 
   def regsubst_regexp(target, pattern, replacement, flags = nil)
     pattern = (pattern.pattern || '') if pattern.is_a?(Puppet::Pops::Types::PRegexpType)
-    inner_regsubst(target, pattern, replacement, operation = flags == 'G' ? :gsub : :sub)
+    inner_regsubst(target, pattern, replacement, flags == 'G' ? :gsub : :sub)
   end
 
   def inner_regsubst(target, re, replacement, op)

data/lib/puppet/functions/require.rb

@@ -11,6 +11,12 @@ Puppet::Functions.create_function(:require, Puppet::Functions::InternalFunction)
   end
 
   def require_impl(scope, *classes)
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:operation => 'require'})
+    end
+
     # Make call patterns uniform and protected against nested arrays, also make
     # names absolute if so desired.
     classes = scope.transform_and_assert_classnames(classes.flatten)

data/lib/puppet/generate/type.rb

@@ -5,7 +5,7 @@ require 'puppet/generate/models/type/type'
 
 module Puppet
   module Generate
-    # Reponsible for generating type definitions in Puppet
+    # Responsible for generating type definitions in Puppet
     class Type
       # Represents an input to the type generator
       class Input

data/lib/puppet/gettext/config.rb

@@ -191,7 +191,7 @@ module Puppet::GettextConfig
   end
 
   # @api private
-  # Attempt to load tranlstions for the given project.
+  # Attempt to load translations for the given project.
   # @param [String] project_name the project whose translations we want to load
   # @param [String] locale_dir the path to the directory containing translations
   # @param [Symbol] file_format translation file format to use, either :po or :mo
@@ -218,7 +218,7 @@ module Puppet::GettextConfig
   # chain for the currently selected text domain, if needed.
   # @param [String] project_name the name of the project for which to load translations
   # @param [String] locale_dir the path to the directory containing translations
-  # @param [Symbol] file_format the fomat of the translations files, :po or :mo
+  # @param [Symbol] file_format the format of the translations files, :po or :mo
   def self.add_repository_to_domain(project_name, locale_dir, file_format, text_domain = FastGettext.text_domain)
     return if @gettext_disabled || !gettext_loaded?
 

data/lib/puppet/gettext/stubs.rb

@@ -1,4 +1,4 @@
-# These stub the translation methods noramlly brought in
+# These stub the translation methods normally brought in
 # by FastGettext. Used when Gettext could not be properly
 # initialized.
 def _(msg)

data/lib/puppet/indirector/catalog/compiler.rb

@@ -178,7 +178,6 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     # TODO: get property/parameter defaults if entries are nil in the resource
     # For now they're hard-coded to match the File type.
 
-    file_metadata = {}
     list_of_resources.each do |resource|
       sources = [resource[:source]].flatten.compact
       next unless inlineable?(resource, sources)

data/lib/puppet/indirector/file_bucket_file/file.rb

@@ -161,7 +161,11 @@ module Puppet::FileBucketFile
             if verify_identical_file(contents_file, bucket_file)
               #TRANSLATORS "FileBucket" should not be translated
               Puppet.info _("FileBucket got a duplicate file %{file_checksum}") % { file_checksum: bucket_file.checksum }
-              Puppet::FileSystem.touch(contents_file)
+              # Don't touch the contents file on Windows, since we can't update the
+              # mtime of read-only files there.
+              if !Puppet::Util::Platform.windows?
+                Puppet::FileSystem.touch(contents_file)
+              end
             elsif contents_file_matches_checksum?(contents_file, bucket_file.checksum_data, bucket_file.checksum_type)
               # If the contents or sizes don't match, but the checksum does,
               # then we've found a conflict (potential hash collision).
@@ -246,7 +250,7 @@ module Puppet::FileBucketFile
     # @return [void]
     # @api private
     def copy_bucket_file_to_contents_file(contents_file, bucket_file)
-      Puppet::FileSystem.open(contents_file, 0440, 'wb') do |of|
+      Puppet::Util.replace_file(contents_file, 0440) do |of|
         # PUP-1044 writes all of the contents
         bucket_file.stream() do |src|
           FileUtils.copy_stream(src, of)

data/lib/puppet/indirector/file_server.rb

@@ -11,7 +11,7 @@ class Puppet::Indirector::FileServer < Puppet::Indirector::Terminus
   def authorized?(request)
     return false unless [:find, :search].include?(request.method)
 
-    mount, file_path = configuration.split_path(request)
+    mount, _ = configuration.split_path(request)
 
     # If we're not serving this mount, then access is denied.
     return false unless mount

data/lib/puppet/indirector/node/ldap.rb

@@ -5,7 +5,8 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
   desc "Search in LDAP for node configuration information.  See
   the [LDAP Nodes](https://docs.puppetlabs.com/guides/ldap_nodes.html) page for more information.  This will first
   search for whatever the certificate name is, then (if that name
-  contains a `.`) for the short name, then `default`."
+  contains a `.`) for the short name, then `default`.
+  Requires ruby-ldap with MRI ruby or jruby-ldap with puppetserver/jruby"
 
   # The attributes that Puppet class information is stored in.
   def class_attributes
@@ -93,7 +94,8 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
     result[:stacked] = get_stacked_values_from_entry(entry)
     result[:parameters] = get_parameters_from_entry(entry)
 
-    result[:environment] = result[:parameters]["environment"] if result[:parameters]["environment"]
+    # delete from parameters to prevent "Already declered variable $environment" error
+    result[:environment] = result[:parameters].delete(:environment) if result[:parameters][:environment]
 
     result[:stacked_parameters] = {}
 
@@ -222,9 +224,23 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
     result.uniq
   end
 
+  # Workaround jruby-ldap 0.0.2 missing the #to_hash method
+  #
+  # @see https://github.com/jruby/jruby-ldap/pull/5
+  #
+  # @param entry [LDAP::Entry] The LDAP::Entry object to convert to a hash
+  # @return [Hash] The hash of the provided LDAP::Entry object with keys
+  #   downcased (puppet variables need to start with lowercase char)
+  def ldap_entry_to_hash(entry)
+     h = {}
+     entry.get_attributes.each { |a| h[a.downcase.to_sym] = entry[a] }
+     h[:dn] = [entry.dn]
+     h
+  end
+
   def get_parameters_from_entry(entry)
     stacked_params = stacked_attributes
-    entry.to_hash.inject({}) do |hash, ary|
+    ldap_entry_to_hash(entry).inject({}) do |hash, ary|
       unless stacked_params.include?(ary[0]) # don't add our stacked parameters to the main param list
         if ary[1].length == 1
           hash[ary[0]] = ary[1].shift

data/lib/puppet/indirector/request.rb

@@ -197,19 +197,23 @@ class Puppet::Indirector::Request
     end
 
     # ... Fall back onto the default server.
-     bound_server = Puppet.lookup(:server) do
+    begin
+      bound_server = Puppet.lookup(:server)
+    rescue
       if primary_server = Puppet.settings[:server_list][0]
-        primary_server[0]
+        bound_server = primary_server[0]
       else
-        Puppet.settings[:server]
+        bound_server = Puppet.settings[:server]
       end
     end
 
-    bound_port = Puppet.lookup(:serverport) do
+    begin
+      bound_port = Puppet.lookup(:serverport)
+    rescue
       if primary_server = Puppet.settings[:server_list][0]
-        primary_server[1]
+        bound_port = primary_server[1]
       else
-        Puppet.settings[:masterport]
+        bound_port = Puppet.settings[:masterport]
       end
     end
     self.server = default_server || bound_server