openvox 7.37.1

data/lib/puppet/pops/evaluator/external_syntax_support.rb

@@ -0,0 +1,46 @@
+# This module is an integral part of the evaluator. It deals with the concern of validating
+# external syntax in text produced by heredoc and templates.
+#
+require_relative '../../../puppet/plugins/syntax_checkers'
+module Puppet::Pops::Evaluator::ExternalSyntaxSupport
+  def assert_external_syntax(_, result, syntax, reference_expr)
+    # ignore 'unspecified syntax'
+    return if syntax.nil? || syntax == ''
+
+    checker = checker_for_syntax(nil, syntax)
+    # ignore syntax with no matching checker
+    return unless checker
+
+    # Call checker and give it the location information from the expression
+    # (as opposed to where the heredoc tag is (somewhere on the line above)).
+    acceptor = Puppet::Pops::Validation::Acceptor.new()
+    checker.check(result, syntax, acceptor, reference_expr)
+
+    if acceptor.error_count > 0
+      checker_message = "Invalid produced text having syntax: '#{syntax}'."
+      Puppet::Pops::IssueReporter.assert_and_report(acceptor, :message => checker_message)
+      raise ArgumentError, _("Internal Error: Configuration of runtime error handling wrong: should have raised exception")
+    end
+  end
+
+  # Finds the most significant checker for the given syntax (most significant is to the right).
+  # Returns nil if there is no registered checker.
+  #
+  def checker_for_syntax(_, syntax)
+    checkers_hash = Puppet.lookup(:plugins)[Puppet::Plugins::SyntaxCheckers::SYNTAX_CHECKERS_KEY]
+    checkers_hash[lookup_keys_for_syntax(syntax).find {|x| checkers_hash[x] }]
+  end
+
+  # Returns an array of possible syntax names
+  def lookup_keys_for_syntax(syntax)
+    segments = syntax.split(/\+/)
+    result = []
+    loop do
+      result << segments.join("+")
+      segments.shift
+      break if segments.empty?
+    end
+    result
+  end
+
+end

data/lib/puppet/pops/evaluator/json_strict_literal_evaluator.rb

@@ -0,0 +1,82 @@
+# Literal values for
+#
+#   * String
+#   * Numbers
+#   * Booleans
+#   * Undef (produces nil)
+#   * Array
+#   * Hash where keys must be Strings
+#   * QualifiedName
+#
+# Not considered literal:
+#
+#   * QualifiedReference  # i.e. File, FooBar
+#   * Default is not accepted as being literal
+#   * Regular Expression is not accepted as being literal
+#   * Hash with non String keys
+#   * String with interpolation
+#
+class Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator
+  #include Puppet::Pops::Utils
+
+  COMMA_SEPARATOR = ', '.freeze
+
+  def initialize
+    @@literal_visitor ||= Puppet::Pops::Visitor.new(self, "literal", 0, 0)
+  end
+
+  def literal(ast)
+    @@literal_visitor.visit_this_0(self, ast)
+  end
+
+  def literal_Object(o)
+    throw :not_literal
+  end
+
+  def literal_Factory(o)
+    literal(o.model)
+  end
+
+  def literal_Program(o)
+    literal(o.body)
+  end
+
+  def literal_LiteralString(o)
+    o.value
+  end
+
+  def literal_QualifiedName(o)
+    o.value
+  end
+
+  def literal_LiteralNumber(o)
+    o.value
+  end
+
+  def literal_LiteralBoolean(o)
+    o.value
+  end
+
+  def literal_LiteralUndef(o)
+    nil
+  end
+
+  def literal_ConcatenatedString(o)
+    # use double quoted string value if there is no interpolation
+    throw :not_literal unless o.segments.size == 1 && o.segments[0].is_a?(Puppet::Pops::Model::LiteralString)
+    o.segments[0].value
+  end
+
+  def literal_LiteralList(o)
+    o.values.map {|v| literal(v) }
+  end
+
+  def literal_LiteralHash(o)
+    o.entries.reduce({}) do |result, entry|
+      key = literal(entry.key)
+      throw :not_literal unless key.is_a?(String)
+      result[key] = literal(entry.value)
+      result
+    end
+  end
+end

