#60 improve Lionweb integration (deserialization only)

Author: alessiostalla

src/interop/json.ts

@@ -33,11 +33,12 @@ Node.prototype[TO_JSON_SYMBOL] = function (withIds?: Indexer) {
         }
         const element = node[p];
         if(element !== undefined && element !== null) {
-            if(node.isChild(p)) {
-                if(element instanceof Node) {
-                    result[p] = toJSON(element, withIds);
-                } else if(Array.isArray(element)) {
+            const containment = node.containment(p);
+            if(containment) {
+                if(containment.multiple) {
                     result[p] = element.map(e => toJSON(e));
+                } else {
+                    result[p] = toJSON(element, withIds);
                 }
             }
             else if (element instanceof ReferenceByName) {
@@ -55,4 +56,4 @@ Node.prototype[TO_JSON_SYMBOL] = function (withIds?: Indexer) {
         }
     }
     return result;
-}
+}

src/interop/lionweb.ts

@@ -1,7 +1,6 @@
 import {
     Classifier,
     Containment, deserializeLanguages,
-    EnumerationLiteral,
     Feature,
     Id,
     InstantiationFacade, Language,
@@ -27,7 +26,7 @@ export class LanguageMapping {
 
     extend(languageMapping: LanguageMapping): this {
         const entries = languageMapping.nodeTypes.entries();
-        for (let entry of entries) {
+        for (const entry of entries) {
             this.nodeTypes.set(entry[0], entry[1]);
             this.classifiers.set(entry[1], entry[0]);
         }
@@ -39,14 +38,14 @@ export class TylasuInstantiationFacade implements InstantiationFacade<TylasuNode
 
     constructor(public languageMappings: LanguageMapping[] = [STARLASU_LANGUAGE_MAPPING]) {}
 
-    encodingOf(literal: EnumerationLiteral): unknown {
+    encodingOf(): unknown {
         return undefined;
     }
     nodeFor(parent: TylasuNode | undefined, classifier: Classifier, id: string, propertySettings: {
         [p: string]: unknown
     }): TylasuNode {
         let node: Node | undefined;
-        for (let language of this.languageMappings) {
+        for (const language of this.languageMappings) {
             const nodeType = language.classifiers.get(classifier);
             if (nodeType) {
                 node = this.makeNode(nodeType, parent?.node, propertySettings);
@@ -66,7 +65,11 @@ export class TylasuInstantiationFacade implements InstantiationFacade<TylasuNode
     }
     setFeatureValue(node: TylasuNode, feature: Feature, value: unknown): void {
         if (feature instanceof Containment) {
-            node.node.setChild(feature.name, (value as TylasuNode)?.node);
+            if (feature.multiple) {
+                node.node.addChild(feature.name, (value as TylasuNode)?.node);
+            } else {
+                node.node.setChild(feature.name, (value as TylasuNode)?.node);
+            }
         } else {
             node.node[feature.name] = value;
         }

src/model/model.ts

@@ -157,15 +157,20 @@ export abstract class Node extends Origin implements Destination {
         });
     }
 
-    isChild(name: string): boolean {
-        return this.getChildNames().indexOf(name) >= 0;
+    containment(name: string): { multiple: boolean } | undefined {
+        const props = this.nodeDefinition?.properties || {};
+        if (name in props) {
+            return props[name].child ? { multiple: !!props[name].multiple } : undefined;
+        } else {
+            return undefined;
+        }
     }
 
     setChild(name: string, child: Node): void {
-        if(!this.isChild(name)) {
-            throw new Error("Not a child: " + name);
-        }
-        if(Array.isArray(this[name])) {
+        const containment = this.containment(name);
+        if(!containment) {
+            throw new Error("Not a containment: " + name);
+        } else if (containment.multiple) {
             throw new Error(name + " is a collection, use addChild");
         }
         if(child.parent && child.parent != this) {
@@ -178,10 +183,10 @@ export abstract class Node extends Origin implements Destination {
     }
 
     addChild(name: string, child: Node): void {
-        if(!this.isChild(name)) {
-            throw new Error("Not a child: " + name);
-        }
-        if(this[name] && !Array.isArray(this[name])) {
+        const containment = this.containment(name);
+        if(!containment) {
+            throw new Error("Not a containment: " + name);
+        } else if (!containment.multiple) {
             throw new Error(name + " is not a collection, use setChild");
         }
         if(child.parent && child.parent != this) {

tests/interop/lionweb.test.ts

@@ -1,5 +1,6 @@
 import FS_LANGUAGE_JSON from "./fs-language.json";
 import FS_MODEL from "./fs-model.json";
+import {expect} from "chai";
 import {deserializeChunk, deserializeLanguages, SerializationChunk} from "@lionweb/core";
 import {Children, Node} from "../../src";
 import {
@@ -34,6 +35,20 @@ describe('Lionweb integration', function() {
     it("Can deserialize simple model",
         function () {
             const nodes = deserializeChunk(FS_MODEL, new TylasuInstantiationFacade([FS_LANGUAGE_MAPPING]), [FS_LANGUAGE], []);
-            expect(nodes).not.toBeFalsy();
+            expect(nodes).not.to.be.empty;
+            expect(nodes.length).to.equal(1);
+            const root = nodes[0];
+            expect(root.node).to.be.instanceof(Directory);
+            let dir = root.node as Directory;
+            expect(dir.name).to.equal("resources.zip");
+            expect(dir.files.length).to.equal(1);
+            expect(dir.files[0]).to.be.instanceof(Directory);
+            dir = dir.files[0] as Directory;
+            expect(dir.name).to.equal("resources");
+            expect(dir.files.length).to.equal(15);
+            expect(dir.files[0]).to.be.instanceof(TextFile);
+            const file = dir.files[0] as TextFile;
+            expect(file.name).to.equal("delegate.egl");
+            expect(file.contents.substring(0, 10)).to.equal("Delegate F");
         });
 });

tests/json.test.ts

@@ -1,6 +1,6 @@
 import {expect} from "chai";
 
-import {ASTNode, Child, GenericNode, Node, PossiblyNamed, Property, ReferenceByName} from "../src";
+import {ASTNode, Child, Children, GenericNode, Node, PossiblyNamed, Property, ReferenceByName} from "../src";
 import {JSONGenerator} from "../src";
 import {Indexer} from "../src/interop/indexing";
 
@@ -183,18 +183,16 @@ describe('JSON generator', function() {
 
 @ASTNode("", "NodeWithChildren")
 class NodeWithChildren extends Node {
-    payload: number
+    payload: number;
     @Child()
-    singleChild: NodeWithChildren
-    @Child()
-    childrenCollection: NodeWithChildren[]
+    singleChild: NodeWithChildren;
+    @Children()
+    childrenCollection: NodeWithChildren[];
 }
 
 @ASTNode("", "DummyNamedNode")
 class DummyNamedNode extends Node implements PossiblyNamed {
-    constructor(
-        public name?: string
-    ) {
+    constructor(public name?: string) {
         super();
     }
 }