Moddle 7

lib/read.js

@@ -215,11 +215,19 @@ ReferenceHandler.prototype.handleNode = function(node) {
     this.element = this.createReference(node);
   }
 
+  const property = this.property;
+
+  const idAttr = property.xml && property.xml.idAttr;
+
+  if (idAttr && node.attributes[idAttr]) {
+    this.element.id = node.attributes[idAttr];
+  }
+
   return this;
 };
 
 ReferenceHandler.prototype.handleEnd = function() {
-  this.element.id = this.body;
+  this.element.id = this.element.id || this.body;
 };
 
 ReferenceHandler.prototype.createReference = function(node) {
@@ -383,6 +391,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 +444,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 +460,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)

lib/write.js

@@ -245,16 +245,31 @@ function ReferenceSerializer(tagName) {
   this.tagName = tagName;
 }
 
-ReferenceSerializer.prototype.build = function(element) {
+ReferenceSerializer.prototype.build = function(property, element) {
+  this.property = property;
   this.element = element;
+
   return this;
 };
 
 ReferenceSerializer.prototype.serializeTo = function(writer) {
-  writer
-    .appendIndent()
-    .append('<' + this.tagName + '>' + this.element.id + '</' + this.tagName + '>')
-    .appendNewLine();
+
+  const property = this.property;
+
+  const idAttr = property.xml && property.xml.idAttr;
+
+  const id = this.element.id;
+  const tagName = this.tagName;
+
+  writer.appendIndent();
+
+  if (idAttr) {
+    writer.append('<' + tagName + ' ' + idAttr + '="' + id + '" />');
+  } else {
+    writer.append('<' + tagName + '>' + id + '</' + tagName + '>');
+  }
+
+  writer.appendNewLine();
 };
 
 function BodySerializer() {}
@@ -532,7 +547,7 @@ ElementSerializer.prototype.parseContainments = function(properties) {
     } else
     if (isReference) {
       forEach(value, function(v) {
-        body.push(new ReferenceSerializer(self.addTagName(self.nsPropertyTagName(p))).build(v));
+        body.push(new ReferenceSerializer(self.addTagName(self.nsPropertyTagName(p))).build(p, v));
       });
     } else {
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "moddle-xml",
-  "version": "10.1.0",
+  "version": "11.0.0-exp.4",
   "description": "XML import/export for documents described with moddle",
   "scripts": {
     "all": "run-s lint test distro",
@@ -54,7 +54,7 @@
     "eslint": "^8.34.0",
     "eslint-plugin-bpmn-io": "^1.0.0",
     "mocha": "^10.0.0",
-    "moddle": "^6.2.0",
+    "moddle": "^7.0.0-exp.3",
     "npm-run-all": "^4.1.5",
     "rollup": "^3.17.2"
   },

test/fixtures/model/properties.json

@@ -177,6 +177,20 @@
         }
       ]
     },
+    {
+      "name": "ReferencingNestedRef",
+      "superClass": [ "BaseWithId" ],
+      "properties": [
+        {
+          "name": "referencedComplex",
+          "type": "Complex",
+          "isReference": true,
+          "xml": {
+            "idAttr": "idref"
+          }
+        }
+      ]
+    },
     {
       "name": "ReferencingCollection",
       "superClass": [ "BaseWithId" ],

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,32 @@
+{
+  "name": "XMI",
+  "uri": "http://www.omg.org/spec/XMI/20131001",
+  "prefix": "xmi",
+  "types": [
+    {
+      "name": "XMI",
+      "properties": [
+        { "name": "extension", "type": "Extension", "isMany": true, "xml": { "serialize": "xmi:type" } }
+      ]
+    },
+    {
+      "name": "Extension",
+      "superClass": [
+        "Element"
+      ]
+    },
+    {
+      "name": "Typed",
+      "extends": [
+        "xmi:Extension"
+      ],
+      "properties": [
+        {
+          "name": "type",
+          "type": "String",
+          "isAttr": true
+        }
+      ]
+    }
+  ]
+}