data/lib/puppet/pops/evaluator/literal_evaluator.rb

@@ -0,0 +1,100 @@
+module Puppet::Pops
+module Evaluator
+# Literal values for
+# String (not containing interpolation)
+# Numbers
+# Booleans
+# Undef (produces nil)
+# Array
+# Hash
+# QualifiedName
+# Default (produced :default)
+# Regular Expression (produces ruby regular expression)
+# QualifiedReference
+# AccessExpresion
+#
+class LiteralEvaluator
+
+  COMMA_SEPARATOR = ', '.freeze
+
+  def initialize
+    @@literal_visitor ||= Visitor.new(self, "literal", 0, 0)
+  end
+
+  def literal(ast)
+    @@literal_visitor.visit_this_0(self, ast)
+  end
+
+  def literal_Object(o)
+    throw :not_literal
+  end
+
+  def literal_Factory(o)
+    literal(o.model)
+  end
+
+  def literal_Program(o)
+    literal(o.body)
+  end
+
+  def literal_LiteralString(o)
+    o.value
+  end
+
+  def literal_QualifiedName(o)
+    o.value
+  end
+
+  def literal_LiteralNumber(o)
+    o.value
+  end
+
+  def literal_LiteralBoolean(o)
+    o.value
+  end
+
+  def literal_LiteralUndef(o)
+    nil
+  end
+
+  def literal_LiteralDefault(o)
+    :default
+  end
+
+  def literal_LiteralRegularExpression(o)
+    o.value
+  end
+
+  def literal_QualifiedReference(o)
+    o.value
+  end
+
+  def literal_AccessExpression(o)
+    # to prevent parameters with [[]] like Optional[[String]]
+    throw :not_literal if o.keys.size == 1 && o.keys[0].is_a?(Model::LiteralList)
+    o.keys.map { |v| literal(v) }
+  end
+
+  def literal_UnaryMinusExpression(o)
+    -literal(o.expr)
+  end
+
+  def literal_ConcatenatedString(o)
+    # use double quoted string value if there is no interpolation
+    throw :not_literal unless o.segments.size == 1 && o.segments[0].is_a?(Model::LiteralString)
+    o.segments[0].value
+  end
+
+  def literal_LiteralList(o)
+    o.values.map {|v| literal(v) }
+  end
+
+  def literal_LiteralHash(o)
+    o.entries.reduce({}) do |result, entry|
+      result[literal(entry.key)] = literal(entry.value)
+      result
+    end
+  end
+end
+end
+end

data/lib/puppet/pops/evaluator/puppet_proc.rb

@@ -0,0 +1,69 @@
+# Complies with Proc API by mapping a Puppet::Pops::Evaluator::Closure to a ruby Proc.
+# Creating and passing an instance of this class instead of just a plain block makes
+# it possible to inherit the parameter info and arity from the closure. Advanced users
+# may also access the closure itself. The Puppet::Pops::Functions::Dispatcher uses this
+# when it needs to get the Callable type of the closure.
+#
+# The class is part of the Puppet Function API for Ruby and thus public API but a user
+# should never create an instance of this class.
+#
+# @api public
+class Puppet::Pops::Evaluator::PuppetProc < Proc
+  # Creates a new instance from a closure and a block that will dispatch
+  # all parameters to the closure. The block must be similar to:
+  #
+  #   { |*args| closure.call(*args) }
+  #
+  # @param closure [Puppet::Pops::Evaluator::Closure] The closure to map
+  # @param &block [Block] The varargs block that invokes the closure.call method
+  #
+  # @api private
+  def self.new(closure, &block)
+    proc = super(&block)
+    proc.instance_variable_set(:@closure, closure)
+    proc
+  end
+
+  # @return  [Puppet::Pops::Evaluator::Closure] the mapped closure
+  # @api public
+  attr_reader :closure
+
+  # @overrides Block.lambda?
+  # @return [Boolean] always false since this proc doesn't do the Ruby lambda magic
+  # @api public
+  def lambda?
+    false
+  end
+
+  # Maps the closure parameters to standard Block parameter info where each
+  # parameter is represented as a two element Array where the first
+  # element is :req, :opt, or :rest and the second element is the name
+  # of the parameter.
+  #
+  # @return [Array<Array<Symbol>>] array of parameter info pairs
+  # @overrides Block.parameters
+  # @api public
+  def parameters
+    @closure.parameters.map do |param|
+      sym = param.name.to_sym
+      if param.captures_rest
+        [ :rest, sym ]
+      elsif param.value
+        [ :opt, sym ]
+      else
+        [ :req, sym ]
+      end
+    end
+  end
+
+  # @return [Integer] the arity of the block
+  # @overrides Block.arity
+  # @api public
+  def arity
+    parameters.reduce(0) do |memo, param|
+      count = memo + 1
+      break -count unless param[0] == :req
+      count
+    end
+  end
+end

