puppet 4.5.3-x86-mingw32 → 4.6.1-x86-mingw32

data/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/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/lib/puppet/pops/serialization/json.rb

@@ -0,0 +1,247 @@
+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
+
+    def extension_packer
+      @packer
+    end
+
+    def packer
+      @packer
+    end
+
+    def build_payload
+      yield(@packer)
+    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 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
+      @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 empty?
+      @io.pos == 0
+    end
+
+    def flush
+      pos = @io.pos
+      case pos
+      when 1
+        # Just start marker present.
+      when 0
+        @io << '['
+      else
+        # Drop last comma
+        @io.pos = pos - 1
+      end
+      @io << ']'
+      @io.flush
+    end
+
+    def write(obj)
+      assert_started
+      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)
+      assert_started
+      if n < 1
+        @io << '[]'
+      else
+        @io << '['
+        @nested <<  [false, n]
+      end
+    end
+
+    def write_map_header(n)
+      assert_started
+      if n < 1
+        @io << '{}'
+      else
+        @io << '{'
+        @nested <<  [true, n * 2]
+      end
+    end
+
+    def write_nil
+      assert_started
+      @io << 'null'
+      write_delim
+    end
+
+    def to_s
+      to_json
+    end
+
+    def to_json
+      string = @io.string
+      if @indent > 0
+        options = { :indent => ' ' * @indent }
+        string = ::JSON.pretty_unparse(::JSON.parse(string), options)
+      end
+      string
+    end
+
+    # Write a payload object. Not subject to extensions
+    def write_pl(obj)
+      @io << obj.to_json << ','
+    end
+
+    def assert_started
+      @io << '[' if @io.pos == 0
+    end
+    private :assert_started
+
+    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.class.name}"
+        end
+      else
+        write_extension(ext, obj)
+      end
+    end
+    private :write_scalar
+
+    def write_extension(ext, obj)
+      @io << '[' << extension_indicator(ext).to_json << ','
+      write_extension_payload(ext, obj)
+      if obj.is_a?(Extension::SequenceStart) && obj.sequence_size > 0
+        @nested << [false, obj.sequence_size]
+      else
+        @io.pos -= 1
+        @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)
+      parsed = ::JSON.parse(io.read(nil))
+      raise SerializationError, "JSON stream is not an array" unless parsed.is_a?(Array)
+      @etor_stack = [parsed.each]
+      @type_registry = {}
+      @nested = []
+    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" if ext_block.nil?
+        obj = ext_block.call(nil)
+      end
+      obj
+    end
+
+    def register_type(extension_number, &block)
+      @type_registry[extension_number] = block
+    end
+  end
+end
+end
+end

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

@@ -0,0 +1,63 @@
+require_relative 'instance_reader'
+require_relative 'instance_writer'
+
+module Puppet::Pops
+module Serialization
+
+# Instance reader for objects that implement {Types::PuppetObject}
+# @api private
+class ObjectReader
+  include InstanceReader
+
+  def read(impl_class, value_count, deserializer)
+    type = impl_class._ptype
+    (names, types, required_count) = type.parameter_info
+    max = names.size
+    unless value_count >= required_count && value_count <= max
+      raise Serialization::SerializationError, "Feature count mismatch for #{impl_class.name}. Expected #{min} - #{max}, actual #{value_count}"
+    end
+    # Deserializer must know about this instance before we read its attributes
+    val = deserializer.remember(impl_class.allocate)
+    args = Array.new(value_count) { deserializer.read }
+    types.each_with_index do |ptype, index|
+      if index < args.size
+        arg = args[index]
+        Types::TypeAsserter.assert_instance_of(nil, ptype, arg) { "#{type.name}[#{names[index]}]" } unless arg == :default
+      else
+        attr = type[names[index]]
+        raise Serialization::SerializationError, "Missing default value for #{type.name}[#{names[index]}]" unless attr.value?
+        args << attr.value
+      end
+    end
+    val.send(:initialize, *args)
+    val
+  end
+
+  INSTANCE = ObjectReader.new
+end
+
+# Instance writer for objects that implement {Types::PuppetObject}
+# @api private
+class ObjectWriter
+  include InstanceWriter
+
+  def write(type, value, serializer)
+    impl_class = value.class
+    (names, types, required_count) = type.parameter_info(true)
+    args = names.map { |name| value.send(name) }
+
+    # Pop optional arguments that are nil
+    while args.size > required_count
+      break unless args.last.nil?
+      args.pop
+    end
+
+    serializer.start_object(type.name, args.size)
+    args.each { |arg| serializer.write(arg) }
+  end
+
+  INSTANCE = ObjectWriter.new
+end
+end
+end
+

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

