openvox 8.19.0

data/lib/puppet/pops/resource/resource_type_impl.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require_relative 'param'
+
+module Puppet::Pops
+module Resource
+def self.register_ptypes(loader, ir)
+  types = [Param, ResourceTypeImpl].map do |c|
+    c.register_ptype(loader, ir)
+  end
+  types.each { |t| t.resolve(loader) }
+end
+
+class ResourceTypeImpl
+  # Make instances of this class directly creatable from the Puppet Language
+  # as object.
+  #
+  include Puppet::Pops::Types::PuppetObject
+
+  # Instances of ResourceTypeImpl can be used as the type of a Puppet::Parser::Resource/Puppet::Resource when compiling
+  #
+  include Puppet::CompilableResourceType
+
+  # Returns the Puppet Type for this instance.
+  def self._pcore_type
+    @ptype
+  end
+
+  def self.register_ptype(loader, ir)
+    param_ref = Types::PTypeReferenceType.new('Puppet::Resource::Param')
+    @ptype = Pcore.create_object_type(loader, ir, self, 'Puppet::Resource::ResourceType3', nil,
+                                      {
+                                        Types::KEY_NAME => Types::PStringType::NON_EMPTY,
+                                        'properties' => {
+                                          Types::KEY_TYPE => Types::PArrayType.new(param_ref),
+                                          Types::KEY_VALUE => EMPTY_ARRAY
+                                        },
+                                        'parameters' => {
+                                          Types::KEY_TYPE => Types::PArrayType.new(param_ref),
+                                          Types::KEY_VALUE => EMPTY_ARRAY
+                                        },
+                                        'title_patterns_hash' => {
+                                          Types::KEY_TYPE => Types::POptionalType.new(
+                                            Types::PHashType.new(Types::PRegexpType::DEFAULT, Types::PArrayType.new(Types::PStringType::NON_EMPTY))
+                                          ),
+                                          Types::KEY_VALUE => nil
+                                        },
+                                        'isomorphic' => {
+                                          Types::KEY_TYPE => Types::PBooleanType::DEFAULT,
+                                          Types::KEY_VALUE => true
+                                        },
+                                        'capability' => {
+                                          Types::KEY_TYPE => Types::PBooleanType::DEFAULT,
+                                          Types::KEY_VALUE => false
+                                        },
+                                      },
+                                      EMPTY_HASH,
+                                      [Types::KEY_NAME])
+  end
+
+  def eql?(other)
+    other.is_a?(Puppet::CompilableResourceType) && @name == other.name
+  end
+  alias == eql?
+
+  # Compares this type against the given _other_ (type) and returns -1, 0, or +1 depending on the order.
+  # @param other [Object] the object to compare against (produces nil, if not kind of Type}
+  # @return [-1, 0, +1, nil] produces -1 if this type is before the given _other_ type, 0 if equals, and 1 if after.
+  #   Returns nil, if the given _other_ is not a kind of Type.
+  # @see Comparable
+  #
+  def <=>(other)
+    # Order is only maintained against other types, not arbitrary objects.
+    # The natural order is based on the reference name used when comparing
+    return nil unless other.is_a?(Puppet::CompilableResourceType)
+
+    # against other type instances.
+    ref <=> other.ref
+  end
+
+  METAPARAMS = [
+    :noop,
+    :schedule,
+    :audit,
+    :loglevel,
+    :alias,
+    :tag,
+    :require,
+    :subscribe,
+    :before,
+    :notify,
+    :stage
+  ].freeze
+
+  # Speed up lookup
+  METAPARAMSET = Set.new(METAPARAMS).freeze
+
+  attr_reader :name
+  attr_reader :properties
+  attr_reader :parameters
+  attr_reader :title_patterns_hash
+  attr_reader :title_patterns
+
+  def initialize(name, properties = EMPTY_ARRAY, parameters = EMPTY_ARRAY, title_patterns_hash = nil, isomorphic = true, capability = false)
+    @name = name
+    @properties = properties
+    @parameters = parameters
+    @title_patterns_hash = title_patterns_hash
+    @isomorphic = isomorphic
+    # ignore capability parameter
+
+    # Compute attributes hash
+    # Compute key_names (possibly compound key if there are multiple name vars).
+    @attributes = {}
+    @key_attributes = []
+
+    # Name to kind of attribute
+    @attr_types = {}
+
+    # Add all meta params
+    METAPARAMS.each { |p| @attr_types[p] = :meta }
+
+    @property_set = Set.new(properties.map do |p|
+      symname = p.name.to_sym
+      @attributes[symname] = p
+      @key_attributes << symname if p.name_var
+      @attr_types[symname] = :property
+      symname
+    end).freeze
+
+    @param_set = Set.new(parameters.map do |p|
+      symname = p.name.to_sym
+      @attributes[symname] = p
+      @key_attributes << symname if p.name_var
+      @attr_types[symname] = :param
+      symname
+    end).freeze
+
+    # API for title patterns is [ [regexp, [ [ [sym, <lambda>], [sym, <lambda>] ] ] ] ]
+    # Where lambdas are optional. This resource type impl does not support lambdas
+    # Note that the pcore file has a simpler hashmap that is post processed here
+    # since the structure must have Symbol instances for names which the .pp representation
+    # does not deliver.
+    #
+    @title_patterns =
+      case @key_attributes.length
+      when 0
+        # TechDebt: The case of specifying title patterns when having no name vars is unspecified behavior in puppet
+        # Here it is silently ignored.
+        nil
+      when 1
+        if @title_patterns_hash.nil?
+          [[/(.*)/m, [[@key_attributes.first]]]]
+        else
+          # TechDebt: The case of having one namevar and an empty title patterns is unspecified behavior in puppet.
+          # Here, it may lead to an empty map which may or may not trigger the wanted/expected behavior.
+          #
+          @title_patterns_hash.map { |k, v| [k, v.map { |n| [n.to_sym] }] }
+        end
+      else
+        if @title_patterns_hash.nil? || @title_patterns_hash.empty?
+          # TechDebt: While title patterns must be specified when more than one is used, they do not have
+          # to match/set them all since some namevars can be omitted (to support the use case in
+          # the 'package' type where 'provider' attribute is handled as part of the key without being
+          # set from the title.
+          #
+          raise Puppet::DevError, _("you must specify title patterns when there are two or more key attributes")
+        end
+
+        @title_patterns_hash.nil? ? [] : @title_patterns_hash.map { |k, v| [k, v.map { |n| [n.to_sym] }] }
+      end
+  end
+
+  # Override CompilableResource inclusion
+  def is_3x_ruby_plugin?
+    false
+  end
+
+  # Answers if the parameter name is a parameter/attribute of this type
+  # This is part of the Puppet::Type API
+  # Check if used when compiling (it is triggered in an apply)
+  #
+  def valid_parameter?(name)
+    @attributes.include?(name) || METAPARAMSET.include?(name)
+  end
+
+  # The type implementation of finish does a lot of things
+  # * iterates over all parameters and calls post_compile on them if the parameter impl responds to post_compile
+  # * validates the relationship parameters
+  #
+  # This implementation does nothing - it is assumed that the catalog is already validated
+  # via the relationship validator (done late in the game).
+  def finish
+    # Do nothing.
+  end
+
+  # This is called on a resource type
+  # it performs tagging if it is a Class or Node.
+  # It also ensure the parent type is in the catalog, but that is weird since
+  # resource types cannot really inherit
+  def instantiate_resource(scope, resource)
+    # Do nothing because nothing is needed when compiling.
+
+    # This is what the Puppet::Type implementation does
+    # None of this should be needed
+
+    #    # Make sure our parent class has been evaluated, if we have one.
+    #    if parent && !scope.catalog.resource(resource.type, parent)
+    #      parent_type(scope).ensure_in_catalog(scope)
+    #    end
+
+    # This will never happen
+
+    #    if ['Class', 'Node'].include? resource.type
+    #      scope.catalog.tag(*resource.tags)
+    #    end
+  end
+
+  # Being isomorphic in puppet means that the resource is managing a state
+  # (as opposed to a resource like Exec that is a function, possibly with side effect.
+  # In a Ruby implementation of a resource type, @isomorphic = false is used to turn
+  # off isomorphism, it is true by default.
+  # This is part of the Puppet::Type API.
+  #
+  def isomorphic?
+    @isomorphic
+  end
+
+  # Produces the names of the attributes that make out the unique id of a resource
+  #
+  def key_attributes
+    @key_attributes
+  end
+
+  # Gives a type a chance to issue deprecations for parameters.
+  # @param title [String] the title of the resource of this type
+  # @param attributes [Array<Param>] the set parameters in the resource instance
+  def deprecate_params(title, attributes)
+    # TODO: Current API somewhat unclear, if done at type level, or per
+    #       Param.
+  end
+
+  ##################################################
+  # NEVER CALLED COMPILE SIDE FOR A COMPILATION
+  ##################################################
+
+  # Answers :property, :param or :meta depending on the type of the attribute
+  # According to original version, this is called millions of times
+  # and a cache is required.
+  # @param name [Symbol]
+  def attrtype(name)
+    raise NotImplementedError, "attrtype() - returns the kind (:meta, :param, or :property) of the parameter"
+    # @attr_types[name]
+  end
+
+  # Returns the implementation of a param/property/attribute - i.e. a Param class
+  def attrclass(name)
+    raise NotImplementedError, "attrclass() - returns the (param) class of the parameter"
+  end
+
+  # PROBABLY NOT USED WHEN COMPILING
+  # Returns the names of all attributes in a defined order:
+  # * all key attributes (the composite id)
+  # * :provider if it is specified
+  # * all properties
+  # * all parameters
+  # * meta parameters
+  #
+  def allattrs
+    raise NotImplementedError, "allattrs() - return all attribute names in order - probably not used master side"
+    # key_attributes | (parameters & [:provider]) | properties.collect { |property| property.name } | parameters | metaparams
+  end
+
+  # Sets "applies to host"
+  def apply_to
+    raise NotImplementedError, "apply_to() - probably used when selecting a provider (device/host support)"
+  end
+
+  def apply_to_host
+    raise NotImplementedError, "apply_to_host() - probably used when selecting a provider (device/host support)"
+  end
+
+  def apply_to_device
+    raise NotImplementedError, "apply_to_device() - probably used when selecting a provider (device/host support)"
+  end
+
+  def apply_to_all
+    raise NotImplementedError, "apply_to_all() - probably used when selecting a provider (device/host support)"
+  end
+
+  def can_apply_to_target(target)
+    raise NotImplementedError, "can_apply_to_target() - probably used when selecting a provider (device/host support)"
+  end
+end
+end
+end