data/lib/puppet/pops/evaluator/relationship_operator.rb

@@ -0,0 +1,185 @@
+module Puppet::Pops
+module Evaluator
+# The RelationshipOperator implements the semantics of the -> <- ~> <~ operators creating relationships or notification
+# relationships between the left and right hand side's references to resources.
+#
+# This is separate class since a second level of evaluation is required that transforms string in left or right hand
+# to type references. The task of "making a relationship" is delegated to the "runtime support" class that is included.
+# This is done to separate the concerns of the new evaluator from the 3x runtime; messy logic goes into the runtime support
+# module. Later when more is cleaned up this can be simplified further.
+#
+class RelationshipOperator
+
+  # Provides access to the Puppet 3.x runtime (scope, etc.)
+  # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
+  #
+  include Runtime3Support
+
+  class IllegalRelationshipOperandError < RuntimeError
+    attr_reader :operand
+    def initialize operand
+      @operand = operand
+    end
+  end
+
+  class NotCatalogTypeError < RuntimeError
+    attr_reader :type
+    def initialize type
+      @type = type
+    end
+  end
+
+  def initialize
+    @type_transformer_visitor = Visitor.new(self, "transform", 1, 1)
+    @type_calculator = Types::TypeCalculator.new()
+
+    tf = Types::TypeFactory
+    @catalog_type = tf.variant(tf.catalog_entry, tf.type_type(tf.catalog_entry))
+  end
+
+  def transform(o, scope)
+    @type_transformer_visitor.visit_this_1(self, o, scope)
+  end
+
+  # Catch all non transformable objects
+  # @api private
+  def transform_Object(o, scope)
+    raise IllegalRelationshipOperandError.new(o)
+  end
+
+  # A Resource is by definition a Catalog type, but of 3.x type
+  # @api private
+  def transform_Resource(o, scope)
+    Types::TypeFactory.resource(o.type, o.title)
+  end
+
+  # A string must be a type reference in string format
+  # @api private
+  def transform_String(o, scope)
+    assert_catalog_type(Types::TypeParser.singleton.parse(o), scope)
+  end
+
+  # A qualified name is short hand for a class with this name
+  # @api private
+  def transform_QualifiedName(o, scope)
+    Types::TypeFactory.host_class(o.value)
+  end
+
+  # Types are what they are, just check the type
+  # @api private
+  def transform_PAnyType(o, scope)
+    assert_catalog_type(o, scope)
+  end
+
+  # This transforms a 3x Collector (the result of evaluating a 3x AST::Collection).
+  # It is passed through verbatim since it is evaluated late by the compiler. At the point
+  # where the relationship is evaluated, it is simply recorded with the compiler for later evaluation.
+  # If one of the sides of the relationship is a Collector it is evaluated before the actual
+  # relationship is formed. (All of this happens at a later point in time.
+  #
+  def transform_Collector(o, scope)
+    o
+  end
+
+  def transform_AbstractCollector(o, scope)
+    o
+  end
+
+  # Array content needs to be transformed
+  def transform_Array(o, scope)
+    o.map{|x| transform(x, scope) }
+  end
+
+  # Asserts (and returns) the type if it is a PCatalogEntryType
+  # (A PCatalogEntryType is the base class of PClassType, and PResourceType).
+  #
+  def assert_catalog_type(o, scope)
+    unless @type_calculator.assignable?(@catalog_type, o)
+      raise NotCatalogTypeError.new(o)
+    end
+    # TODO must check if this is an abstract PResourceType (i.e. without a type_name) - which should fail ?
+    # e.g. File -> File (and other similar constructs) - maybe the catalog protects against this since references
+    # may be to future objects...
+    o
+  end
+
+  RELATIONSHIP_OPERATORS = ['->', '~>', '<-', '<~'].freeze
+  REVERSE_OPERATORS      = ['<-', '<~'].freeze
+  RELATION_TYPE = {
+    '->' => :relationship,
+    '<-' => :relationship,
+    '~>' => :subscription,
+    '<~' => :subscription
+  }.freeze
+
+  # Evaluate a relationship.
+  # TODO: The error reporting is not fine grained since evaluation has already taken place
+  # There is no references to the original source expressions at this point, only the overall
+  # relationship expression. (e.g.. the expression may be ['string', func_call(), etc.] -> func_call())
+  # To implement this, the general evaluator needs to be able to track each evaluation result and associate
+  # it with a corresponding expression. This structure should then be passed to the relationship operator.
+  #
+  def evaluate(left_right_evaluated, relationship_expression, scope)
+    # assert operator (should have been validated, but this logic makes assumptions which would
+    # screw things up royally). Better safe than sorry.
+    unless RELATIONSHIP_OPERATORS.include?(relationship_expression.operator)
+      fail(Issues::UNSUPPORTED_OPERATOR, relationship_expression, {:operator => relationship_expression.operator})
+    end
+
+    begin
+      # Turn each side into an array of types (this also asserts their type)
+      # (note wrap in array first if value is not already an array)
+      #
+      # TODO: Later when objects are Puppet Runtime Objects and know their type, it will be more efficient to check/infer
+      # the type first since a chained operation then does not have to visit each element again. This is not meaningful now
+      # since inference needs to visit each object each time, and this is what the transformation does anyway).
+      #
+      # real is [left, right], and both the left and right may be a single value or an array. In each case all content
+      # should be flattened, and then transformed to a type. left or right may also be a value that is transformed
+      # into an array, and thus the resulting left and right must be flattened individually
+      # Once flattened, the operands should be sets (to remove duplicate entries)
+      #
+      real = left_right_evaluated.collect {|x| [x].flatten.collect {|y| transform(y, scope) }}
+      real[0].flatten!
+      real[1].flatten!
+      real[0].uniq!
+      real[1].uniq!
+
+      # reverse order if operator is Right to Left
+      source, target = reverse_operator?(relationship_expression) ? real.reverse : real
+
+      # Add the relationships to the catalog
+      source.each {|s| target.each {|t| add_relationship(s, t, RELATION_TYPE[relationship_expression.operator], scope) }}
+
+      # The result is the transformed source RHS unless it is empty, in which case the transformed LHS is returned.
+      # This closes the gap created by an empty set of references in a chain of relationship
+      # such that X -> [ ] -> Y results in  X -> Y.
+      #result = real[1].empty? ? real[0] : real[1]
+      if real[1].empty?
+        # right side empty, simply use the left (whatever it may be)
+        result = real[0]
+      else
+        right = real[1]
+        if right.size == 1 && right[0].is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
+          # the collector when evaluated later may result in an empty set, if so, the
+          # lazy relationship forming logic needs to have access to the left value.
+          adapter = Puppet::Pops::Adapters::EmptyAlternativeAdapter.adapt(right[0])
+          adapter.empty_alternative = real[0]
+        end
+        result = right
+      end
+      result
+
+    rescue NotCatalogTypeError => e
+      fail(Issues::NOT_CATALOG_TYPE, relationship_expression, {:type => @type_calculator.string(e.type)})
+    rescue IllegalRelationshipOperandError => e
+      fail(Issues::ILLEGAL_RELATIONSHIP_OPERAND_TYPE, relationship_expression, {:operand => e.operand})
+    end
+  end
+
+  def reverse_operator?(o)
+    REVERSE_OPERATORS.include?(o.operator)
+  end
+end
+end
+end

