openvox 7.37.1

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

@@ -0,0 +1,107 @@
+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/lib/puppet/pops/functions/dispatcher.rb

@@ -0,0 +1,75 @@
+# 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
+
+  def find_matching_dispatcher(args, &block)
+    @dispatchers.find { |d| d.type.callable_with?(args, block) }
+  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)
+
+    dispatcher = find_matching_dispatcher(args, &block)
+    unless dispatcher
+      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 dispatcher.argument_mismatch_handler?
+      msg = dispatcher.invoke(instance, calling_scope, args)
+      raise ArgumentError, "'#{instance.class.name}' #{msg}"
+    end
+
+    catch(:next) do
+      dispatcher.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/lib/puppet/pops/functions/function.rb

@@ -0,0 +1,139 @@
+# @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 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
+
+  # The scope where the function was defined
+  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/lib/puppet/pops/issue_reporter.rb

@@ -0,0 +1,137 @@
+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