puppet 4.5.3-x64-mingw32 → 4.6.1-x64-mingw32

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

@@ -0,0 +1,21 @@
+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 },
+  },
+  equality => [name],
+}]
+

data/lib/puppet/pops/serialization.rb

@@ -0,0 +1,17 @@
+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
+end
+end
+
+require_relative 'serialization/serializer'
+require_relative 'serialization/deserializer'
+require_relative 'serialization/json'
+require_relative 'serialization/time_factory'
+require_relative 'serialization/rgen'
+require_relative 'serialization/object'

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

@@ -0,0 +1,149 @@
+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
+# - 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::OBJECT_START) do |data|
+      read_payload(data) { |ep| type_name = read_tpl_qname(ep); Extension::ObjectStart.new(type_name, 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::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(read_tpl_qname(ep)) }
+    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
+        TimeFactory.from_sec_nsec(sec, nsec)
+      end
+    end
+
+    register_type(Extension::VERSION) do |data|
+      read_payload(data) { |ep| Semantic::Version.parse(ep.read) }
+    end
+
+    register_type(Extension::VERSION_RANGE) do |data|
+      read_payload(data) { |ep| Semantic::VersionRange.parse(ep.read) }
+    end
+  end
+end
+end
+end

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

@@ -0,0 +1,179 @@
+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
+# - 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
+
+  # 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)
+    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::OBJECT_START, Extension::ObjectStart) do |o|
+      build_payload { |ep| write_tpl_qname(ep, o.type_name); 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
+
+    # 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| write_tpl_qname(ep, 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) do |o|
+      build_payload { |ep| ep.write(o.tv_sec); ep.write(o.tv_nsec) }
+    end
+
+    register_type(Extension::VERSION, Semantic::Version) do |o|
+      build_payload { |ep| ep.write(o.to_s) }
+    end
+
+    register_type(Extension::VERSION_RANGE, Semantic::VersionRange) do |o|
+      build_payload { |ep| ep.write(o.to_s) }
+    end
+  end
+end
+end
+end
+

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

@@ -0,0 +1,60 @@
+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
+    # @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::ObjectStart
+        type_name = val.type_name
+        type = Types::TypeParser.singleton.parse(type_name, @loader)
+        raise SerializationError, "No implementation mapping found for Puppet Type #{type_name}" if type.is_a?(Types::PTypeReferenceType)
+        type.read(val.attribute_count, self)
+      when Numeric, String, true, false, nil, Time
+        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,126 @@
+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
+  OBJECT_START = 0x12
+
+  # 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
+
+  # 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 ObjectStart
+  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 OBJECT_START extension. The payload is the name of the object type and the
+  # number of attributes in the instance.
+  class ObjectStart
+    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?(ObjectStart) && o.type_name == @type_name && 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