bolt 0.20.3 → 0.20.5

data/vendored/puppet/lib/puppet/parser/functions/inline_template.rb

@@ -1,6 +1,6 @@
 Puppet::Parser::Functions::newfunction(:inline_template, :type => :rvalue, :arity => -2, :doc =>
   "Evaluate a template string and return its value.  See
-  [the templating docs](https://docs.puppetlabs.com/puppet/latest/reference/lang_template.html) for
+  [the templating docs](https://puppet.com/docs/puppet/latest/lang_template.html) for
   more information. Note that if multiple template strings are specified, their
   output is all concatenated and returned as the output of the function.") do |vals|
 

data/vendored/puppet/lib/puppet/parser/functions/lest.rb

@@ -3,7 +3,7 @@ Puppet::Parser::Functions::newfunction(
   :type => :rvalue,
   :arity => -2,
   :doc => <<-DOC
-Call a [lambda](https://docs.puppet.com/puppet/latest/reference/lang_lambdas.html)
+Call a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 (which should accept no arguments) if the argument given to the function is `undef`.
 Returns the result of calling the lambda if the argument is `undef`, otherwise the
 given argument.

data/vendored/puppet/lib/puppet/parser/functions/lookup.rb

@@ -31,7 +31,7 @@ The arguments accepted by `lookup` are as follows:
     first key, it will try again with the subsequent ones, only resorting to a
     default value if none of them succeed.
 2. `<VALUE TYPE>` (data type) --- A
-[data type](https://docs.puppetlabs.com/puppet/latest/reference/lang_data_type.html)
+[data type](https://puppet.com/docs/puppet/latest/lang_data_type.html)
 that must match the retrieved value; if not, the lookup (and catalog
 compilation) will fail. Defaults to `Data` (accepts any normal value).
 3. `<MERGE BEHAVIOR>` (string or hash; see **"Merge Behaviors"** below) ---

data/vendored/puppet/lib/puppet/parser/functions/map.rb

@@ -3,7 +3,7 @@ Puppet::Parser::Functions::newfunction(
   :type => :rvalue,
   :arity => -3,
   :doc => <<-DOC
-Applies a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+Applies a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 to every value in a data structure and returns an array containing the results.
 
 This function takes two mandatory arguments, in this order:

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

@@ -3,7 +3,7 @@ Puppet::Parser::Functions::newfunction(
   :type => :rvalue,
   :arity => -3,
   :doc => <<-DOC
-Applies a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+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

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

@@ -4,7 +4,8 @@ Puppet::Parser::Functions::newfunction(
   :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 called from within a lambda the return will return from the function evaluating the lambda.
+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
@@ -63,6 +64,26 @@ 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

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

@@ -4,7 +4,7 @@ Puppet::Parser::Functions::newfunction(
   :arity => -1,
   :doc => <<-DOC
 Reverses the order of the elements of something that is iterable and optionally runs a
-[lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) for each
+[lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) for each
 element.
 
 This function takes one to two arguments:

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

@@ -4,7 +4,7 @@ Puppet::Parser::Functions::newfunction(
   :arity => -1,
   :doc => <<-DOC
 Provides stepping with given interval over elements in an iterable and optionally runs a
-[lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) for each
+[lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) for each
 element.
 
 This function takes two to three arguments:

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

@@ -3,7 +3,7 @@ Puppet::Parser::Functions::newfunction(
   :type => :rvalue,
   :arity => -2,
   :doc => <<-DOC
-Call a [lambda](https://docs.puppet.com/puppet/latest/reference/lang_lambdas.html)
+Call a [lambda](https://puppet.com/docs/puppet/latest/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.
 

data/vendored/puppet/lib/puppet/parser/functions/with.rb

@@ -3,11 +3,11 @@ Puppet::Parser::Functions::newfunction(
   :type => :rvalue,
   :arity => -1,
   :doc => <<-DOC
-Call a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+Call a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 with the given arguments and return the result. Since a lambda's scope is
-[local](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html#lambda-scope)
-to the lambda, you can use the `with` function to create private blocks of code within a
-class using variables whose values cannot be accessed outside of the lambda.
+local to the lambda, you can use the `with` function to create private blocks
+of code within a class using variables whose values cannot be accessed outside
+of the lambda.
 
 **Example**: Using `with`
 

data/vendored/puppet/lib/puppet/parser/resource.rb

@@ -8,7 +8,6 @@ class Puppet::Parser::Resource < Puppet::Resource
   require 'puppet/util/tagging'
 
   include Puppet::Util
-  include Puppet::Util::MethodHelper
   include Puppet::Util::Errors
   include Puppet::Util::Logging
 

data/vendored/puppet/lib/puppet/parser/resource/param.rb

@@ -2,14 +2,21 @@
 class Puppet::Parser::Resource::Param
   include Puppet::Util
   include Puppet::Util::Errors
-  include Puppet::Util::MethodHelper
 
   attr_accessor :name, :value, :source, :add, :file, :line
 
-  def initialize(hash)
-    set_options(hash)
-    requiredopts(:name)
-    @name = @name.intern
+  def initialize(name: nil, value: nil, source: nil, line: nil, file: nil, add: nil)
+    @value = value
+    @source = source
+    @line = line
+    @file = file
+    @add = add
+
+    unless name
+      # This must happen after file and line are set to have them reported in the error
+      self.fail(Puppet::ResourceError, "'name' is a required option for #{self.class}")
+    end
+    @name = name.intern
   end
 
   def line_to_i

data/vendored/puppet/lib/puppet/parser/scope.rb

@@ -7,8 +7,6 @@ require 'puppet/parser'
 require 'puppet/parser/templatewrapper'
 require 'puppet/parser/resource'
 
-require 'puppet/util/methodhelper'
-
 # This class is part of the internal parser/evaluator/compiler functionality of Puppet.
 # It is passed between the various classes that participate in evaluation.
 # None of its methods are API except those that are clearly marked as such.
@@ -16,7 +14,6 @@ require 'puppet/util/methodhelper'
 # @api public
 class Puppet::Parser::Scope
   extend Forwardable
-  include Puppet::Util::MethodHelper
 
   # Variables that always exist with nil value even if not set
   BUILT_IN_VARS = ['module_name'.freeze, 'caller_module_name'.freeze].freeze
@@ -374,14 +371,15 @@ class Puppet::Parser::Scope
   end
 
   # Initialize our new scope.  Defaults to having no parent.
-  def initialize(compiler, options = EMPTY_HASH)
+  def initialize(compiler, source: nil, resource: nil)
     if compiler.is_a? Puppet::Parser::AbstractCompiler
       @compiler = compiler
     else
       raise Puppet::DevError, _("you must pass a compiler instance to a new scope object")
     end
 
-    set_options(options)
+    @source = source
+    @resource = resource
 
     extend_with_functions_module
 
@@ -875,8 +873,8 @@ class Puppet::Parser::Scope
     return "Scope(#{@resource})" unless @resource.nil?
 
     # For logging of function-scope - it is now showing the file and line.
-    detail = Puppet::Pops::PuppetStack.stacktrace[0]
-    return "Scope()" unless detail.is_a?(Array)
+    detail = Puppet::Pops::PuppetStack.top_of_stack
+    return "Scope()" if detail.empty?
 
     # shorten the path if possible
     path = detail[0]

data/vendored/puppet/lib/puppet/pops/evaluator/compare_operator.rb

@@ -23,7 +23,7 @@ class CompareOperator
     @@include_visitor ||= Visitor.new(self, "include", 2, 2)
   end
 
-  def equals (a, b)
+  def equals(a, b)
     @@equals_visitor.visit_this_1(self, a, b)
   end
 
@@ -59,6 +59,8 @@ class CompareOperator
   def cmp_Numeric(a, b)
     if b.is_a?(Numeric)
       a <=> b
+    elsif b.is_a?(Time::Timespan) || b.is_a?(Time::Timestamp)
+      -(b <=> a) # compare other way and invert result
     else
       raise ArgumentError.new(_("A Numeric is not comparable to non Numeric"))
     end

data/vendored/puppet/lib/puppet/pops/evaluator/runtime3_support.rb

@@ -55,13 +55,8 @@ module Runtime3Support
   #
   def runtime_issue(issue, options={})
     # Get position from puppet runtime stack
-    stacktrace = Puppet::Pops::PuppetStack.stacktrace()
-    if stacktrace.size > 0
-      file, line = stacktrace[0]
-    else
-      file = nil
-      line = nil
-    end
+    file, line = Puppet::Pops::PuppetStack.top_of_stack
+
     # Use a SemanticError as the sourcepos
     semantic = Puppet::Pops::SemanticError.new(issue, nil, options.merge({:file => file, :line => line}))
     optionally_fail(issue,  semantic)

data/vendored/puppet/lib/puppet/pops/issues.rb

@@ -486,6 +486,10 @@ module Issues
     _("Unacceptable name. The name '%{name}' is unacceptable as the name of %{value}") % { name: name, value: label.a_an(semantic) }
   end
 
+  ILLEGAL_DEFINITION_LOCATION = issue :ILLEGAL_DEFINITION_LOCATION, :name, :file do
+    _("Unacceptable location. The name '%{name}' is unacceptable in file '%{file}'") % { name: name, file: file }
+  end
+
   CAPTURES_REST_NOT_LAST = hard_issue :CAPTURES_REST_NOT_LAST, :param_name do
     _("Parameter $%{param} is not last, and has 'captures rest'") % { param: param_name }
   end

data/vendored/puppet/lib/puppet/pops/loader/loader_paths.rb

@@ -67,7 +67,7 @@ module LoaderPaths
       @generic_path = (the_root_path.nil? ? relative_path : File.join(the_root_path, relative_path))
     end
 
-    def match_many?
+    def fuzzy_matching?
       false
     end
 
@@ -239,7 +239,7 @@ module LoaderPaths
       EMPTY_STRING
     end
 
-    def match_many?
+    def fuzzy_matching?
       true
     end
 

data/vendored/puppet/lib/puppet/pops/loader/module_loaders.rb

@@ -291,13 +291,12 @@ module ModuleLoaders
       raise NotImplementedError.new
     end
 
-    # Abstract method that subclasses override to return an array of paths that match the resolved path regardless of
-    # path extension.
+    # Abstract method that subclasses override to return an array of paths that may be associated with the resolved path.
     #
     # @param resolved_path [String] a path, without extension, resolved by a smart path against the loader's root (if it has one)
     # @return [Array<String>]
     #
-    def existing_paths(resolved_path)
+    def candidate_paths(resolved_path)
       raise NotImplementedError.new
     end
 
@@ -386,9 +385,9 @@ module ModuleLoaders
         next unless sp.valid_name?(typed_name)
         origin = sp.effective_path(typed_name, is_global ? 0 : 1)
         unless origin.nil?
-          if sp.match_many?
-            # Find all paths that starts with origin
-            origins = existing_paths(origin)
+          if sp.fuzzy_matching?
+            # Find all paths that might be related to origin
+            origins = candidate_paths(origin)
             return [origins, sp] unless origins.empty?
           else
             existing = existing_path(origin)
@@ -424,13 +423,19 @@ module ModuleLoaders
       @path_index.include?(effective_path) ? effective_path : nil
     end
 
-    def existing_paths(effective_path)
+    def candidate_paths(effective_path)
+      basename = File.basename(effective_path, '.*')
       dirname = File.dirname(effective_path)
-      basename = File.basename(effective_path)
-      # Select all paths matching `effective_path` up until an optional file extension
-      @path_index.select do |path|
-        File.basename(path, '.*') == basename &&
-          File.dirname(path) == dirname
+
+      files = @path_index.select do |path|
+        File.dirname(path) == dirname
+      end
+
+      # At least one file has to match what we're loading, or it certainly doesn't exist
+      if files.any? { |file| File.basename(file, '.*') == basename }
+        files
+      else
+        []
       end
     end
 

data/vendored/puppet/lib/puppet/pops/loader/task_instantiator.rb

@@ -3,66 +3,94 @@
 module Puppet::Pops
 module Loader
 class TaskInstantiator
-  def self.create(loader, typed_name, source_refs)
-    name = typed_name.name
-    metadata = nil
-    task_source = nil
-    source_refs.each do |source_ref|
-      if source_ref.end_with?('.json')
-        metadata = source_ref
-      elsif task_source.nil?
-        task_source = source_ref
-      else
-        raise ArgumentError, _('Only one file can exists besides the .json file for task %{name} in directory %{directory}') %
-          { name: name, directory: File.dirname(source_refs[0]) }
-      end
-    end
-
-    if task_source.nil?
-      raise ArgumentError, _('No source besides task metadata was found in directory %{directory} for task %{name}') %
-        { name: name, directory: File.dirname(source_refs[0]) }
-    end
-    create_task(loader, name, task_source, metadata)
-  end
-
-  def self.create_task(loader, name, task_source, metadata)
+  def self.load_metadata(loader, metadata)
     if metadata.nil?
-      create_task_from_hash(name, task_source, EMPTY_HASH)
+      EMPTY_HASH
     else
       json_text = loader.get_contents(metadata)
       begin
-        create_task_from_hash(name, task_source, JSON.parse(json_text) || EMPTY_HASH)
-      rescue JSON::ParserError => ex
+        Puppet::Util::Json.load(json_text).freeze || EMPTY_HASH
+      rescue Puppet::Util::Json::ParseError => ex
         raise Puppet::ParseError.new(ex.message, metadata)
-      rescue Types::TypeAssertionError => ex
-        # Not strictly a parser error but from the users perspective, the file content didn't parse properly. The
-        # ParserError also conveys file info (even though line is unknown)
-        msg = _('Failed to load metadata for task %{name}: %{reason}') % { :name => name, :reason => ex.message }
-        raise Puppet::ParseError.new(msg, metadata)
       end
     end
   end
 
-  def self.create_task_from_hash(name, task_source, hash)
+  def self.validate_implementations(typed_name, directory, metadata, executables)
+    name = typed_name.name
+    basename = typed_name.name_parts[1] || 'init'
+    # If 'implementations' is defined, it needs to mention at least one
+    # implementation, and everything it mentions must exist.
+    if metadata.key?('implementations')
+      if metadata['implementations'].is_a?(Array)
+        metadata['implementations'].map do |impl|
+          path = executables.find { |real_impl| File.basename(real_impl) == impl['name'] }
+          if path
+            { "name" => impl['name'], "requirements" => impl.fetch('requirements', []), "path" => path }
+          else
+            raise ArgumentError, _("Task metadata for task %{name} specifies missing implementation %{implementation}") %
+              { name: name, implementation: impl['name'] }
+          end
+        end
+      else
+        # If 'implementations' is the wrong type, we just pass it through and
+        # let the task type definition reject it.
+        metadata['implementations']
+      end
+    # If implementations isn't defined, then we use executables matching the
+    # task name, and only one may exist.
+    else
+      implementations = executables.select { |impl| File.basename(impl, '.*') == basename }
+      if implementations.empty?
+        raise ArgumentError, _('No source besides task metadata was found in directory %{directory} for task %{name}') %
+          { name: name, directory: directory }
+      elsif implementations.length > 1
+        raise ArgumentError, _("Multiple executables were found in directory %{directory} for task %{name}; define 'implementations' in metadata to differentiate between them") %
+          { name: name, directory: implementations[0] }
+      end
+
+      [{ "name" => File.basename(implementations.first), "path" => implementations.first, "requirements" => [] }]
+    end
+  end
+
+  def self.create(loader, typed_name, source_refs)
+    name = typed_name.name
+    basename = typed_name.name_parts[1] || 'init'
+    dirname = File.dirname(source_refs[0])
+    metadata_files, executables = source_refs.partition { |source_ref| source_ref.end_with?('.json') }
+    metadata_file = metadata_files.find { |source_ref| File.basename(source_ref, '.json') == basename }
+
+    metadata = load_metadata(loader, metadata_file)
+
+    implementation_metadata = validate_implementations(typed_name, dirname, metadata, executables)
+
     arguments = {
       'name' => name,
-      'executable' => task_source
+      'implementations' => implementation_metadata
     }
-    hash.each_pair do |key, value|
-      if 'parameters' == key || 'output' == key
-        ps = {}
-        value.each_pair do |k, v|
-          pd = v.dup
-          t = v['type']
-          pd['type'] = t.nil? ? Types::TypeFactory.data : Types::TypeParser.singleton.parse(t)
-          ps[k] = pd
+
+    begin
+      metadata.each_pair do |key, value|
+        if %w[parameters output].include?(key)
+          ps = {}
+          value.each_pair do |k, v|
+            pd = v.dup
+            t = v['type']
+            pd['type'] = t.nil? ? Types::TypeFactory.data : Types::TypeParser.singleton.parse(t)
+            ps[k] = pd
+          end
+          value = ps
         end
-        value = ps
+        arguments[key] = value unless arguments.key?(key)
       end
-      arguments[key] = value
-    end
 
-    Types::TypeFactory.task.from_hash(arguments)
+      Types::TypeFactory.task.from_hash(arguments)
+    rescue Types::TypeAssertionError => ex
+      # Not strictly a parser error but from the users perspective, the file content didn't parse properly. The
+      # ParserError also conveys file info (even though line is unknown)
+      msg = _('Failed to load metadata for task %{name}: %{reason}') % { name: name, reason: ex.message }
+      raise Puppet::ParseError.new(msg, metadata_file)
+    end
   end
 end
 end