JSON generator: use node definition metadata

Author: alessiostalla

src/interop/json.ts

@@ -1,5 +1,4 @@
 import {ensureNodeDefinition, Node} from "../model/model";
-import {ReferenceByName} from "../model/naming";
 import {Indexer} from "./indexing";
 
 export const TO_JSON_SYMBOL = Symbol("toJSON");
@@ -14,46 +13,51 @@ export class JSONGenerator {
     }
 }
 
-Node.prototype[TO_JSON_SYMBOL] = function (withIds?: Indexer) {
-    const def = ensureNodeDefinition(this);
+export function defaultToJSON(node: Node, withIds?: Indexer) {
+    const def = ensureNodeDefinition(node);
     const result = {
         type: (def.package ? def.package + "." : "") + def.name
     };
 
     if (withIds) {
-        const id = withIds.getId(this);
-        if (id)
+        const id = withIds.getId(node);
+        if (id) {
             result["id"] = id;
+        }
     }
 
-    const node = this as Node;
-    for(const p in node) {
-        if(p == 'parent' || p == 'parseTreeNode') {
-            continue;
-        }
-        const element = node[p];
-        if(element !== undefined && element !== null) {
-            const containment = node.containment(p);
-            if(containment) {
-                if(containment.multiple) {
-                    result[p] = element.map(e => toJSON(e));
-                } else {
-                    result[p] = toJSON(element, withIds);
+    for(const p in node.nodeDefinition.features) {
+        const feature = node.nodeDefinition.features[p];
+        if(feature.child) {
+            if(feature.multiple) {
+                const children = node.getChildren(p);
+                if (children.length > 0) {
+                    result[p] = children.map(e => toJSON(e, withIds));
+                }
+            } else {
+                const child = node.getChild(p);
+                if (child) {
+                    result[p] = toJSON(child, withIds);
                 }
             }
-            else if (element instanceof ReferenceByName) {
-                const reference = element as ReferenceByName<any>;
+        } else if (feature.reference) {
+            const reference = node.getReference(p);
+            if (reference) {
                 result[p] = {
-                    name: reference.name
-                }
-                if (withIds) {
-                    result[p]["referred"] = reference.resolved ? withIds.getId(reference.referred) : undefined;
+                    name: reference.name,
+                    referred: reference.resolved ? withIds?.getId(reference.referred) : undefined
                 }
             }
-            else if(typeof node[p] !== "function") {
-                result[p] = node[p];
+        } else {
+            const attributeValue = node.getAttributeValue(p);
+            if (attributeValue !== undefined) {
+                result[p] = attributeValue;
             }
         }
     }
     return result;
 }
+
+Node.prototype[TO_JSON_SYMBOL] = function (withIds?: Indexer) {
+    return defaultToJSON(this as Node, withIds);
+}

tests/json.test.ts

@@ -1,6 +1,16 @@
 import {expect} from "chai";
 
-import {ASTNode, Child, Children, GenericNode, Node, PossiblyNamed, Reference, ReferenceByName} from "../src";
+import {
+    ASTNode,
+    Attribute,
+    Child,
+    Children,
+    GenericNode,
+    Node,
+    PossiblyNamed,
+    Reference,
+    ReferenceByName
+} from "../src";
 import {Indexer, JSONGenerator} from "../src";
 
 describe('JSON generator', function() {
@@ -182,6 +192,7 @@ describe('JSON generator', function() {
 
 @ASTNode("", "NodeWithChildren")
 class NodeWithChildren extends Node {
+    @Attribute()
     payload: number;
     @Child()
     singleChild: NodeWithChildren;
@@ -191,26 +202,41 @@ class NodeWithChildren extends Node {
 
 @ASTNode("", "DummyNamedNode")
 class DummyNamedNode extends Node implements PossiblyNamed {
-    constructor(public name?: string) {
+    @Attribute()
+    public name?: string;
+
+    constructor(name?: string) {
         super();
+        this.name = name;
     }
 }
 
 @ASTNode("", "NodeWithReference")
 class NodeWithReference extends Node implements PossiblyNamed {
-    constructor(public name?: string, public reference?: ReferenceByName<DummyNamedNode>) {
+    @Attribute()
+    public name?: string;
+    @Reference()
+    public reference?: ReferenceByName<DummyNamedNode>;
+
+    constructor(name?: string, reference?: ReferenceByName<DummyNamedNode>) {
         super();
+        this.name = name;
+        this.reference = reference;
     }
 
     @Child() namedNode?: DummyNamedNode;
 }
 
 @ASTNode("", "NodeWithSelfReference")
 class NodeWithSelfReference extends Node implements PossiblyNamed {
-    @Reference() public reference?: ReferenceByName<NodeWithSelfReference>;
+    @Attribute()
+    public name?: string;
+    @Reference()
+    public reference?: ReferenceByName<NodeWithSelfReference>;
 
-    constructor(public name?: string, reference?: ReferenceByName<NodeWithSelfReference>) {
+    constructor(name?: string, reference?: ReferenceByName<NodeWithSelfReference>) {
         super();
+        this.name = name;
         this.reference = reference;
     }
 }