openvox 8.19.0

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

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require_relative 'extension'
+
+module Puppet::Pops
+module Serialization
+MAX_INTEGER = 0x7fffffffffffffff
+MIN_INTEGER = -0x8000000000000000
+
+# Abstract class for protocol specific writers such as MsgPack or JSON
+# The abstract write is capable of writing 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 AbstractWriter
+  # @param [MessagePack::Packer,JSON::Packer] packer the underlying packer stream
+  # @param [Hash] options
+  # @option options [Boolean] :tabulate `true` if tabulation is enabled (which is the default).
+  # @param [DebugPacker,nil] extension_packer Optional specific extension packer. Only used for debug output
+  # @api public
+  def initialize(packer, options, extension_packer = nil)
+    @tabulate = options[:tabulate]
+    @tabulate = true if @tabulate.nil?
+    @written = {}
+    @packer = packer
+    @extension_packer = extension_packer.nil? ? packer : extension_packer
+    register_types
+  end
+
+  # Tell the underlying packer to flush.
+  # @api public
+  def finish
+    @packer.flush
+  end
+
+  def supports_binary?
+    false
+  end
+
+  # Write a value on the underlying stream
+  # @api public
+  def write(value)
+    written = false
+    case value
+    when Integer
+      # not tabulated, but integers larger than 64-bit cannot be allowed.
+      raise SerializationError, _('Integer out of bounds') if value > MAX_INTEGER || value < MIN_INTEGER
+    when Numeric, Symbol, Extension::NotTabulated, true, false, nil
+      # not tabulated
+    else
+      if @tabulate
+        index = @written[value]
+        if index.nil?
+          @packer.write(value)
+          written = true
+          @written[value] = @written.size
+        else
+          value = Extension::InnerTabulation.new(index)
+        end
+      end
+    end
+    @packer.write(value) unless written
+  end
+
+  # Called from extension callbacks only
+  #
+  # @api private
+  def build_payload
+    raise SerializationError, "Internal error: Class #{self.class} does not implement method 'build_payload'"
+  end
+
+  # @api private
+  def extension_packer
+    @extension_packer
+  end
+
+  # Called from extension callbacks only
+  #
+  # @api private
+  def write_tpl_qname(ep, qname)
+    names = qname.split('::')
+    ep.write(names.size)
+    names.each { |n| write_tpl(ep, n) }
+  end
+
+  # Called from extension callbacks only
+  #
+  # @api private
+  def write_tpl(ep, value)
+    # TRANSLATORS 'Integers' is a Ruby class for numbers and should not be translated
+    raise ArgumentError, _('Internal error. Integers cannot be tabulated in extension payload') if value.is_a?(Integer)
+
+    if @tabulate
+      index = @written[value]
+      if index.nil?
+        @written[value] = @written.size
+      else
+        value = index
+      end
+    end
+    ep.write(value)
+  end
+
+  # @api private
+  def register_type(extension_number, payload_class, &block)
+    @packer.register_type(extension_number, payload_class, &block)
+  end
+
+  # @api private
+  def register_types
+    # 0x00 - 0x0F are reserved for low-level serialization / tabulation extensions
+
+    register_type(Extension::INNER_TABULATION, Extension::InnerTabulation) do |o|
+      build_payload { |ep| ep.write(o.index) }
+    end
+
+    register_type(Extension::TABULATION, Extension::Tabulation) do |o|
+      build_payload { |ep| ep.write(o.index) }
+    end
+
+    # 0x10 - 0x1F are reserved for structural extensions
+
+    register_type(Extension::ARRAY_START, Extension::ArrayStart) do |o|
+      build_payload { |ep| ep.write(o.size) }
+    end
+
+    register_type(Extension::MAP_START, Extension::MapStart) do |o|
+      build_payload { |ep| ep.write(o.size) }
+    end
+
+    register_type(Extension::PCORE_OBJECT_START, Extension::PcoreObjectStart) do |o|
+      build_payload { |ep| write_tpl_qname(ep, o.type_name); ep.write(o.attribute_count) }
+    end
+
+    register_type(Extension::OBJECT_START, Extension::ObjectStart) do |o|
+      build_payload { |ep| ep.write(o.attribute_count) }
+    end
+
+    # 0x20 - 0x2f reserved for special extension objects
+
+    register_type(Extension::DEFAULT, Extension::Default) do |_o|
+      build_payload { |ep| }
+    end
+
+    register_type(Extension::COMMENT, Extension::Comment) do |o|
+      build_payload { |ep| ep.write(o.comment) }
+    end
+
+    register_type(Extension::SENSITIVE_START, Extension::SensitiveStart) do |_o|
+      build_payload { |ep| }
+    end
+
+    # 0x30 - 0x7f reserved for mapping of specific runtime classes
+
+    register_type(Extension::REGEXP, Regexp) do |o|
+      build_payload { |ep| ep.write(o.source) }
+    end
+
+    register_type(Extension::TYPE_REFERENCE, Types::PTypeReferenceType) do |o|
+      build_payload { |ep| ep.write(o.type_string) }
+    end
+
+    register_type(Extension::SYMBOL, Symbol) do |o|
+      build_payload { |ep| ep.write(o.to_s) }
+    end
+
+    register_type(Extension::TIME, Time::Timestamp) do |o|
+      build_payload { |ep| nsecs = o.nsecs; ep.write(nsecs / 1_000_000_000); ep.write(nsecs % 1_000_000_000) }
+    end
+
+    register_type(Extension::TIMESPAN, Time::Timespan) do |o|
+      build_payload { |ep| nsecs = o.nsecs; ep.write(nsecs / 1_000_000_000); ep.write(nsecs % 1_000_000_000) }
+    end
+
+    register_type(Extension::VERSION, SemanticPuppet::Version) do |o|
+      build_payload { |ep| ep.write(o.to_s) }
+    end
+
+    register_type(Extension::VERSION_RANGE, SemanticPuppet::VersionRange) do |o|
+      build_payload { |ep| ep.write(o.to_s) }
+    end
+
+    if supports_binary?
+      register_type(Extension::BINARY, Types::PBinaryType::Binary) do |o|
+        # The Ruby MessagePack implementation has special treatment for "ASCII-8BIT" strings. They
+        # are written as binary data.
+        build_payload { |ep| ep.write(o.binary_buffer) }
+      end
+    else
+      register_type(Extension::BASE64, Types::PBinaryType::Binary) do |o|
+        build_payload { |ep| ep.write(o.to_s) }
+      end
+    end
+
+    URI.scheme_list.values.each do |uri_class|
+      register_type(Extension::URI, uri_class) do |o|
+        build_payload { |ep| ep.write(o.to_s) }
+      end
+    end
+  end
+
+  def to_s
+    self.class.name.to_s
+  end
+
+  def inspect
+    to_s
+  end
+end
+end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative 'extension'
+
+module Puppet::Pops
+module Serialization
+  # The deserializer is capable of reading, arrays, maps, and complex objects using an underlying protocol reader. It takes care of
+  # resolving tabulations and assembling complex objects. The type of the complex objects are resolved using a loader.
+  # @api public
+  class Deserializer
+    # Provides access to the reader.
+    # @api private
+    attr_reader :reader, :loader
+
+    # @param [AbstractReader] reader the reader used when reading primitive objects from a stream
+    # @param [Loader::Loader] loader the loader used when resolving names of types
+    # @api public
+    def initialize(reader, loader)
+      @read = []
+      @reader = reader
+      @loader = loader
+    end
+
+    # Read the next value from the reader.
+    #
+    # @return [Object] the value that was read
+    # @api public
+    def read
+      val = @reader.read
+      case val
+      when Extension::Tabulation
+        @read[val.index]
+      when Extension::Default
+        :default
+      when Extension::ArrayStart
+        result = remember([])
+        val.size.times { result << read }
+        result
+      when Extension::MapStart
+        result = remember({})
+        val.size.times { key = read; result[key] = read }
+        result
+      when Extension::SensitiveStart
+        Types::PSensitiveType::Sensitive.new(read)
+      when Extension::PcoreObjectStart
+        type_name = val.type_name
+        type = Types::TypeParser.singleton.parse(type_name, @loader)
+        raise SerializationError, _("No implementation mapping found for Puppet Type %{type_name}") % { type_name: type_name } if type.is_a?(Types::PTypeReferenceType)
+
+        result = type.read(val.attribute_count, self)
+        if result.is_a?(Types::PObjectType)
+          existing_type = loader.load(:type, result.name)
+          if result.eql?(existing_type)
+            result = existing_type
+          else
+            # Add result to the loader unless it is equal to the existing_type. The add
+            # will only succeed when the existing_type is nil.
+            loader.add_entry(:type, result.name, result, nil)
+          end
+        end
+        result
+      when Extension::ObjectStart
+        type = read
+        type.read(val.attribute_count - 1, self)
+      when Numeric, String, true, false, nil
+        val
+      else
+        remember(val)
+      end
+    end
+
+    # Remember that a value has been read. This means that the value is given an index
+    # and that subsequent reads of a tabulation with that index should return the value.
+    # @param [Object] value The value to remember
+    # @return [Object] the argument
+    # @api private
+    def remember(value)
+      @read << value
+      value
+    end
+  end
+end
+end

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

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Puppet::Pops
+module Serialization
+module Extension
+  # 0x00 - 0x0F are reserved for low-level serialization / tabulation extensions
+
+  # Tabulation internal to the low level protocol reader/writer
+  INNER_TABULATION = 0x00
+
+  # Tabulation managed by the serializer / deserializer
+  TABULATION = 0x01
+
+  # 0x10 - 0x1F are reserved for structural extensions
+  ARRAY_START = 0x10
+  MAP_START = 0x11
+  PCORE_OBJECT_START = 0x12
+  OBJECT_START = 0x13
+  SENSITIVE_START = 0x14
+
+  # 0x20 - 0x2f reserved for special extension objects
+  DEFAULT = 0x20
+  COMMENT = 0x21
+
+  # 0x30 - 0x7f reserved for mapping of specific runtime classes
+  REGEXP = 0x30
+  TYPE_REFERENCE = 0x31
+  SYMBOL = 0x32
+  TIME   = 0x33
+  TIMESPAN = 0x34
+  VERSION = 0x35
+  VERSION_RANGE = 0x36
+  BINARY = 0x37
+  BASE64 = 0x38
+  URI    = 0x39
+
+  # Marker module indicating whether or not an instance is tabulated or not
+  module NotTabulated; end
+
+  # Marker module for objects that starts a sequence, i.e. ArrayStart, MapStart, and PcoreObjectStart
+  module SequenceStart; end
+
+  # The class that triggers the use of the DEFAULT extension. It doesn't have any payload
+  class Default
+    include NotTabulated
+    INSTANCE = Default.new
+  end
+
+  # The class that triggers the use of the TABULATION extension. The payload is the tabulation index
+  class Tabulation
+    include NotTabulated
+    attr_reader :index
+
+    def initialize(index)
+      @index = index
+    end
+  end
+
+  # Tabulation internal to the protocol reader/writer
+  class InnerTabulation < Tabulation
+  end
+
+  # The class that triggers the use of the MAP_START extension. The payload is the map size (number of entries)
+  class MapStart
+    include NotTabulated
+    include SequenceStart
+    attr_reader :size
+
+    def initialize(size)
+      @size = size
+    end
+
+    # Sequence size is twice the map size since each entry is written as key and value
+    def sequence_size
+      @size * 2
+    end
+  end
+
+  # The class that triggers the use of the ARRAY_START extension. The payload is the array size
+  class ArrayStart
+    include NotTabulated
+    include SequenceStart
+    attr_reader :size
+
+    def initialize(size)
+      @size = size
+    end
+
+    def sequence_size
+      @size
+    end
+  end
+
+  # The class that triggers the use of the SENSITIVE_START extension. It has no payload
+  class SensitiveStart
+    include NotTabulated
+    INSTANCE = SensitiveStart.new
+  end
+
+  # The class that triggers the use of the PCORE_OBJECT_START extension. The payload is the name of the object type
+  # and the number of attributes in the instance.
+  class PcoreObjectStart
+    include SequenceStart
+    attr_reader :type_name, :attribute_count
+
+    def initialize(type_name, attribute_count)
+      @type_name = type_name
+      @attribute_count = attribute_count
+    end
+
+    def hash
+      @type_name.hash * 29 + attribute_count.hash
+    end
+
+    def eql?(o)
+      o.is_a?(PcoreObjectStart) && o.type_name == @type_name && o.attribute_count == @attribute_count
+    end
+    alias == eql?
+
+    def sequence_size
+      @attribute_count
+    end
+  end
+
+  class ObjectStart
+    include SequenceStart
+    attr_reader :attribute_count
+
+    def initialize(attribute_count)
+      @attribute_count = attribute_count
+    end
+
+    def hash
+      attribute_count.hash
+    end
+
+    def eql?(o)
+      o.is_a?(ObjectStart) && o.attribute_count == @attribute_count
+    end
+    alias == eql?
+
+    def sequence_size
+      @attribute_count
+    end
+  end
+
+  # The class that triggers the use of the COMMENT extension. The payload is comment text
+  class Comment
+    attr_reader :comment
+
+    def initialize(comment)
+      @comment = comment
+    end
+
+    def hash
+      @comment.hash
+    end
+
+    def eql?(o)
+      o.is_a?(Comment) && o.comment == @comment
+    end
+    alias == eql?
+  end
+end
+end
+end

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

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module Puppet::Pops
+module Serialization
+  class Builder
+    def initialize(values)
+      @values = values
+      @resolved = true
+    end
+
+    def [](key)
+      @values[key]
+    end
+
+    def []=(key, value)
+      @values[key] = value
+      @resolved = false if value.is_a?(Builder)
+    end
+
+    def resolve
+      unless @resolved
+        @resolved = true
+        case @values
+        when Array
+          @values.each_with_index { |v, idx| @values[idx] = v.resolve if v.is_a?(Builder) }
+        when Hash
+          @values.each_pair { |k, v| @values[k] = v.resolve if v.is_a?(Builder) }
+        end
+      end
+      @values
+    end
+  end
+
+  class ObjectHashBuilder < Builder
+    def initialize(instance)
+      super({})
+      @instance = instance
+    end
+
+    def resolve
+      @instance._pcore_init_from_hash(super)
+      @instance
+    end
+  end
+
+  class ObjectArrayBuilder < Builder
+    def initialize(instance)
+      super({})
+      @instance = instance
+    end
+
+    def resolve
+      @instance.send(:initialize, *super.values)
+      @instance
+    end
+  end
+
+  # Class that can process the `Data` produced by the {ToDataConverter} class and reassemble
+  # the objects that were converted.
+  #
+  # @api public
+  class FromDataConverter
+    # Converts the given `Data` _value_ according to the given _options_ and returns the resulting `RichData`.
+    #
+    # @param value [Data] the value to convert
+    # @param options {Symbol => <Boolean,String>} options hash
+    # @option options [Loaders::Loader] :loader the loader to use. Can be `nil` in which case the default is
+    #    determined by the {Types::TypeParser}.
+    # @option options [Boolean] :allow_unresolved `true` to allow that rich_data hashes are kept "as is" if the
+    #    designated '__ptype' cannot be resolved. Defaults to `false`.
+    # @return [RichData] the processed result.
+    #
+    # @api public
+    def self.convert(value, options = EMPTY_HASH)
+      new(options).convert(value)
+    end
+
+    # Creates a new instance of the processor
+    #
+    # @param options {Symbol => Object} options hash
+    # @option options [Loaders::Loader] :loader the loader to use. Can be `nil` in which case the default is
+    #    determined by the {Types::TypeParser}.
+    # @option options [Boolean] :allow_unresolved `true` to allow that rich_data hashes are kept "as is" if the
+    #    designated '__ptype' cannot be resolved. Defaults to `false`.
+    #
+    # @api public
+    def initialize(options = EMPTY_HASH)
+      @allow_unresolved = options[:allow_unresolved]
+      @allow_unresolved = false if @allow_unresolved.nil?
+      @loader = options[:loader]
+
+      @pcore_type_procs = {
+        PCORE_TYPE_HASH => proc do |hash, _|
+          value = hash[PCORE_VALUE_KEY]
+          build({}) do
+            top = value.size
+            idx = 0
+            while idx < top
+              key = without_value { convert(value[idx]) }
+              idx += 1
+              with(key) { convert(value[idx]) }
+              idx += 1
+            end
+          end
+        end,
+
+        PCORE_TYPE_SENSITIVE => proc do |hash, _|
+          build(Types::PSensitiveType::Sensitive.new(convert(hash[PCORE_VALUE_KEY])))
+        end,
+
+        PCORE_TYPE_DEFAULT => proc do |_, _|
+          build(:default)
+        end,
+
+        PCORE_TYPE_SYMBOL => proc do |hash, _|
+          build(:"#{hash[PCORE_VALUE_KEY]}")
+        end,
+
+        PCORE_LOCAL_REF_SYMBOL => proc do |hash, _|
+          build(JsonPath::Resolver.singleton.resolve(@root, hash[PCORE_VALUE_KEY]))
+        end
+      }
+      @pcore_type_procs.default = proc do |hash, type_value|
+        value = hash.include?(PCORE_VALUE_KEY) ? hash[PCORE_VALUE_KEY] : hash.reject { |key, _| PCORE_TYPE_KEY == key }
+        if type_value.is_a?(Hash)
+          type = without_value { convert(type_value) }
+          if type.is_a?(Hash)
+            raise SerializationError, _('Unable to deserialize type from %{type}') % { type: type } unless @allow_unresolved
+
+            hash
+          else
+            pcore_type_hash_to_value(type, value)
+          end
+        else
+          type = Types::TypeParser.singleton.parse(type_value, @loader)
+          if type.is_a?(Types::PTypeReferenceType)
+            unless @allow_unresolved
+              raise SerializationError, _('No implementation mapping found for Puppet Type %{type_name}') % { type_name: type_value }
+            end
+
+            hash
+          else
+            # not a string
+            pcore_type_hash_to_value(type, value)
+          end
+        end
+      end
+    end
+
+    # Converts the given `Data` _value_ and returns the resulting `RichData`
+    #
+    # @param value [Data] the value to convert
+    # @return [RichData] the processed result
+    #
+    # @api public
+    def convert(value)
+      case value
+      when Hash
+        pcore_type = value[PCORE_TYPE_KEY]
+        if pcore_type && (pcore_type.is_a?(String) || pcore_type.is_a?(Hash))
+          @pcore_type_procs[pcore_type].call(value, pcore_type)
+        else
+          build({}) { value.each_pair { |key, elem| with(key) { convert(elem) } } }
+        end
+      when Array
+        build([]) { value.each_with_index { |elem, idx| with(idx) { convert(elem) } } }
+      else
+        build(value)
+      end
+    end
+
+    private
+
+    def with(key)
+      parent_key = @key
+      @key = key
+      yield
+      @key = parent_key
+    end
+
+    def with_value(value)
+      @root = value unless instance_variable_defined?(:@root)
+      parent = @current
+      @current = value
+      yield
+      @current = parent
+      value
+    end
+
+    def without_value
+      parent = @current
+      @current = nil
+      value = yield
+      @current = parent
+      value
+    end
+
+    def build(value, &block)
+      vx = Builder.new(value)
+      @current[@key] = vx unless @current.nil?
+      with_value(vx, &block) if block_given?
+      vx.resolve
+    end
+
+    def build_object(builder, &block)
+      @current[@key] = builder unless @current.nil?
+      with_value(builder, &block) if block_given?
+      builder.resolve
+    end
+
+    def pcore_type_hash_to_value(pcore_type, value)
+      case value
+      when Hash
+        # Complex object
+        if value.empty?
+          build(pcore_type.create)
+        elsif pcore_type.implementation_class.respond_to?(:_pcore_init_from_hash)
+          build_object(ObjectHashBuilder.new(pcore_type.allocate)) { value.each_pair { |key, elem| with(key) { convert(elem) } } }
+        else
+          build_object(ObjectArrayBuilder.new(pcore_type.allocate)) { value.each_pair { |key, elem| with(key) { convert(elem) } } }
+        end
+      when String
+        build(pcore_type.create(value))
+      else
+        raise SerializationError, _('Cannot create a %{type_name} from a %{arg_class}') %
+                                  { :type_name => pcore_type.name, :arg_class => value.class.name }
+      end
+    end
+  end
+end
+end