data/lib/puppet/pops/resource/resource_type_set.pcore

@@ -0,0 +1,22 @@
+type Puppet::Resource::Param = Object[{
+  attributes => {
+    type => Type,
+    name => String[1],
+    name_var => { type => Boolean, value => false }
+  },
+  equality => [name],
+}]
+
+
+type Puppet::Resource::ResourceType3 = Object[{
+  attributes => {
+    name           => String[1],
+    properties     => { type => Array[Puppet::Resource::Param], value = []},
+    parameters     => { type => Array[Puppet::Resource::Param], value = []},
+    title_patterns => { type => Optional[Hash[Regexp, Array[String[1]]], value => nil },
+    isomorphic     => { type => Boolean, value => true },
+    capability     => { type => Boolean, value => false },
+  },
+  equality => [name],
+}]
+

data/lib/puppet/pops/semantic_error.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Error that is used to raise an Issue. See {Puppet::Pops::Issues}.
+#
+class Puppet::Pops::SemanticError < RuntimeError
+  attr_accessor :issue
+  attr_accessor :semantic
+  attr_accessor :options
+
+  # @param issue [Puppet::Pops::Issues::Issue] the issue describing the severity and message
+  # @param semantic [Puppet::Pops::Model::Locatable, nil] the expression causing the failure, or nil if unknown
+  # @param options [Hash] an options hash with Symbol to value mapping - these are the arguments to the issue
+  #
+  def initialize(issue, semantic = nil, options = {})
+    @issue = issue
+    @semantic = semantic
+    @options = options
+  end
+
+  def file
+    @options[:file]
+  end
+
+  def line
+    @options[:line]
+  end
+
+  def pos
+    @options[:pos]
+  end
+end

data/lib/puppet/pops/serialization/abstract_reader.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require_relative 'extension'
+require_relative 'time_factory'
+
+module Puppet::Pops
+module Serialization
+# Abstract class for protocol specific readers such as MsgPack or JSON
+# The abstract reader is capable of reading the primitive scalars:
+# - Boolean
+# - Integer
+# - Float
+# - String
+# and, by using extensions, also
+# - Array start
+# - Map start
+# - Object start
+# - Regexp
+# - Version
+# - VersionRange
+# - Timespan
+# - Timestamp
+# - Default
+#
+# @api public
+class AbstractReader
+  # @param [MessagePack::Unpacker,JSON::Unpacker] unpacker The low lever unpacker that delivers the primitive objects
+  # @param [MessagePack::Unpacker,JSON::Unpacker] extension_unpacker Optional unpacker for extensions. Defaults to the unpacker
+  # @api public
+  def initialize(unpacker, extension_unpacker = nil)
+    @read = []
+    @unpacker = unpacker
+    @extension_unpacker = extension_unpacker.nil? ? unpacker : extension_unpacker
+    register_types
+  end
+
+  # Read an object from the underlying unpacker
+  # @return [Object] the object that was read
+  # @api public
+  def read
+    obj = @unpacker.read
+    case obj
+    when Extension::InnerTabulation
+      @read[obj.index]
+    when Numeric, Symbol, Extension::NotTabulated, true, false, nil
+      # not tabulated
+      obj
+    else
+      @read << obj
+      obj
+    end
+  end
+
+  # @return [Integer] The total count of unique primitive values that has been read
+  # @api private
+  def primitive_count
+    @read.size
+  end
+
+  # @api private
+  def read_payload(data)
+    raise SerializationError, "Internal error: Class #{self.class} does not implement method 'read_payload'"
+  end
+
+  # @api private
+  def read_tpl_qname(ep)
+    Array.new(ep.read) { read_tpl(ep) }.join('::')
+  end
+
+  # @api private
+  def read_tpl(ep)
+    obj = ep.read
+    case obj
+    when Integer
+      @read[obj]
+    else
+      @read << obj
+      obj
+    end
+  end
+
+  # @api private
+  def extension_unpacker
+    @extension_unpacker
+  end
+
+  # @api private
+  def register_type(extension_number, &block)
+    @unpacker.register_type(extension_number, &block)
+  end
+
+  # @api private
+  def register_types
+    register_type(Extension::INNER_TABULATION) do |data|
+      read_payload(data) { |ep| Extension::InnerTabulation.new(ep.read) }
+    end
+
+    register_type(Extension::TABULATION) do |data|
+      read_payload(data) { |ep| Extension::Tabulation.new(ep.read) }
+    end
+
+    register_type(Extension::ARRAY_START) do |data|
+      read_payload(data) { |ep| Extension::ArrayStart.new(ep.read) }
+    end
+
+    register_type(Extension::MAP_START) do |data|
+      read_payload(data) { |ep| Extension::MapStart.new(ep.read) }
+    end
+
+    register_type(Extension::PCORE_OBJECT_START) do |data|
+      read_payload(data) { |ep| type_name = read_tpl_qname(ep); Extension::PcoreObjectStart.new(type_name, ep.read) }
+    end
+
+    register_type(Extension::OBJECT_START) do |data|
+      read_payload(data) { |ep| Extension::ObjectStart.new(ep.read) }
+    end
+
+    register_type(Extension::DEFAULT) do |data|
+      read_payload(data) { |_ep| Extension::Default::INSTANCE }
+    end
+
+    register_type(Extension::COMMENT) do |data|
+      read_payload(data) { |ep| Extension::Comment.new(ep.read) }
+    end
+
+    register_type(Extension::SENSITIVE_START) do |data|
+      read_payload(data) { |_ep| Extension::SensitiveStart::INSTANCE }
+    end
+
+    register_type(Extension::REGEXP) do |data|
+      read_payload(data) { |ep| Regexp.new(ep.read) }
+    end
+
+    register_type(Extension::TYPE_REFERENCE) do |data|
+      read_payload(data) { |ep| Types::PTypeReferenceType.new(ep.read) }
+    end
+
+    register_type(Extension::SYMBOL) do |data|
+      read_payload(data) { |ep| ep.read.to_sym }
+    end
+
+    register_type(Extension::TIME) do |data|
+      read_payload(data) do |ep|
+        sec = ep.read
+        nsec = ep.read
+        Time::Timestamp.new(sec * 1_000_000_000 + nsec)
+      end
+    end
+
+    register_type(Extension::TIMESPAN) do |data|
+      read_payload(data) do |ep|
+        sec = ep.read
+        nsec = ep.read
+        Time::Timespan.new(sec * 1_000_000_000 + nsec)
+      end
+    end
+
+    register_type(Extension::VERSION) do |data|
+      read_payload(data) { |ep| SemanticPuppet::Version.parse(ep.read) }
+    end
+
+    register_type(Extension::VERSION_RANGE) do |data|
+      read_payload(data) { |ep| SemanticPuppet::VersionRange.parse(ep.read) }
+    end
+
+    register_type(Extension::BASE64) do |data|
+      read_payload(data) { |ep| Types::PBinaryType::Binary.from_base64_strict(ep.read) }
+    end
+
+    register_type(Extension::BINARY) do |data|
+      # The Ruby MessagePack implementation have special treatment for "ASCII-8BIT" strings. They
+      # are written as binary data.
+      read_payload(data) { |ep| Types::PBinaryType::Binary.new(ep.read) }
+    end
+
+    register_type(Extension::URI) do |data|
+      read_payload(data) { |ep| URI(ep.read) }
+    end
+  end
+end
+end
+end