feat(read): account for xml.serialize when infering property from tag name

Author: nikku

lib/read.js

@@ -383,6 +383,44 @@ ElementHandler.prototype.createElement = function(node) {
   return instance;
 };
 
+/**
+ * Returns a property with an effective type descriptor,
+ * in case type is defined through xml -> serialize hint.
+ *
+ * @param  {any} node parsed
+ * @param  {PropertyDescriptor} property
+ *
+ * @return {PropertyDescriptor|null}
+ */
+ElementHandler.prototype.getSerializeAsTypePropertyForNode = function(node, property) {
+
+  const model = this.model;
+
+  const serializationType = getSerializationType(property);
+
+  if (!serializationType) {
+    return null;
+  }
+
+  const elementTypeName = node.attributes[serializationType];
+
+  // type is optional, if it does not exists the
+  // default type is assumed
+  if (elementTypeName) {
+
+    // convert the prefix used to the mapped form, but also
+    // take possible type prefixes from XML
+    // into account, i.e.: xsi:type="t{ActualType}",
+    const normalizedTypeName = normalizeTypeName(elementTypeName, node.ns, model);
+
+    const elementType = model.getType(normalizedTypeName);
+
+    return assign({}, property, {
+      effectiveType: getModdleDescriptor(elementType).name
+    });
+  }
+};
+
 ElementHandler.prototype.getPropertyForNode = function(node) {
 
   var name = node.name;
@@ -398,33 +436,10 @@ ElementHandler.prototype.getPropertyForNode = function(node) {
   // search for properties by name first
 
   if (property && !property.isAttr) {
-
-    const serializationType = getSerializationType(property);
-
-    if (serializationType) {
-      const elementTypeName = node.attributes[serializationType];
-
-      // type is optional, if it does not exists the
-      // default type is assumed
-      if (elementTypeName) {
-
-        // convert the prefix used to the mapped form, but also
-        // take possible type prefixes from XML
-        // into account, i.e.: xsi:type="t{ActualType}",
-        const normalizedTypeName = normalizeTypeName(elementTypeName, node.ns, model);
-
-        const elementType = model.getType(normalizedTypeName);
-
-        return assign({}, property, {
-          effectiveType: getModdleDescriptor(elementType).name
-        });
-      }
-    }
-
-    // search for properties by name first
-    return property;
+    return this.getSerializeAsTypePropertyForNode(node, property) || property;
   }
 
+  // search by properties by type
   var pkg = model.getPackage(nameNs.prefix);
 
   if (pkg) {
@@ -437,10 +452,11 @@ ElementHandler.prototype.getPropertyForNode = function(node) {
     });
 
     if (property) {
-      return assign({}, property, {
+      return this.getSerializeAsTypePropertyForNode(node, property) || assign({}, property, {
         effectiveType: getModdleDescriptor(elementType).name
       });
     }
+
   } else {
 
     // parse unknown element (maybe extension)

test/fixtures/model/uml/uml.json

@@ -0,0 +1,19 @@
+{
+  "name": "UML",
+  "uri": "http://www.omg.org/spec/UML/20131001",
+  "prefix": "uml",
+  "types": [
+    {
+      "name": "Package",
+      "superClass": [
+        "xmi:Extension"
+      ]
+    },
+    {
+      "name": "SpecialPackage",
+      "superClass": [
+        "Package"
+      ]
+    }
+  ]
+}

test/fixtures/model/uml/xmi.json

@@ -0,0 +1,23 @@
+{
+  "name": "XMI",
+  "uri": "http://www.omg.org/spec/XMI/20131001",
+  "prefix": "xmi",
+  "types": [
+    {
+      "name": "XMI",
+      "properties": [
+        { "name": "extensions", "type": "Extension", "isMany": true, "xml": { "serialize": "xmi:type" } }
+      ]
+    },
+    {
+      "name": "Extension",
+      "properties": [
+        {
+          "name": "type",
+          "type": "String",
+          "isAttr": true
+        }
+      ]
+    }
+  ]
+}

test/fixtures/xml/XMI.xmi

@@ -2819,4 +2819,51 @@ describe('Reader', function() {
 
   });
 
+
+  describe('package owned xml -> serialize property', function() {
+
+    it('should parse without warnings', async function() {
+
+      // given
+      var datatypesModel = createModel([
+        'uml/xmi',
+        'uml/uml'
+      ]);
+
+      var reader = new Reader(datatypesModel);
+      var rootHandler = reader.handler('xmi:XMI');
+
+      var xml = `
+        <xmi:XMI xmlns:xmi="http://www.omg.org/spec/XMI/20131001" xmlns:uml="http://www.omg.org/spec/UML/20131001">
+          <uml:Package xmi:type="uml:Package" />
+          <uml:Package xmi:type="uml:SpecialPackage" />
+        </xmi:XMI>
+      `;
+
+      // when
+      var {
+        rootElement,
+        warnings
+      } = await reader.fromXML(xml, rootHandler);
+
+      // then
+      expect(rootElement).to.jsonEqual({
+        $type: 'xmi:XMI',
+        extensions: [
+          {
+            $type: 'uml:Package',
+            type: 'uml:Package'
+          },
+          {
+            $type: 'uml:SpecialPackage',
+            type: 'uml:SpecialPackage'
+          }
+        ]
+      });
+
+      expect(warnings).to.be.empty;
+    });
+
+  });
+
 });