@@ -0,0 +1,151 @@
+require_relative 'instance_reader'
+require_relative 'instance_writer'
+
+module Puppet::Pops
+module Serialization
+
+# @api private
+module RGen
+  class Base
+    def features(impl_class)
+      impl_class.ecore.eAllStructuralFeatures.reject {|feature| feature.derived }
+    end
+  end
+
+  # Instance reader for RGen::Ecore objects
+  # @api private
+  class RGenReader < Base
+    include InstanceReader
+
+    def read(impl_class, value_count, deserializer)
+      features = features(impl_class)
+      raise SerializationError, "Feature count mismatch for #{impl_class}" unless value_count == features.size
+      # Deserializer must know about this instance before we read its attributes
+      obj = deserializer.remember(impl_class.new)
+      features.each { |feature| obj.setGeneric(feature.name, deserializer.read) }
+      obj
+    end
+
+    INSTANCE = RGenReader.new
+  end
+
+  # Instance writer for RGen::Ecore objects
+  # @api private
+  class RGenWriter < Base
+    include InstanceWriter
+
+    def write(type, value, serializer)
+      impl_class = value.class
+      features = features(impl_class)
+      serializer.start_object(type.name, features.size)
+      features.each { |feature| serializer.write(value.getGeneric(feature.name)) }
+    end
+
+    INSTANCE = RGenWriter.new
+  end
+
+  # A generator that produces a {Types::PTypeSetType} instance based on an ruby {Module}
+  # that represents an RGen::ECore::EPackage.
+  #
+  # The generator is not complete. In particular, it does not deal with:
+  # - references that extend beyond eCore and the given ePackage
+  # - sub packages
+  # - methods
+  # - annotations
+  #
+  class TypeGenerator
+
+    ECore = ::RGen::ECore
+
+    def generate_type_set(namespace, package, loader)
+      types = {}
+      package.constants.each do |c|
+        cls = package.const_get(c)
+        next unless cls.is_a?(Class) && cls.respond_to?(:ecore)
+        e_class = cls.ecore
+        types[e_class.name] = generate_type_hash(e_class)
+      end
+      type_set = Types::PTypeSetType.new(namespace, {
+        Pcore::KEY_PCORE_VERSION => Pcore::PCORE_VERSION,
+        Types::KEY_VERSION => '0.1.0',
+        Types::KEY_TYPES => types
+      }, Pcore::RUNTIME_NAME_AUTHORITY).resolve(Types::TypeParser.singleton, loader)
+
+      type_set.types.values.each do |type|
+        type.reader = RGenReader::INSTANCE
+        type.writer = RGenWriter::INSTANCE
+      end
+      type_set
+    end
+
+    def generate_type_hash(e_class)
+      attributes = {}
+      e_class.eStructuralFeatures.each do |feature|
+        attr = {}
+        attributes[feature.name] = attr
+        type = feature_type(feature)
+        value = feature.defaultValue
+        if value.nil?
+          if feature.lowerBound == 0
+            if feature.upperBound == -1 || feature.upperBound > 1
+              attr[Types::KEY_VALUE] = []
+            elsif !feature.derived
+              type = Types::POptionalType.new(type)
+              attr[Types::KEY_VALUE] = nil
+            end
+          end
+        else
+          value = value.to_s if value.is_a?(Symbol)
+          attr['value'] = value
+        end
+        attr[Types::KEY_TYPE] = type
+        if feature.derived
+          attr[Types::KEY_KIND] = Types::PObjectType::ATTRIBUTE_KIND_DERIVED
+        elsif feature.unsettable
+          attr[Types::KEY_KIND] = Types::PObjectType::ATTRIBUTE_KIND_CONSTANT
+        end
+      end
+      result = { Types::KEY_ATTRIBUTES => attributes }
+      supers = e_class.eSuperTypes
+      case supers.size
+      when 0
+      when 1
+        result['parent'] = Types::PTypeReferenceType.new(supers[0].name)
+      else
+        raise SerializationError, "Multiple inheritance is not supported. #{e_class.name} has #{supers.size} super types"
+      end
+      result
+    end
+
+    def feature_type(feature)
+      eType = feature.eType
+      type = case eType
+      when ECore::EInt, ECore::ELong
+        Types::PIntegerType::DEFAULT
+      when ECore::EFloat
+        Types::PFloatType::DEFAULT
+      when ECore::EEnum
+        Types::PEnumType.new(eType.eLiterals.map { |e| e.name })
+      when ECore::EBoolean
+        Types::PBooleanType::DEFAULT
+      when ECore::EString
+        Types::PStringType::DEFAULT
+      when ECore::EClass
+        Types::PTypeReferenceType.new(eType.name)
+      else
+        Types::PAnyType::DEFAULT
+      end
+
+      case feature.upperBound
+      when 1
+        type
+      when -1
+        Types::PArrayType.new(type, Types::PIntegerType.new(feature.lowerBound))
+      else
+        Types::PArrayType.new(type, Types::PIntegerType.new(feature.lowerBound, feature.upperBound))
+      end
+    end
+  end
+end
+end
+end