puppet 4.10.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/json.rb

@@ -201,7 +201,7 @@ module JSON
           @io << obj.to_json
           write_delim
         else
-          raise SerializationError, "Unable to serialize a #{obj.class.name}"
+          raise SerializationError, _("Unable to serialize a %{obj}") % { obj: obj.class.name }
         end
       else
         write_extension(ext, obj)
@@ -248,14 +248,14 @@ module JSON
 
     def re_initialize(io)
       parsed = parse_io(io)
-      raise SerializationError, "JSON stream is not an array. It is a #{io.class.name}" unless parsed.is_a?(Array)
+      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?
+        raise SerializationError, _('Unexpected end of input') if @etor_stack.empty?
         etor = @etor_stack.last
         begin
           obj = etor.next
@@ -269,7 +269,7 @@ module JSON
         @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?
+        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

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

@@ -10,11 +10,11 @@ class ObjectReader
   include InstanceReader
 
   def read(impl_class, value_count, deserializer)
-    type = impl_class._ptype
+    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 #{impl_class.name}. Expected #{required_count} - #{max}, actual #{value_count}"
+      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)
@@ -25,7 +25,7 @@ class ObjectReader
         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?
+        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
@@ -43,16 +43,16 @@ class ObjectWriter
 
   def write(type, value, serializer)
     impl_class = value.class
-    (names, types, required_count) = type.parameter_info(impl_class, true)
+    (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 args.last == type[names[args.size-1]].value
+      break unless type[names[args.size-1]].default_value?(args.last)
       args.pop
     end
 
-    if type.name.start_with?('Pcore::')
+    if type.name.start_with?('Pcore::') || serializer.type_by_reference?
       serializer.push_written(value)
       serializer.start_pcore_object(type.name, args.size)
     else

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

@@ -10,11 +10,14 @@ module Serialization
     # @api private
     attr_reader :writer
 
-    # @param [AbstractWriter] writer the writer that is used for writing primitive values
+    # @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)
+    def initialize(writer, options = EMPTY_HASH)
       @written = {}
       @writer = writer
+      @options = options
     end
 
     # Tell the underlying writer to finish
@@ -81,35 +84,53 @@ module Serialization
       @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 value
-      when Symbol, Regexp, SemanticPuppet::Version, SemanticPuppet::VersionRange, Time::Timestamp, Time::Timespan, Types::PBinaryType::Binary
+      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)
         push_written(value)
         @writer.write(value)
-      when Array
+      when value.instance_of?(Array)
         push_written(value)
         start_array(value.size)
         value.each { |elem| write(elem) }
-      when Hash
+      when value.instance_of?(Hash)
         push_written(value)
         start_map(value.size)
         value.each_pair { |key, val| write(key); write(val) }
-      when Types::PSensitiveType::Sensitive
+      when value.instance_of?(Types::PSensitiveType::Sensitive)
         start_sensitive
         write(value.unwrap)
-      when Types::PTypeReferenceType
+      when value.instance_of?(Types::PTypeReferenceType)
         push_written(value)
         @writer.write(value)
-      when Types::PuppetObject
-        value._ptype.write(value, self)
+      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 #{impl_class.name}" unless type.is_a?(Types::PObjectType)
+        raise SerializationError, _("No Puppet Type found for %{klass}") % { klass: impl_class.name } unless type.is_a?(Types::PObjectType)
         type.write(value, self)
       end
     end