bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/pops/functions/dispatch.rb

@@ -1,107 +0,0 @@
-module Puppet::Pops
-module Functions
-# Defines a connection between a implementation method and the signature that
-# the method will handle.
-#
-# This interface should not be used directly. Instead dispatches should be
-# constructed using the DSL defined in {Puppet::Functions}.
-#
-# @api private
-class Dispatch < Evaluator::CallableSignature
-  # @api public
-  attr_reader :type
-  # TODO: refactor to parameter_names since that makes it API
-  attr_reader :param_names
-  attr_reader :injections
-
-  # Describes how arguments are woven if there are injections, a regular argument is a given arg index, an array
-  # an injection description.
-  #
-  attr_reader :weaving
-  # @api public
-  attr_reader :block_name
-
-  # @param type [Puppet::Pops::Types::PArrayType, Puppet::Pops::Types::PTupleType] - type describing signature
-  # @param method_name [String] the name of the method that will be called when type matches given arguments
-  # @param param_names [Array<String>] names matching the number of parameters specified by type (or empty array)
-  # @param block_name [String,nil] name of block parameter, no nil
-  # @param injections [Array<Array>] injection data for weaved parameters
-  # @param weaving [Array<Integer,Array>] weaving knits
-  # @param last_captures [Boolean] true if last parameter is captures rest
-  # @param argument_mismatch_handler [Boolean] true if this is a dispatch for an argument mismatch
-  # @api private
-  def initialize(type, method_name, param_names, last_captures = false, block_name = nil, injections = EMPTY_ARRAY, weaving = EMPTY_ARRAY, argument_mismatch_handler = false)
-    @type = type
-    @method_name = method_name
-    @param_names = param_names
-    @last_captures = last_captures
-    @block_name = block_name
-    @injections = injections
-    @weaving = weaving
-    @argument_mismatch_handler = argument_mismatch_handler
-  end
-
-  # @api private
-  def parameter_names
-    @param_names
-  end
-
-  # @api private
-  def last_captures_rest?
-    @last_captures
-  end
-
-  def argument_mismatch_handler?
-    @argument_mismatch_handler
-  end
-
-  # @api private
-  def invoke(instance, calling_scope, args, &block)
-    result = instance.send(@method_name, *weave(calling_scope, args), &block)
-    return_type = @type.return_type
-    Types::TypeAsserter.assert_instance_of(nil, return_type, result) { "value returned from function '#{@method_name}'" } unless return_type.nil?
-    result
-  end
-
-  # @api private
-  def weave(scope, args)
-    # no need to weave if there are no injections
-    if @injections.empty?
-      args
-    else
-      new_args = []
-      @weaving.each do |knit|
-        if knit.is_a?(Array)
-          injection_name = @injections[knit[0]]
-          new_args <<
-            case injection_name
-            when :scope
-              scope
-            when :pal_script_compiler
-              Puppet.lookup(:pal_script_compiler)
-            when :cache
-              Puppet::Pops::Adapters::ObjectIdCacheAdapter.adapt(scope.compiler)
-            when :pal_catalog_compiler
-              Puppet.lookup(:pal_catalog_compiler)
-            when :pal_compiler
-              Puppet.lookup(:pal_compiler)
-            else
-              raise ArgumentError, _("Unknown injection %{injection_name}") % { injection_name: injection_name }
-            end
-        else
-          # Careful so no new nil arguments are added since they would override default
-          # parameter values in the received
-          if knit < 0
-            idx = -knit - 1
-            new_args += args[idx..-1] if idx < args.size
-          else
-            new_args << args[knit] if knit < args.size
-          end
-        end
-      end
-      new_args
-    end
-  end
-end
-end
-end

data/vendored/puppet/lib/puppet/pops/functions/dispatcher.rb

