bolt 0.19.1 → 0.20.0

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

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

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

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

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

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