openvox 7.37.1

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_relative '../../../puppet/util/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
+      ::Puppet::Util::Json.load(io_string)
+    end
+
+    def to_json
+      if @indent > 0
+        ::Puppet::Util::Json.dump(to_a, { :pretty => true, :indent => ' ' * @indent })
+      else
+        io_string
+      end
+    end
+
+    # Write a payload object. Not subject to extensions
+    def write_pl(obj)
+      @io << Puppet::Util::Json.dump(obj) << ','
+    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 << Puppet::Util::Json.dump(obj)
+          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
+        ::Puppet::Util::Json.load(io.read)
+      when String
+        ::Puppet::Util::Json.load(io)
+      else
+        io
+      end
+    end
+  end
+end
+end
+end

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

@@ -0,0 +1,127 @@
+require_relative '../../../puppet/concurrent/thread_local_singleton'
+
+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#to_json_path}
+  # method.
+  #
+  # @api private
+  class Resolver
+    extend Puppet::Concurrent::ThreadLocalSingleton
+
+    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)
+      v = resolve_any(factory.model.body, context, path)
+      v.is_a?(Builder) ? v.resolve : v
+    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,70 @@
+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(type, impl_class, value_count, deserializer)
+    (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 && 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, _, 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
+

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

@@ -0,0 +1,140 @@
+require_relative 'extension'
+
+module Puppet::Pops
+module Serialization
+  # The serializer is capable of writing, arrays, maps, and complex objects using an underlying protocol writer. It takes care of
+  # tabulating and disassembling complex objects.
+  # @api public
+  class Serializer
+    # Provides access to the writer.
+    # @api private
+    attr_reader :writer
+
+    # @param writer [AbstractWriter] the writer that is used for writing primitive values
+    # @param options [{String, Object}] serialization options
+    # @option options [Boolean] :type_by_reference `true` if Object types are serialized by name only.
+    # @api public
+    def initialize(writer, options = EMPTY_HASH)
+      @written = {}
+      @writer = writer
+      @options = options
+    end
+
+    # Tell the underlying writer to finish
+    # @api public
+    def finish
+      @writer.finish
+    end
+
+    # Write an object
+    # @param [Object] value the object to write
+    # @api public
+    def write(value)
+      case value
+      when Integer, Float, String, true, false, nil
+        @writer.write(value)
+      when :default
+        @writer.write(Extension::Default::INSTANCE)
+      else
+        index = @written[value.object_id]
+        if index.nil?
+          write_tabulated_first_time(value)
+        else
+          @writer.write(Extension::Tabulation.new(index))
+        end
+      end
+    end
+
+    # Write the start of an array.
+    # @param [Integer] size the size of the array
+    # @api private
+    def start_array(size)
+      @writer.write(Extension::ArrayStart.new(size))
+    end
+
+    # Write the start of a map (hash).
+    # @param [Integer] size the number of entries in the map
+    # @api private
+    def start_map(size)
+      @writer.write(Extension::MapStart.new(size))
+    end
+
+    # Write the start of a complex pcore object
+    # @param [String] type_ref the name of the type
+    # @param [Integer] attr_count the number of attributes in the object
+    # @api private
+    def start_pcore_object(type_ref, attr_count)
+      @writer.write(Extension::PcoreObjectStart.new(type_ref, attr_count))
+    end
+
+    # Write the start of a complex object
+    # @param [Integer] attr_count the number of attributes in the object
+    # @api private
+    def start_object(attr_count)
+      @writer.write(Extension::ObjectStart.new(attr_count))
+    end
+
+    def push_written(value)
+      @written[value.object_id] = @written.size
+    end
+
+    # Write the start of a sensitive object
+    # @api private
+    def start_sensitive
+      @writer.write(Extension::SensitiveStart::INSTANCE)
+    end
+
+    def type_by_reference?
+      @options[:type_by_reference] == true
+    end
+
+    def to_s
+      "#{self.class.name} with #{@writer}"
+    end
+
+    def inspect
+      to_s
+    end
+
+    # First time write of a tabulated object. This means that the object is written and then remembered. Subsequent writes
+    # of the same object will yield a write of a tabulation index instead.
+    # @param [Object] value the value to write
+    # @api private
+    def write_tabulated_first_time(value)
+      case
+      when value.instance_of?(Symbol),
+          value.instance_of?(Regexp),
+          value.instance_of?(SemanticPuppet::Version),
+          value.instance_of?(SemanticPuppet::VersionRange),
+          value.instance_of?(Time::Timestamp),
+          value.instance_of?(Time::Timespan),
+          value.instance_of?(Types::PBinaryType::Binary),
+          value.is_a?(URI)
+        push_written(value)
+        @writer.write(value)
+      when value.instance_of?(Array)
+        push_written(value)
+        start_array(value.size)
+        value.each { |elem| write(elem) }
+      when value.instance_of?(Hash)
+        push_written(value)
+        start_map(value.size)
+        value.each_pair { |key, val| write(key); write(val) }
+      when value.instance_of?(Types::PSensitiveType::Sensitive)
+        start_sensitive
+        write(value.unwrap)
+      when value.instance_of?(Types::PTypeReferenceType)
+        push_written(value)
+        @writer.write(value)
+      when value.is_a?(Types::PuppetObject)
+        value._pcore_type.write(value, self)
+      else
+        impl_class = value.class
+        type = Loaders.implementation_registry.type_for_module(impl_class)
+        raise SerializationError, _("No Puppet Type found for %{klass}") % { klass: impl_class.name } unless type.is_a?(Types::PObjectType)
+        type.write(value, self)
+      end
+    end
+  end
+end
+end

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

@@ -0,0 +1,67 @@
+module Puppet::Pops
+module Serialization
+  # Implements all the constructors found in the Time class and ensures that
+  # the created Time object can be serialized and deserialized using its
+  # seconds and nanoseconds without loss of precision.
+  #
+  # @deprecated No longer in use. Functionality replaced by Timestamp
+  # @api private
+  class TimeFactory
+
+    NANO_DENOMINATOR = 10**9
+
+    def self.at(*args)
+      sec_nsec_safe(Time.at(*args))
+    end
+
+    def self.gm(*args)
+      sec_nsec_safe(Time.gm(*args))
+    end
+
+    def self.local(*args)
+      sec_nsec_safe(Time.local(*args))
+    end
+
+    def self.mktime(*args)
+      sec_nsec_safe(Time.mktime(*args))
+    end
+
+    def self.new(*args)
+      sec_nsec_safe(Time.new(*args))
+    end
+
+    def self.now
+      sec_nsec_safe(Time.now)
+    end
+
+    def self.utc(*args)
+      sec_nsec_safe(Time.utc(*args))
+    end
+
+    # Creates a Time object from a Rational defined as:
+    #
+    # (_sec_ * #NANO_DENOMINATOR + _nsec_) / #NANO_DENOMINATOR
+    #
+    # This ensures that a Time object can be reliably serialized and using its
+    # its #tv_sec and #tv_nsec values and then recreated again (using this method)
+    # without loss of precision.
+    #
+    # @param sec [Integer] seconds since Epoch
+    # @param nsec [Integer] nano seconds
+    # @return [Time] the created object
+    #
+    def self.from_sec_nsec(sec, nsec)
+      Time.at(Rational(sec * NANO_DENOMINATOR + nsec, NANO_DENOMINATOR))
+    end
+
+    # Returns a new Time object that is adjusted to ensure that precision is not
+    # lost when it is serialized and deserialized using its seconds and nanoseconds
+    # @param t [Time] the object to adjust
+    # @return [Time] the adjusted object
+    #
+    def self.sec_nsec_safe(t)
+      from_sec_nsec(t.tv_sec, t.tv_nsec)
+    end
+  end
+end
+end