@@ -1,71 +0,0 @@
-# Evaluate the dispatches defined as {Puppet::Pops::Functions::Dispatch}
-# instances to call the appropriate method on the
-# {Puppet::Pops::Functions::Function} instance.
-#
-# @api private
-class Puppet::Pops::Functions::Dispatcher
-  attr_reader :dispatchers
-
-  # @api private
-  def initialize()
-    @dispatchers = [ ]
-  end
-
-  # Answers if dispatching has been defined
-  # @return [Boolean] true if dispatching has been defined
-  #
-  # @api private
-  def empty?
-    @dispatchers.empty?
-  end
-
-  # Dispatches the call to the first found signature (entry with matching type).
-  #
-  # @param instance [Puppet::Functions::Function] - the function to call
-  # @param calling_scope [T.B.D::Scope] - the scope of the caller
-  # @param args [Array<Object>] - the given arguments in the form of an Array
-  # @return [Object] - what the called function produced
-  #
-  # @api private
-  def dispatch(instance, calling_scope, args, &block)
-    found = @dispatchers.find { |d| d.type.callable_with?(args, block) }
-    unless found
-      args_type = Puppet::Pops::Types::TypeCalculator.singleton.infer_set(block_given? ? args + [block] : args)
-      raise ArgumentError, Puppet::Pops::Types::TypeMismatchDescriber.describe_signatures(instance.class.name, signatures, args_type)
-    end
-
-    if found.argument_mismatch_handler?
-      msg = found.invoke(instance, calling_scope, args)
-      raise ArgumentError, "'#{instance.class.name}' #{msg}"
-    end
-
-    catch(:next) do
-      found.invoke(instance, calling_scope, args, &block)
-    end
-  end
-
-  # Adds a dispatch directly to the set of dispatchers.
-  # @api private
-  def add(a_dispatch)
-    @dispatchers << a_dispatch
-  end
-
-  # Produces a CallableType for a single signature, and a Variant[<callables>] otherwise
-  #
-  # @api private
-  def to_type()
-    # make a copy to make sure it can be contained by someone else (even if it is not contained here, it
-    # should be treated as immutable).
-    #
-    callables = dispatchers.map { | dispatch | dispatch.type }
-
-    # multiple signatures, produce a Variant type of Callable1-n (must copy them)
-    # single signature, produce single Callable
-    callables.size > 1 ?  Puppet::Pops::Types::TypeFactory.variant(*callables) : callables.pop
-  end
-
-  # @api private
-  def signatures
-    @dispatchers.reject { |dispatcher| dispatcher.argument_mismatch_handler? }
-  end
-end

data/vendored/puppet/lib/puppet/pops/functions/function.rb

