bolt 0.20.0 → 0.20.2

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

@@ -0,0 +1,158 @@
+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/vendored/puppet/lib/puppet/pops/serialization/from_data_converter.rb

@@ -0,0 +1,223 @@
+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
+        if @values.is_a?(Array)
+          @values.each_with_index { |v, idx| @values[idx] = v.resolve if v.is_a?(Builder) }
+        elsif @values.is_a?(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 '__pcore_type__' 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 '__pcore_type__' 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
+            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)
+      if value.is_a?(Hash)
+        pcore_type = value[PCORE_TYPE_KEY]
+        if pcore_type
+          @pcore_type_procs[pcore_type].call(value, pcore_type)
+        else
+          build({}) { value.each_pair { |key, elem| with(key) { convert(elem) }}}
+        end
+      elsif value.is_a?(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)
+      if value.is_a?(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
+      elsif value.is_a?(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

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

@@ -0,0 +1,19 @@
+module Puppet::Pops
+module Serialization
+  # An InstanceReader is responsible for reading an instance of a complex object using a deserializer. The read involves creating the
+  # instance, register it with the deserializer (so that self references can be resolved) and then read the instance data (which normally
+  # amounts to all attribute values).
+  # Instance readers are registered with of {Types::PObjectType}s to aid the type when reading instances.
+  #
+  # @api private
+  module InstanceReader
+    # @param [Class] impl_class the class of the instance to be created and initialized
+    # @param [Integer] value_count the expected number of objects that forms the initialization data
+    # @param [Deserializer] deserializer the deserializer to read from, and to register the instance with
+    # @return [Object] the instance that has been read
+    def read(impl_class, value_count, deserializer)
+      Serialization.not_implemented(self, 'read')
+    end
+  end
+end
+end

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

@@ -0,0 +1,14 @@
+module Puppet::Pops
+module Serialization
+  # An instance writer is responsible for writing complex objects using a {Serializer}
+  # @api private
+  module InstanceWriter
+    # @param [Types::PObjectType] type the type of instance to write
+    # @param [Object] value the instance
+    # @param [Serializer] serializer the serializer that will receive the written instance
+    def write(type, value, serializer)
+      Serialization.not_implemented(self, 'write')
+    end
+  end
+end
+end

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

@@ -0,0 +1,297 @@
+require 'json'
+
+module Puppet::Pops
+module Serialization
+
+require_relative 'time_factory'
+require_relative 'abstract_reader'
+require_relative 'abstract_writer'
+
+module JSON
+  # A Writer that writes output in JSON format
+  # @api private
+  class Writer < AbstractWriter
+    def initialize(io, options = {})
+      super(Packer.new(io, options), options)
+    end
+
+    # Clear the underlying io stream but does not clear tabulation cache
+    # Specifically designed to enable tabulation to span more than one
+    # separately deserialized object.
+    def clear_io
+      @packer.clear_io
+    end
+
+    def extension_packer
+      @packer
+    end
+
+    def packer
+      @packer
+    end
+
+    def build_payload
+      yield(@packer)
+    end
+
+    def to_a
+      @packer.to_a
+    end
+
+    def to_json
+      @packer.to_json
+    end
+  end
+
+  # A Reader that reads JSON formatted input
+  # @api private
+  class Reader < AbstractReader
+    def initialize(io)
+      super(Unpacker.new(io))
+    end
+
+    def re_initialize(io)
+      @unpacker.re_initialize(io)
+    end
+
+    def read_payload(data)
+      yield(@unpacker)
+    end
+  end
+
+  # The JSON Packer. Modeled after the MessagePack::Packer
+  # @api private
+  class Packer
+    def initialize(io, options = {})
+      @io = io
+      @io << '['
+      @type_registry = {}
+      @nested = []
+      @verbose = options[:verbose]
+      @verbose = false if @verbose.nil?
+      @indent = options[:indent] || 0
+    end
+
+    def register_type(type, klass, &block)
+      @type_registry[klass] = [type, klass, block]
+    end
+
+    def clear_io
+      # Truncate everything except leading '['
+      if @io.is_a?(String)
+        @io.slice!(1..-1)
+      else
+        @io.truncate(1)
+      end
+    end
+
+    def empty?
+      @io.is_a?(String) ? io.length == 1 : @io.pos == 1
+    end
+
+    def flush
+      # Drop last comma unless just start marker present
+      if @io.is_a?(String)
+        @io.chop! unless @io.length == 1
+        @io << ']'
+      else
+        pos = @io.pos
+        @io.pos = pos - 1 unless pos == 1
+        @io << ']'
+        @io.flush
+      end
+    end
+
+    def write(obj)
+      case obj
+      when Array
+        write_array_header(obj.size)
+        obj.each { |x| write(x) }
+      when Hash
+        write_map_header(obj.size)
+        obj.each_pair {|k, v| write(k); write(v) }
+      when nil
+        write_nil
+      else
+        write_scalar(obj)
+      end
+    end
+    alias pack write
+
+    def write_array_header(n)
+      if n < 1
+        @io << '[]'
+      else
+        @io << '['
+        @nested <<  [false, n]
+      end
+    end
+
+    def write_map_header(n)
+      if n < 1
+        @io << '{}'
+      else
+        @io << '{'
+        @nested <<  [true, n * 2]
+      end
+    end
+
+    def write_nil
+      @io << 'null'
+      write_delim
+    end
+
+    def to_s
+      to_json
+    end
+
+    def to_a
+      ::JSON.parse(io_string)
+    end
+
+    def to_json
+      if @indent > 0
+        ::JSON.pretty_unparse(to_a, { :indent => ' ' * @indent })
+      else
+        io_string
+      end
+    end
+
+    # Write a payload object. Not subject to extensions
+    def write_pl(obj)
+      @io << obj.to_json << ','
+    end
+
+    def io_string
+      if @io.is_a?(String)
+        @io
+      else
+        @io.pos = 0
+        @io.read
+      end
+    end
+    private :io_string
+
+    def write_delim
+      nesting = @nested.last
+      cnt = nesting.nil? ? nil : nesting[1]
+      case cnt
+      when 1
+        @io << (nesting[0] ? '}' : ']')
+        @nested.pop
+        write_delim
+      when Integer
+        if (cnt % 2) == 0 || !nesting[0]
+          @io << ','
+        else
+          @io << ':'
+        end
+        nesting[1] = cnt - 1
+      else
+        @io << ','
+      end
+    end
+    private :write_delim
+
+    def write_scalar(obj)
+      ext = @type_registry[obj.class]
+      if ext.nil?
+        case obj
+        when Numeric, String, true, false, nil
+          @io << obj.to_json
+          write_delim
+        else
+          raise SerializationError, _("Unable to serialize a %{obj}") % { obj: obj.class.name }
+        end
+      else
+        write_extension(ext, obj)
+      end
+    end
+    private :write_scalar
+
+    def write_extension(ext, obj)
+      @io << '[' << extension_indicator(ext).to_json << ','
+      @nested << nil
+      write_extension_payload(ext, obj)
+      @nested.pop
+      if obj.is_a?(Extension::SequenceStart) && obj.sequence_size > 0
+        @nested << [false, obj.sequence_size]
+      else
+        if @io.is_a?(String)
+          @io.chop!
+        else
+          @io.pos -= 1
+        end
+        @io << ']'
+        write_delim
+      end
+    end
+    private :write_extension
+
+    def write_extension_payload(ext, obj)
+      ext[2].call(obj)
+    end
+    private :write_extension_payload
+
+    def extension_indicator(ext)
+      @verbose ? ext[1].name.sub(/^Puppet::Pops::Serialization::\w+::(.+)$/, '\1') : ext[0]
+    end
+    private :extension_indicator
+  end
+
+  class Unpacker
+    def initialize(io)
+      re_initialize(io)
+      @type_registry = {}
+      @nested = []
+    end
+
+    def re_initialize(io)
+      parsed = parse_io(io)
+      raise SerializationError, _("JSON stream is not an array. It is a %{klass}") % { klass: io.class.name } unless parsed.is_a?(Array)
+      @etor_stack = [parsed.each]
+    end
+
+    def read
+      obj = nil
+      loop do
+        raise SerializationError, _('Unexpected end of input') if @etor_stack.empty?
+        etor = @etor_stack.last
+        begin
+          obj = etor.next
+          break
+        rescue StopIteration
+          @etor_stack.pop
+        end
+      end
+      if obj.is_a?(Array)
+        ext_etor = obj.each
+        @etor_stack << ext_etor
+        ext_no = ext_etor.next
+        ext_block = @type_registry[ext_no]
+        raise SerializationError, _("Invalid input. %{ext_no} is not a valid extension number") % { ext_no: ext_no } if ext_block.nil?
+        obj = ext_block.call(nil)
+      end
+      obj
+    end
+
+    def register_type(extension_number, &block)
+      @type_registry[extension_number] = block
+    end
+
+    private
+
+    def parse_io(io)
+      case io
+      when IO, StringIO
+        ::JSON.parse(io.read)
+      when String
+        ::JSON.parse(io)
+      else
+        io
+      end
+    end
+  end
+end
+end
+end