WIP: resolve property references to other namespace

lib/descriptor-builder.js

@@ -135,11 +135,20 @@ DescriptorBuilder.prototype.addNamedProperty = function(p, validate) {
       propsByName = this.propertiesByName;
 
   if (validate) {
-    this.assertNotDefined(p, ns.name);
-    this.assertNotDefined(p, ns.localName);
+    this.assertNotDefined(p);
   }
 
-  propsByName[ns.name] = propsByName[ns.localName] = p;
+  if (!propsByName[ns.name]) {
+    propsByName[ns.name] = p;
+
+    if (ns.prefix === this.ns.prefix || !propsByName[ns.localName]) {
+
+      // property defined in local ns, also add with localName
+      propsByName[ns.localName] = p;
+    }
+  }
+  else if (!propsByName[ns.localName])
+    propsByName[ns.localName] = p;
 };
 
 DescriptorBuilder.prototype.removeNamedProperty = function(p) {
@@ -172,15 +181,23 @@ DescriptorBuilder.prototype.setIdProperty = function(p, validate) {
   this.idProperty = p;
 };
 
-DescriptorBuilder.prototype.assertNotDefined = function(p, name) {
-  var propertyName = p.name,
-      definedProperty = this.propertiesByName[propertyName];
+DescriptorBuilder.prototype.assertNotDefined = function(p) {
+  var ns = p.ns,
+      localName = ns.localName,
+      nsName = ns.name,
+      propByName = this.propertiesByName;
+
+  // redefining properties inside the same namespace without 'redefines' or
+  // 'replaces' is not allowed.
+  if (propByName[nsName] && propByName[localName]) {
+    var definedProperty = propByName[localName],
+        prevDefinedName = definedProperty.definedBy.ns.name + '#' + localName,
+        curDefinedName = p.definedBy.ns.name + '#' + localName;
 
-  if (definedProperty) {
     throw new Error(
-      'property <' + propertyName + '> already defined; ' +
-      'override of <' + definedProperty.definedBy.ns.name + '#' + definedProperty.ns.name + '> by ' +
-      '<' + p.definedBy.ns.name + '#' + p.ns.name + '> not allowed without redefines');
+      'property <' + localName + '> already defined in namespace <' +
+        ns.prefix + '>; override of <' + prevDefinedName + '> by ' +
+        '<' + curDefinedName + '> not allowed without redefines or replaces');
   }
 };
 
@@ -230,4 +247,4 @@ DescriptorBuilder.prototype.addTrait = function(t, inherited) {
 
   types.push(t);
   typesByName[typeName] = t;
-};
+};

lib/factory.js

@@ -27,7 +27,17 @@ Factory.prototype.createType = function(descriptor) {
   // initialize default values
   forEach(descriptor.properties, function(p) {
     if (!p.isMany && p.default !== undefined) {
-      prototype[p.name] = p.default;
+      var name;
+
+      if (p.ns.prefix === descriptor.ns.prefix) {
+
+        // use local name if property already in local ns
+        name = p.name;
+      }
+      else {
+        name = p.ns.name;
+      }
+      prototype[name] = p.default;
     }
   });
 
@@ -58,4 +68,4 @@ Factory.prototype.createType = function(descriptor) {
   props.defineDescriptor(ModdleElement, descriptor);
 
   return ModdleElement;
-};
+};

lib/properties.js

@@ -19,10 +19,10 @@ export default function Properties(model) {
 Properties.prototype.set = function(target, name, value) {
 
   var property = this.model.getPropertyDescriptor(target, name);
-
-  var propertyName = property && property.name;
+  var propertyName = getPropertyName(target, name, property);
 
   if (isUndefined(value)) {
+
     // unset the property, if the specified value is undefined;
     // delete from $attrs (for extensions) or the target itself
     if (property) {
@@ -31,20 +31,22 @@ Properties.prototype.set = function(target, name, value) {
       delete target.$attrs[name];
     }
   } else {
-    // set the property, defining well defined properties on the fly
-    // or simply updating them in target.$attrs (for extensions)
+
+    // set the property, defining well defined properties on the fly or simply
+    // updating them in target.$attrs (for extensions)
     if (property) {
       if (propertyName in target) {
         target[propertyName] = value;
       } else {
-        defineProperty(target, property, value);
+        defineProperty(target, propertyName, property, value);
       }
     } else {
       target.$attrs[name] = value;
     }
   }
 };
 
+
 /**
  * Returns the named property of the given element
  *
@@ -56,16 +58,15 @@ Properties.prototype.set = function(target, name, value) {
 Properties.prototype.get = function(target, name) {
 
   var property = this.model.getPropertyDescriptor(target, name);
+  var propertyName = getPropertyName(target, name, property);
 
   if (!property) {
     return target.$attrs[name];
   }
 
-  var propertyName = property.name;
-
   // check if access to collection property and lazily initialize it
   if (!target[propertyName] && property.isMany) {
-    defineProperty(target, property, []);
+    defineProperty(target, propertyName, property, []);
   }
 
   return target[propertyName];
@@ -103,11 +104,28 @@ function isUndefined(val) {
   return typeof val === 'undefined';
 }
 
-function defineProperty(target, property, value) {
-  Object.defineProperty(target, property.name, {
+
+function getPropertyName(target, name, descriptor) {
+  if (!target || !name || !descriptor)
+    return undefined;
+
+  var propertyName = descriptor.name;
+
+  if (name.includes(':')) {
+    var parts = name.split(':');
+
+    if (parts[0] !== target.$descriptor.ns.prefix)
+      propertyName = descriptor.ns.name;
+  }
+
+  return propertyName;
+}
+
+function defineProperty(target, name, property, value) {
+  Object.defineProperty(target, name, {
     enumerable: !property.isReference,
     writable: true,
     value: value,
     configurable: true
   });
-}
+}

test/fixtures/model/datatype.json

@@ -7,7 +7,10 @@
       "name": "Root",
       "properties": [
         { "name": "bounds", "serialize": "xsi:type", "type": "Rect" },
-        { "name": "otherBounds", "type": "do:Rect", "serialize": "xsi:type", "isMany": true }
+        { "name": "otherBounds", "type": "do:Rect", "serialize": "xsi:type", "isMany": true },
+        {
+          "name": "defaultSingle", "type": "Boolean", "default": true
+        }
       ]
     },
     {
@@ -17,4 +20,4 @@
       ]
     }
   ]
-}
+}

test/fixtures/model/multiple-inherited-properties.json

@@ -0,0 +1,53 @@
+{
+  "name": "MultipleInheritance",
+  "uri": "http://multipleinheritance",
+  "prefix": "mh",
+  "types": [
+    {
+      "name": "AnotherRoot",
+      "properties": [
+        {
+          "name": "any",
+          "type": "AnotherRoot",
+          "isMany": true
+        },
+        {
+          "name": "many",
+          "type": "String",
+          "isMany": true
+        },
+        {
+          "name": "single",
+          "type": "String"
+        },
+        {
+          "name": "defaultSingle",
+          "type": "String",
+          "default": "mh-default-string"
+        }
+      ]
+    },
+    {
+      "name": "MultipleInherited",
+      "superClass": [ "AnotherRoot", "props:Root", "dt:Root" ],
+      "properties": [
+        {
+          "name": "anotherDefaultSingle",
+          "type": "Boolean",
+          "default": false
+        }
+      ]
+    },
+    {
+      "name": "InvalidMultipleInherited",
+      "superClass": [ "AnotherRoot", "props:Root" ],
+      "properties": [
+        {
+          "name": "defaultSingle",
+          "type": "Boolean",
+          "default": false
+        }
+      ]
+    }
+  ]
+}

test/fixtures/model/properties.json

@@ -84,6 +84,13 @@
         { "name": "idNumeric", "type": "Integer", "isAttr": true, "redefines": "BaseWithId#id", "isId": true }
       ]
     },
+    {
+      "name": "BaseWithAlreadyDefinedId",
+      "superClass": [ "BaseWithId" ],
+      "properties": [
+        { "name": "id", "type": "Integer", "isAttr": true, "isId": true }
+      ]
+    },
     {
       "name": "Attributes",
       "superClass": [ "BaseWithId" ],
@@ -122,6 +129,25 @@
           "name": "any",
           "type": "Base",
           "isMany": true
+        },
+        {
+          "name": "many",
+          "type": "Integer",
+          "isMany": true
+        },
+        {
+          "name": "single",
+          "type": "Integer"
+        },
+        {
+          "name": "defaultSingle",
+          "type": "Integer",
+          "default": 42
+        },
+        {
+          "name": "anotherDefaultSingle",
+          "type": "Integer",
+          "default": 23
         }
       ]
     },
@@ -171,4 +197,4 @@
       ]
     }
   ]
-}
+}

test/spec/moddle.js

@@ -101,7 +101,10 @@ describe('moddle', function() {
 
       expect(descriptor.ns).to.jsonEqual(expectedDescriptorNs);
       expect(descriptor.properties).to.jsonEqual(expectedDescriptorProperties);
-      expect(descriptor.propertiesByName).to.jsonEqual(expectedDescriptorPropertiesByName);
+      expect(descriptor.propertiesByName.id).to
+        .equal(descriptor.propertiesByName['props:id']);
+      expect(descriptor.propertiesByName['props:id']).to
+        .jsonEqual(expectedDescriptorPropertiesByName['props:id']);
     });