@@ -1,141 +0,0 @@
-# @note WARNING: This new function API is still under development and may change at
-#   any time
-#
-# A function in the puppet evaluator.
-#
-# Functions are normally defined by another system, which produces subclasses
-# of this class as well as constructing delegations to call the appropriate methods.
-#
-# This class should rarely be used directly. Instead functions should be
-# constructed using {Puppet::Functions.create_function}.
-#
-# @api public
-class Puppet::Pops::Functions::Function
-  # The scope where the function was defined
-  attr_reader :closure_scope
-
-  # The loader that loaded this function.
-  # Should be used if function wants to load other things.
-  #
-  attr_reader :loader
-
-  def initialize(closure_scope, loader)
-    @closure_scope = closure_scope
-    @loader = loader
-  end
-
-  # Invokes the function via the dispatching logic that performs type check and weaving.
-  # A specialized function may override this method to do its own dispatching and checking of
-  # the raw arguments. A specialized implementation can rearrange arguments, add or remove
-  # arguments and then delegate to the dispatching logic by calling:
-  #
-  # @example Delegating to the dispatcher
-  #     def call(scope, *args)
-  #       manipulated_args = args + ['easter_egg']
-  #       self.class.dispatcher.dispatch(self, scope, manipulated_args)
-  #     end
-  #
-  # System functions that must have access to the calling scope can use this technique. Functions
-  # in general should not need the calling scope. (The closure scope; what is visible where the function
-  # is defined) is available via the method `closure_scope`).
-  #
-  # @api public
-  def call(scope, *args, &block)
-    begin
-      result = catch(:return) do
-        return self.class.dispatcher.dispatch(self, scope, args, &block)
-      end
-      return result.value
-    rescue Puppet::Pops::Evaluator::Next => jumper
-      begin
-        throw :next, jumper.value
-      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION
-        raise Puppet::ParseError.new("next() from context where this is illegal", jumper.file, jumper.line)
-      end
-    rescue Puppet::Pops::Evaluator::Return => jumper
-      begin
-        throw :return, jumper
-      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION
-        raise Puppet::ParseError.new("return() from context where this is illegal", jumper.file, jumper.line)
-      end
-    end
-  end
-
-  # Allows the implementation of a function to call other functions by name. The callable functions
-  # are those visible to the same loader that loaded this function (the calling function). The
-  # referenced function is called with the calling functions closure scope as the caller's scope.
-  #
-  # @param function_name [String] The name of the function
-  # @param *args [Object] splat of arguments
-  # @return [Object] The result returned by the called function
-  #
-  # @api public
-  def call_function(function_name, *args, &block)
-    internal_call_function(closure_scope, function_name, args, &block)
-  end
-
-  def closure_scope
-    # If closure scope is explicitly set to not nil, if there is a global scope, otherwise an empty hash
-    @closure_scope || Puppet.lookup(:global_scope) { {} }
-  end
-
-  # The dispatcher for the function
-  #
-  # @api private
-  def self.dispatcher
-    @dispatcher ||= Puppet::Pops::Functions::Dispatcher.new
-  end
-
-  # Produces information about parameters in a way that is compatible with Closure
-  #
-  # @api private
-  def self.signatures
-    @dispatcher.signatures
-  end
-
-  protected
-
-  # Allows the implementation of a function to call other functions by name and pass the caller
-  # scope. The callable functions are those visible to the same loader that loaded this function
-  # (the calling function).
-  #
-  # @param scope [Puppet::Parser::Scope] The caller scope
-  # @param function_name [String] The name of the function
-  # @param args [Array] array of arguments
-  # @return [Object] The result returned by the called function
-  #
-  # @api public
-  def internal_call_function(scope, function_name, args, &block)
-
-    the_loader = loader
-    unless the_loader
-      raise ArgumentError, _("Function %{class_name}(): cannot call function '%{function_name}' - no loader specified") %
-          { class_name: self.class.name, function_name: function_name }
-    end
-
-    func = the_loader.load(:function, function_name)
-    if func
-      Puppet::Util::Profiler.profile(function_name, [:functions, function_name]) do
-        return func.call(scope, *args, &block)
-      end
-    end
-
-    # Check if a 3x function is present. Raise a generic error if it's not to allow upper layers to fill in the details
-    # about where in a puppet manifest this error originates. (Such information is not available here).
-    loader_scope = closure_scope
-    func_3x = Puppet::Parser::Functions.function(function_name, loader_scope.environment) if loader_scope.is_a?(Puppet::Parser::Scope)
-    unless func_3x
-      raise ArgumentError, _("Function %{class_name}(): Unknown function: '%{function_name}'") %
-          { class_name: self.class.name, function_name: function_name }
-    end
-
-    # Call via 3x API
-    # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
-    # NOTE: Passing an empty string last converts nil/:undef to empty string
-    result = scope.send(func_3x, Puppet::Pops::Evaluator::Runtime3FunctionArgumentConverter.map_args(args, loader_scope, ''), &block)
-
-    # Prevent non r-value functions from leaking their result (they are not written to care about this)
-    Puppet::Parser::Functions.rvalue?(function_name) ? result : nil
-  end
-
-end

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