data/lib/puppet/pops/evaluator/runtime3_converter.rb

@@ -0,0 +1,221 @@
+module Puppet::Pops::Evaluator
+# Converts nested 4x supported values to 3x values. This is required because
+# resources and other objects do not know about the new type system, and does not support
+# regular expressions. Unfortunately this has to be done for array and hash as well.
+# A complication is that catalog types needs to be resolved against the scope.
+#
+# Users should not create instances of this class. Instead the class methods {Runtime3Converter.convert},
+# {Runtime3Converter.map_args}, or {Runtime3Converter.instance} should be used
+class Runtime3Converter
+  MAX_INTEGER =  Puppet::Pops::MAX_INTEGER
+  MIN_INTEGER = Puppet::Pops::MIN_INTEGER
+
+  # Converts 4x supported values to a 3x values. Same as calling Runtime3Converter.instance.map_args(...)
+  #
+  # @param args [Array] Array of values to convert
+  # @param scope [Puppet::Parser::Scope] The scope to use when converting
+  # @param undef_value [Object] The value that nil is converted to
+  # @return [Array] The converted values
+  #
+  def self.map_args(args, scope, undef_value)
+    @instance.map_args(args, scope, undef_value)
+  end
+
+  # Converts 4x supported values to a 3x values. Same as calling Runtime3Converter.instance.convert(...)
+  #
+  # @param o [Object]The value to convert
+  # @param scope [Puppet::Parser::Scope] The scope to use when converting
+  # @param undef_value [Object] The value that nil is converted to
+  # @return [Object] The converted value
+  #
+  def self.convert(o, scope, undef_value)
+    @instance.convert(o, scope, undef_value)
+  end
+
+  # Returns the singleton instance of this class.
+  # @return [Runtime3Converter] The singleton instance
+  def self.instance
+    @instance
+  end
+
+  # Converts 4x supported values to a 3x values.
+  #
+  # @param args [Array] Array of values to convert
+  # @param scope [Puppet::Parser::Scope] The scope to use when converting
+  # @param undef_value [Object] The value that nil is converted to
+  # @return [Array] The converted values
+  #
+  def map_args(args, scope, undef_value)
+    args.map {|a| convert(a, scope, undef_value) }
+  end
+
+  # Converts a 4x supported value to a 3x value.
+  #
+  # @param o [Object]The value to convert
+  # @param scope [Puppet::Parser::Scope] The scope to use when converting
+  # @param undef_value [Object] The value that nil is converted to
+  # @return [Object] The converted value
+  #
+  def convert(o, scope, undef_value)
+    @convert_visitor.visit_this_2(self, o, scope, undef_value)
+  end
+
+  def convert_NilClass(o, scope, undef_value)
+    @inner ? nil : undef_value
+  end
+
+  def convert_Integer(o, scope, undef_value)
+    return o unless o < MIN_INTEGER || o > MAX_INTEGER
+    range_end = o > MAX_INTEGER ? 'max' : 'min'
+    raise Puppet::Error, "Use of a Ruby Integer outside of Puppet Integer #{range_end} range, got '#{"0x%x" % o}'"
+  end
+
+  def convert_BigDecimal(o, scope, undef_value)
+    # transform to same value float value if possible without any rounding error
+    f = o.to_f
+    return f unless f != o
+    raise Puppet::Error, "Use of a Ruby BigDecimal value outside Puppet Float range, got '#{o}'"
+  end
+
+  def convert_String(o, scope, undef_value)
+    # Although wasteful, a dup is needed because user code may mutate these strings when applying
+    # Resources. This does not happen when in server mode since it only uses Resources that are
+    # in puppet core and those are all safe.
+    o.frozen? && !Puppet.run_mode.server? ? o.dup : o
+  end
+
+  def convert_Object(o, scope, undef_value)
+    o
+  end
+
+  def convert_Array(o, scope, undef_value)
+    ic = @inner_converter
+    o.map {|x| ic.convert(x, scope, undef_value) }
+  end
+
+  def convert_Hash(o, scope, undef_value)
+    result = {}
+    ic = @inner_converter
+    o.each {|k,v| result[ic.convert(k, scope, undef_value)] = ic.convert(v, scope, undef_value) }
+    result
+  end
+
+  def convert_Iterator(o, scope, undef_value)
+    raise Puppet::Error, _('Use of an Iterator is not supported here')
+  end
+
+  def convert_Symbol(o, scope, undef_value)
+    return o unless o == :undef
+    !@inner ? undef_value : nil
+  end
+
+  def convert_PAnyType(o, scope, undef_value)
+    o
+  end
+
+  def convert_PCatalogEntryType(o, scope, undef_value)
+    # Since 4x does not support dynamic scoping, all names are absolute and can be
+    # used as is (with some check/transformation/mangling between absolute/relative form
+    # due to Puppet::Resource's idiosyncratic behavior where some references must be
+    # absolute and others cannot be.
+    # Thus there is no need to call scope.resolve_type_and_titles to do dynamic lookup.
+    t, title = catalog_type_to_split_type_title(o)
+    t = Runtime3ResourceSupport.find_resource_type(scope, t) unless t == 'class' || t == 'node'
+    Puppet::Resource.new(t, title)
+  end
+
+  # Produces an array with [type, title] from a PCatalogEntryType
+  # This method is used to produce the arguments for creation of reference resource instances
+  # (used when 3x is operating on a resource).
+  # Ensures that resources are *not* absolute.
+  #
+  def catalog_type_to_split_type_title(catalog_type)
+    split_type = catalog_type.is_a?(Puppet::Pops::Types::PTypeType) ? catalog_type.type : catalog_type
+    case split_type
+      when Puppet::Pops::Types::PClassType
+        class_name = split_type.class_name
+        ['class', class_name.nil? ? nil : class_name.sub(/^::/, '')]
+      when Puppet::Pops::Types::PResourceType
+        type_name = split_type.type_name
+        title = split_type.title
+        if type_name =~ /^(::)?[Cc]lass$/
+          ['class', title.nil? ? nil : title.sub(/^::/, '')]
+        else
+          # Ensure that title is '' if nil
+          # Resources with absolute name always results in error because tagging does not support leading ::
+          [type_name.nil? ? nil : type_name.sub(/^::/, '').downcase, title.nil? ? '' : title]
+        end
+      else
+        #TRANSLATORS 'PClassType' and 'PResourceType' are Puppet types and should not be translated
+        raise ArgumentError, _("Cannot split the type %{class_name}, it represents neither a PClassType, nor a PResourceType.") %
+            { class_name: catalog_type.class }
+    end
+  end
+
+  protected
+
+  def initialize(inner = false)
+    @inner = inner
+    @inner_converter = inner ? self : self.class.new(true)
+    @convert_visitor = Puppet::Pops::Visitor.new(self, 'convert', 2, 2)
+  end
+
+  @instance = self.new
+end
+
+# A Ruby function written for the 3.x API cannot be expected to handle extended data types. This
+# converter ensures that they are converted to String format
+# @api private
+class Runtime3FunctionArgumentConverter < Runtime3Converter
+
+  def convert_Regexp(o, scope, undef_value)
+    # Puppet 3x cannot handle parameter values that are regular expressions. Turn into regexp string in
+    # source form
+    o.inspect
+  end
+
+  def convert_Version(o, scope, undef_value)
+    # Puppet 3x cannot handle SemVers. Use the string form
+    o.to_s
+  end
+
+  def convert_VersionRange(o, scope, undef_value)
+    # Puppet 3x cannot handle SemVerRanges. Use the string form
+    o.to_s
+  end
+
+  def convert_Binary(o, scope, undef_value)
+    # Puppet 3x cannot handle Binary. Use the string form
+    o.to_s
+  end
+
+  def convert_Timespan(o, scope, undef_value)
+    # Puppet 3x cannot handle Timespans. Use the string form
+    o.to_s
+  end
+
+  def convert_Timestamp(o, scope, undef_value)
+    # Puppet 3x cannot handle Timestamps. Use the string form
+    o.to_s
+  end
+
+  # Converts result back to 4.x by replacing :undef with nil in Array and Hash objects
+  #
+  def self.convert_return(val3x)
+    if val3x == :undef
+      nil
+    elsif val3x.is_a?(Array)
+      val3x.map {|v| convert_return(v) }
+    elsif val3x.is_a?(Hash)
+      hsh = {}
+      val3x.each_pair {|k,v| hsh[convert_return(k)] = convert_return(v)}
+      hsh
+    else
+      val3x
+    end
+  end
+
+  @instance = self.new
+end
+
+end