puppet 4.10.12 → 5.0.0

data/lib/puppet/pops/resource/resource_type_impl.rb

@@ -21,7 +21,7 @@ class ResourceTypeImpl
   include Puppet::CompilableResourceType
 
   # Returns the Puppet Type for this instance.
-  def self._ptype
+  def self._pcore_type
     @ptype
   end
 
@@ -149,7 +149,7 @@ class ResourceTypeImpl
         # Here it is silently ignored.
         nil
       when 1
-        if @title_patterns_hash.nil?
+        if @title_pattners_hash.nil?
           [ [ /(.*)/m, [ [@key_attributes.first] ] ] ]
         else
           # TechDebt: The case of having one namevar and an empty title patterns is unspecified behavior in puppet.

data/lib/puppet/pops/serialization.rb

@@ -6,12 +6,36 @@ module Serialization
 
   class SerializationError < Puppet::Error
   end
+
+  PCORE_TYPE_KEY = '__pcore_type__'.freeze
+
+  # Key used when the value can be represented as, and recreated from, a single string that can
+  # be passed to a `from_string` method or an array of values that can be passed to the default
+  # initializer method.
+  PCORE_VALUE_KEY = '__pcore_value__'.freeze
+
+  # Type key used for hashes that contain keys that are not of type String
+  PCORE_TYPE_HASH = 'Hash'.freeze
+
+  # Type key used for symbols
+  PCORE_TYPE_SENSITIVE = 'Sensitive'.freeze
+
+  # Type key used for symbols
+  PCORE_TYPE_SYMBOL = 'Symbol'.freeze
+
+  # Type key used for Default
+  PCORE_TYPE_DEFAULT = 'Default'.freeze
+
+  # Type key used for document local references
+  PCORE_LOCAL_REF_SYMBOL = 'LocalRef'.freeze
 end
 end
 
+require_relative 'serialization/json_path'
+require_relative 'serialization/from_data_converter'
+require_relative 'serialization/to_data_converter'
 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_writer.rb

@@ -56,7 +56,7 @@ class AbstractWriter
     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
+      raise SerializationError, _('Integer out of bounds') if value > MAX_INTEGER || value < MIN_INTEGER
     when Numeric, Symbol, Extension::NotTabulated, true, false, nil
       # not tabulated
     else
@@ -202,6 +202,14 @@ class AbstractWriter
       end
     end
   end
+
+  def to_s
+    "#{self.class.name}"
+  end
+
+  def inspect
+    to_s
+  end
 end
 end
 end

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

@@ -43,7 +43,7 @@ module Serialization
       when Extension::PcoreObjectStart
         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)
+        raise SerializationError, _("No implementation mapping found for Puppet Type %{type_name}") % { type_name: type_name } if type.is_a?(Types::PTypeReferenceType)
         result = type.read(val.attribute_count, self)
         if result.is_a?(Types::PObjectType)
           existing_type = loader.load(:type, result.name)

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,12 +43,12 @@ 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