@@ -1,137 +0,0 @@
-module Puppet::Pops
-class IssueReporter
-
-  # @param acceptor [Validation::Acceptor] the acceptor containing reported issues
-  # @option options [String] :message (nil) A message text to use as prefix in
-  #   a single Error message
-  # @option options [Boolean] :emit_warnings (false) whether warnings should be emitted
-  # @option options [Boolean] :emit_errors (true) whether errors should be
-  #   emitted or only the given message
-  # @option options [Exception] :exception_class (Puppet::ParseError) The exception to raise
-  #
-  def self.assert_and_report(acceptor, options)
-    return unless acceptor
-
-    max_errors       = options[:max_errors]   || Puppet[:max_errors]
-    max_warnings     = options[:max_warnings] || Puppet[:max_warnings]
-    max_deprecations = options[:max_deprecations] || (Puppet[:disable_warnings].include?('deprecations') ? 0 : Puppet[:max_deprecations])
-
-    emit_warnings    = options[:emit_warnings] || false
-    emit_errors      = options[:emit_errors].nil? ? true : !!options[:emit_errors]
-    emit_message     = options[:message]
-    emit_exception   = options[:exception_class] || Puppet::ParseErrorWithIssue
-
-    # If there are warnings output them
-    warnings = acceptor.warnings
-    if emit_warnings && warnings.size > 0
-      formatter = Validation::DiagnosticFormatterPuppetStyle.new
-      emitted_w = 0
-      emitted_dw = 0
-      acceptor.warnings.each do |w|
-        if w.severity == :deprecation
-          # Do *not* call Puppet.deprecation_warning it is for internal deprecation, not
-          # deprecation of constructs in manifests! (It is not designed for that purpose even if
-          # used throughout the code base).
-          #
-          log_message(:warning, formatter, w) if emitted_dw < max_deprecations
-          emitted_dw += 1
-        else
-          log_message(:warning, formatter, w) if emitted_w < max_warnings
-          emitted_w += 1
-        end
-        break if emitted_w >= max_warnings && emitted_dw >= max_deprecations # but only then
-      end
-    end
-
-    # If there were errors, report the first found. Use a puppet style formatter.
-    errors = acceptor.errors
-    if errors.size > 0
-      unless emit_errors
-        raise emit_exception.new(emit_message)
-      end
-      formatter = Validation::DiagnosticFormatterPuppetStyle.new
-      if errors.size == 1 || max_errors <= 1
-        # raise immediately
-        exception = create_exception(emit_exception, emit_message, formatter, errors[0])
-        # if an exception was given as cause, use it's backtrace instead of the one indicating "here"
-        if errors[0].exception
-          exception.set_backtrace(errors[0].exception.backtrace)
-        end
-        raise exception
-      end
-      emitted = 0
-      if emit_message
-        Puppet.err(emit_message)
-      end
-      errors.each do |e|
-        log_message(:err, formatter, e)
-        emitted += 1
-        break if emitted >= max_errors
-      end
-      giving_up_message = if (emit_warnings && warnings.size > 0)
-                            _("Language validation logged %{error_count} errors, and %{warning_count} warnings. Giving up") %
-                                { error_count: errors.size, warning_count: warnings.size }
-                          else
-                            _("Language validation logged %{error_count} errors. Giving up") %
-                                { error_count: errors.size }
-                          end
-      exception = emit_exception.new(giving_up_message)
-      exception.file = errors[0].file
-      raise exception
-    end
-  end
-
-  def self.format_with_prefix(prefix, message)
-    return message unless prefix
-    [prefix, message].join(' ')
-  end
-
-  def self.warning(semantic, issue, args)
-    Puppet::Util::Log.create({
-      :level => :warning,
-      :message => issue.format(args),
-      :arguments => args,
-      :issue_code => issue.issue_code,
-      :file => semantic.file,
-      :line => semantic.line,
-      :pos => semantic.pos,
-    })
-  end
-
-  def self.error(exception_class, semantic, issue, args)
-    raise exception_class.new(issue.format(args), semantic.file, semantic.line, semantic.pos, nil, issue.issue_code, args)
-  end
-
-  def self.create_exception(exception_class, emit_message, formatter, diagnostic)
-    file = diagnostic.file
-    file = (file.is_a?(String) && file.empty?) ? nil : file
-    line = pos = nil
-    if diagnostic.source_pos
-      line = diagnostic.source_pos.line
-      pos = diagnostic.source_pos.pos
-    end
-    exception_class.new(format_with_prefix(emit_message, formatter.format_message(diagnostic)), file, line, pos, nil, diagnostic.issue.issue_code, diagnostic.arguments)
-  end
-  private_class_method :create_exception
-
-  def self.log_message(severity, formatter, diagnostic)
-    file = diagnostic.file
-    file = (file.is_a?(String) && file.empty?) ? nil : file
-    line = pos = nil
-    if diagnostic.source_pos
-      line = diagnostic.source_pos.line
-      pos = diagnostic.source_pos.pos
-    end
-    Puppet::Util::Log.create({
-        :level => severity,
-        :message => formatter.format_message(diagnostic),
-        :arguments => diagnostic.arguments,
-        :issue_code => diagnostic.issue.issue_code,
-        :file => file,
-        :line => line,
-        :pos => pos,
-      })
-  end
-  private_class_method :log_message
-end
-end