bolt 0.24.0 → 0.25.0

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

@@ -1,43 +0,0 @@
-module Puppet::Pops
-module Serialization
-  def self.not_implemented(impl, method_name)
-    raise NotImplementedError, "The class #{impl.class.name} should have implemented the method #{method_name}()"
-  end
-
-  class SerializationError < Puppet::Error
-  end
-
-  PCORE_TYPE_KEY = '__ptype'.freeze
-
-  # Key used when the value can be represented as, and recreated from, a single string that can
-  # be passed to a `from_string` method or an array of values that can be passed to the default
-  # initializer method.
-  PCORE_VALUE_KEY = '__pvalue'.freeze
-
-  # Type key used for hashes that contain keys that are not of type String
-  PCORE_TYPE_HASH = 'Hash'.freeze
-
-  # Type key used for symbols
-  PCORE_TYPE_SENSITIVE = 'Sensitive'.freeze
-  PCORE_TYPE_BINARY = 'Binary'.freeze
-
-  # Type key used for symbols
-  PCORE_TYPE_SYMBOL = 'Symbol'.freeze
-
-  # Type key used for Default
-  PCORE_TYPE_DEFAULT = 'Default'.freeze
-
-  # Type key used for document local references
-  PCORE_LOCAL_REF_SYMBOL = 'LocalRef'.freeze
-end
-end
-
-require_relative 'serialization/json_path'
-require_relative 'serialization/from_data_converter'
-require_relative 'serialization/to_data_converter'
-require_relative 'serialization/to_stringified_converter'
-require_relative 'serialization/serializer'
-require_relative 'serialization/deserializer'
-require_relative 'serialization/json'
-require_relative 'serialization/time_factory'
-require_relative 'serialization/object'

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

@@ -1,180 +0,0 @@
-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 * 1000000000 + nsec)
-      end
-    end
-
-    register_type(Extension::TIMESPAN) do |data|
-      read_payload(data) do |ep|
-        sec = ep.read
-        nsec = ep.read
-        Time::Timespan.new(sec * 1000000000 + 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

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

@@ -1,222 +0,0 @@
-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 / 1000000000); ep.write(nsecs % 1000000000) }
-    end
-
-    register_type(Extension::TIMESPAN, Time::Timespan) do |o|
-      build_payload { |ep| nsecs = o.nsecs; ep.write(nsecs / 1000000000); ep.write(nsecs % 1000000000) }
-    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}"
-  end
-
-  def inspect
-    to_s
-  end
-end
-end
-end

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

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