puppet 4.1.0 → 5.0.0

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

@@ -0,0 +1,181 @@
+module Puppet::Pops
+module Serialization
+  # 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)
+      @current[@key] = value unless @current.nil?
+      with_value(value, &block) if block_given?
+      value
+    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(pcore_type.allocate) do
+            @current._pcore_init_from_hash(with_value({}) { value.each_pair { |key, elem| with(key) { convert(elem) } } })
+          end
+        else
+          build(pcore_type.allocate) do
+            args = with_value([]) { value.values.each_with_index { |elem, idx| with(idx) { convert(elem) }}}
+            @current.send(:initialize, *args)
+          end
+        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
+
+    def data_to_pcore_type(pcore_type)
+      if pcore_type.is_a?(Hash)
+        without_value { convert(pcore_type) }
+      else
+        type = Types::TypeParser.singleton.parse(pcore_type, @loader)
+        if type.is_a?(Types::PTypeReferenceType)
+          raise SerializationError, _('No implementation mapping found for Puppet Type %{type_name}') % { type_name: pcore_type }
+        end
+        type
+      end
+    end
+  end
+end
+end

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,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

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

@@ -0,0 +1,126 @@
+module Puppet::Pops
+module Serialization
+module JsonPath
+  # Creates a _json_path_ reference from the given `path` argument
+  #
+  # @path path [Array<Integer,String>] An array of integers and strings
+  # @return [String] the created json_path
+  #
+  # @api private
+  def self.to_json_path(path)
+    p = '$'
+    path.each do |seg|
+      if seg.nil?
+        p << '[null]'
+      elsif Types::PScalarDataType::DEFAULT.instance?(seg)
+        p << '[' << Types::StringConverter.singleton.convert(seg, '%p') << ']'
+      else
+        # Unable to construct json path from complex segments
+        return nil
+      end
+    end
+    p
+  end
+
+  # Resolver for JSON path that uses the Puppet parser to create the AST. The path must start
+  # with '$' which denotes the value that is passed into the parser. This parser can easily
+  # be extended with more elaborate resolution mechanisms involving document sets.
+  #
+  # The parser is limited to constructs generated by the {JsonPath#json_path_reference}
+  # method.
+  #
+  # @api private
+  class Resolver
+    def self.singleton
+      @singleton ||= self.new
+    end
+
+    def initialize
+      @parser = Parser::Parser.new
+      @visitor = Visitor.new(nil, 'resolve', 2, 2)
+    end
+
+    # Resolve the given _path_ in the given _context_.
+    # @param context [Object] the context used for resolution
+    # @param path [String] the json path
+    # @return [Object] the resolved value
+    #
+    def resolve(context, path)
+      factory = @parser.parse_string(path)
+      resolve_any(factory.model.body, context, path)
+    end
+
+    def resolve_any(ast, context, path)
+      @visitor.visit_this_2(self, ast, context, path)
+    end
+
+    def resolve_AccessExpression(ast, context, path)
+      bad_json_path(path) unless ast.keys.size == 1
+      receiver = resolve_any(ast.left_expr, context, path)
+      key = resolve_any(ast.keys[0], context, path)
+      if receiver.is_a?(Types::PuppetObject)
+        PCORE_TYPE_KEY == key ? receiver._pcore_type : receiver.send(key)
+      else
+        receiver[key]
+      end
+    end
+
+    def resolve_NamedAccessExpression(ast, context, path)
+      receiver = resolve_any(ast.left_expr, context, path)
+      key = resolve_any(ast.right_expr, context, path)
+      if receiver.is_a?(Types::PuppetObject)
+        PCORE_TYPE_KEY == key ? receiver._pcore_type : receiver.send(key)
+      else
+        receiver[key]
+      end
+    end
+
+    def resolve_QualifiedName(ast, _, _)
+      v = ast.value
+      'null' == v ? nil : v
+    end
+
+    def resolve_QualifiedReference(ast, _, _)
+      v = ast.cased_value
+      'null'.casecmp(v) == 0 ? nil : v
+    end
+
+    def resolve_ReservedWord(ast, _, _)
+      ast.word
+    end
+
+    def resolve_LiteralUndef(_, _, _)
+      'undef'
+    end
+
+    def resolve_LiteralDefault(_, _, _)
+      'default'
+    end
+
+    def resolve_VariableExpression(ast, context, path)
+      # A single '$' means root, i.e. the context.
+      bad_json_path(path) unless EMPTY_STRING == resolve_any(ast.expr, context, path)
+      context
+    end
+
+    def resolve_CallMethodExpression(ast, context, path)
+      bad_json_path(path) unless ast.arguments.empty?
+      resolve_any(ast.functor_expr, context, path)
+    end
+
+    def resolve_LiteralValue(ast, _, _)
+      ast.value
+    end
+
+    def resolve_Object(ast, _, path)
+      bad_json_path(path)
+    end
+
+    def bad_json_path(path)
+      raise SerializationError, _('Unable to parse jsonpath "%{path}"') % { :path => path }
+    end
+    private :bad_json_path
+  end
+end
+end
+end

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

@@ -0,0 +1,71 @@
+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._pcore_type
+    (names, types, required_count) = type.parameter_info(impl_class)
+    max = names.size
+    unless value_count >= required_count && value_count <= max
+      raise Serialization::SerializationError, _("Feature count mismatch for %{value0}. Expected %{required_count} - %{max}, actual %{value_count}") % { value0: impl_class.name, required_count: required_count, max: max, value_count: 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}[%{name}]") % { type_name: type.name, 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(impl_class)
+    args = names.map { |name| value.send(name) }
+
+    # Pop optional arguments that are default
+    while args.size > required_count
+      break unless type[names[args.size-1]].default_value?(args.last)
+      args.pop
+    end
+
+    if type.name.start_with?('Pcore::') || serializer.type_by_reference?
+      serializer.push_written(value)
+      serializer.start_pcore_object(type.name, args.size)
+    else
+      serializer.start_object(args.size + 1)
+      serializer.write(type)
+      serializer.push_written(value)
+    end
+
+    args.each { |arg| serializer.write(arg) }
+  end
+
+  INSTANCE = ObjectWriter.new
+end
+end
+end
+