@lionweb/validation 0.5.0 → 0.6.0-beta.2

package/src/validators/LionWebLanguageValidator.ts

@@ -1,14 +1,14 @@
-import { IncorrectLionCoreVersion_Issue, NotLionCoreLanguageKey_Issue, NumberOfLanguagesUsed_Issue } from "../issues/LanguageIssues.js";
-import { JsonContext } from "./../issues/JsonContext.js";
-import { LionWebJsonChunk } from "../json/LionWebJson.js";
-import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js";
-import { ValidationResult } from "./ValidationResult.js";
+import { IncorrectLionCoreVersion_Issue, NotLionCoreLanguageKey_Issue, NumberOfLanguagesUsed_Issue } from "../issues/LanguageIssues.js"
+import { JsonContext } from "../json/JsonContext.js"
+import { LionWebJsonChunk } from "../json/LionWebJson.js"
+import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
+import { ValidationResult } from "./ValidationResult.js"
 
 export class LionWebLanguageValidator {
-    validationResult: ValidationResult;
+    validationResult: ValidationResult
 
     constructor() {
-        this.validationResult = new ValidationResult();
+        this.validationResult = new ValidationResult()
     }
 
     /**
@@ -22,19 +22,18 @@ export class LionWebLanguageValidator {
             this.validationResult.issue(new NumberOfLanguagesUsed_Issue(new JsonContext(null, ["languages"]), chunk.languages.length))
             return
         }
-        const usedLanguage = chunk.languages[0];
+        const usedLanguage = chunk.languages[0]
         if (usedLanguage.key !== "LionCore-M3") {
             this.validationResult.issue(new NotLionCoreLanguageKey_Issue(new JsonContext(null, ["languages", 0]), usedLanguage.key))
         }
         if (usedLanguage.version !== "1") {
             this.validationResult.issue(new IncorrectLionCoreVersion_Issue(new JsonContext(null, ["languages", 0]), usedLanguage.version))
         }
-        const chunkWrapper = new LionWebJsonChunkWrapper(chunk);
-        const languageNodes = chunkWrapper.findNodesOfConcept("Language");
+        const chunkWrapper = new LionWebJsonChunkWrapper(chunk)
+        const languageNodes = chunkWrapper.findNodesOfConcept("Language")
         if (languageNodes.length !== 1) {
             // TODO Better error handling.
-            console.error("Expected exactly one Language node, found " + languageNodes.length + " => " + JSON.stringify(languageNodes));
-
+            console.error("Expected exactly one Language node, found " + languageNodes.length + " => " + JSON.stringify(languageNodes))
         }
     }
 }

package/src/validators/LionWebReferenceValidator.ts

@@ -2,63 +2,71 @@ import {
     Duplicates_Issue,
     Reference_ChildMissingInParent_Issue,
     Reference_CirculairParent_Issue,
-    Reference_DuplicateNodeId_Issue, Reference_LanguageUnknown_Issue,
-    Reference_ParentMissingInChild_Issue
-} from "../issues/ReferenceIssues.js";
-import { JsonContext } from "./../issues/JsonContext.js";
-import { ChunkUtils } from "../json/ChunkUtils.js";
-import { LION_CORE_BUILTINS_KEY, LionWebJsonChild, LionWebJsonChunk, LionWebJsonMetaPointer, LionWebJsonNode, LwJsonUsedLanguage } from "../json/LionWebJson.js";
-import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js";
-import { SimpleFieldValidator } from "./SimpleFieldValidator.js";
-import { ValidationResult } from "./ValidationResult.js";
+    Reference_DuplicateNodeId_Issue,
+    Reference_LanguageUnknown_Issue,
+    Reference_ParentMissingInChild_Issue,
+} from "../issues/ReferenceIssues.js"
+import { JsonContext } from "../json/JsonContext.js"
+import { ChunkUtils } from "../json/ChunkUtils.js"
+import {
+    LION_CORE_BUILTINS_KEY,
+    LionWebJsonContainment,
+    LionWebJsonChunk,
+    LionWebJsonMetaPointer,
+    LionWebJsonNode,
+    LwJsonUsedLanguage,
+} from "../json/LionWebJson.js"
+import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
+import { SimpleFieldValidator } from "./SimpleFieldValidator.js"
+import { ValidationResult } from "./ValidationResult.js"
 
 /**
  * Assuming that the syntax is correct, check whether all LionWeb references are correct,
  * as far as they do not need the used language definition.
  */
 export class LionWebReferenceValidator {
-    validationResult: ValidationResult;
-    nodesIdMap: Map<string, LionWebJsonNode> = new Map<string, LionWebJsonNode>();
-    simpleFieldValidator: SimpleFieldValidator;
+    validationResult: ValidationResult
+    nodesIdMap: Map<string, LionWebJsonNode> = new Map<string, LionWebJsonNode>()
+    simpleFieldValidator: SimpleFieldValidator
 
     constructor(validationResult: ValidationResult) {
-        this.validationResult = validationResult;
-        this.simpleFieldValidator = new SimpleFieldValidator(this.validationResult);
+        this.validationResult = validationResult
+        this.simpleFieldValidator = new SimpleFieldValidator(this.validationResult)
     }
 
     validateNodeIds(obj: LionWebJsonChunk, ctx: JsonContext): void {
         // put all nodes in a map, validate that there are no two nodes with the same id.
         obj.nodes.forEach((node, index) => {
             // this.validationResult.check(this.nodesIdMap.get(node.id) === undefined, `Node number ${index} has duplicate id "${node.id}"`);
-            if (! (this.nodesIdMap.get(node.id) === undefined)) {
-                this.validationResult.issue(new Reference_DuplicateNodeId_Issue(ctx.concat("nodes", index), node.id));
+            if (!(this.nodesIdMap.get(node.id) === undefined)) {
+                this.validationResult.issue(new Reference_DuplicateNodeId_Issue(ctx.concat("nodes", index), node.id))
             }
-            this.nodesIdMap.set(node.id, node);
-        });
+            this.nodesIdMap.set(node.id, node)
+        })
     }
 
     validate(obj: LionWebJsonChunkWrapper): void {
-        const rootCtx =  new JsonContext(null, ["$"]);
-        this.checkDuplicateUsedLanguage(obj.jsonChunk.languages, rootCtx);
-        this.validateNodeIds(obj.jsonChunk, rootCtx);
+        const rootCtx = new JsonContext(null, ["$"])
+        this.checkDuplicateUsedLanguage(obj.jsonChunk.languages, rootCtx)
+        this.validateNodeIds(obj.jsonChunk, rootCtx)
         obj.jsonChunk.nodes.forEach((node, nodeIndex) => {
-            const context = rootCtx.concat(`node`, nodeIndex);
-            const parentNode = node.parent;
+            const context = rootCtx.concat(`node`, nodeIndex)
+            const parentNode = node.parent
             if (parentNode !== null) {
-                this.validateExistsAsChild(context, this.nodesIdMap.get(parentNode), node);
+                this.validateExistsAsChild(context, this.nodesIdMap.get(parentNode), node)
             }
-            this.validateLanguageReference(obj, node.classifier, context);
-            this.checkParentCircular(node, context);
-            this.checkDuplicate(node.annotations, rootCtx.concat("node", nodeIndex, "annotations"));
-            this.validateChildrenHaveCorrectParent(node, rootCtx.concat("node", nodeIndex));
+            this.validateLanguageReference(obj, node.classifier, context)
+            this.checkParentCircular(node, context)
+            this.checkDuplicate(node.annotations, rootCtx.concat("node", nodeIndex, "annotations"))
+            this.validateChildrenHaveCorrectParent(node, rootCtx.concat("node", nodeIndex))
             node.properties.forEach((prop, propertyIndex) => {
-                this.validateLanguageReference(obj, prop.property, rootCtx.concat("node", nodeIndex, "property", propertyIndex));
-            });
+                this.validateLanguageReference(obj, prop.property, rootCtx.concat("node", nodeIndex, "property", propertyIndex))
+            })
             node.containments.forEach((containment, childIndex) => {
-                this.validateLanguageReference(obj, containment.containment, rootCtx.concat("node", nodeIndex, "containments", childIndex));
-                this.checkDuplicate(containment.children, rootCtx.concat("node", nodeIndex, "containments", childIndex));
-                containment.children.forEach((childId) => {
-                    const childNode = this.nodesIdMap.get(childId);
+                this.validateLanguageReference(obj, containment.containment, rootCtx.concat("node", nodeIndex, "containments", childIndex))
+                this.checkDuplicate(containment.children, rootCtx.concat("node", nodeIndex, "containments", childIndex))
+                containment.children.forEach(childId => {
+                    const childNode = this.nodesIdMap.get(childId)
                     if (childNode !== undefined) {
                         if (childNode.parent !== null && childNode.parent !== undefined && childNode.parent !== node.id) {
                             this.validationResult.issue(new Reference_ChildMissingInParent_Issue(context, childNode, node))
@@ -68,10 +76,10 @@ export class LionWebReferenceValidator {
                             // TODO this.validationResult.error(`Child "${childId}" of node "${node.id}" has different parent "${childNode.parent}"`);
                         }
                     }
-                });
-            });
-            node.annotations.forEach((annotationId) => {
-                const annotation = this.nodesIdMap.get(annotationId);
+                })
+            })
+            node.annotations.forEach(annotationId => {
+                const annotation = this.nodesIdMap.get(annotationId)
                 if (annotation !== undefined) {
                     if (annotation.parent !== null && annotation.parent !== undefined && annotation.parent !== node.id) {
                         this.validationResult.issue(new Reference_ChildMissingInParent_Issue(context, annotation, node))
@@ -81,13 +89,13 @@ export class LionWebReferenceValidator {
                         // TODO this.validationResult.error(`Child "${annotationId}" of node "${node.id}" has different parent "${childNode.parent}"`);
                     }
                 }
-            });
+            })
             node.references.forEach((ref, refIndex) => {
-                this.validateLanguageReference(obj, ref.reference, rootCtx.concat("node", nodeIndex, "references", refIndex));
+                this.validateLanguageReference(obj, ref.reference, rootCtx.concat("node", nodeIndex, "references", refIndex))
                 // TODO Check for duplicate targets?
                 // If so, what to check because there can be either or both a `resolveInfo` and a `reference`
-            });
-        });
+            })
+        })
     }
 
     /**
@@ -97,10 +105,10 @@ export class LionWebReferenceValidator {
      * @param context
      */
     validateLanguageReference(chunk: LionWebJsonChunkWrapper, metaPointer: LionWebJsonMetaPointer, context: JsonContext) {
-        const lang = ChunkUtils.findLwUsedLanguageWithVersion(chunk.jsonChunk, metaPointer.language, metaPointer.version);
+        const lang = ChunkUtils.findLwUsedLanguageWithVersion(chunk.jsonChunk, metaPointer.language, metaPointer.version)
         if (metaPointer.language === LION_CORE_BUILTINS_KEY) {
             // Ok, builtin
-            return;
+            return
         }
         if (lang === undefined || lang === null) {
             this.validationResult.issue(new Reference_LanguageUnknown_Issue(context, metaPointer))
@@ -118,16 +126,16 @@ export class LionWebReferenceValidator {
      */
     checkDuplicate(strings: string[], context: JsonContext) {
         if (strings === null || strings === undefined) {
-            return;
+            return
         }
-        const alreadySeen: Record<string, boolean> = {};
-        strings.forEach((str) => {
+        const alreadySeen: Record<string, boolean> = {}
+        strings.forEach(str => {
             if (alreadySeen[str]) {
                 this.validationResult.issue(new Duplicates_Issue(context, str))
             } else {
-                alreadySeen[str] = true;
+                alreadySeen[str] = true
             }
-        });
+        })
     }
 
     /**
@@ -138,19 +146,19 @@ export class LionWebReferenceValidator {
      */
     checkDuplicateUsedLanguage(usedLanguages: LwJsonUsedLanguage[], context: JsonContext) {
         if (usedLanguages === null || usedLanguages === undefined) {
-            return;
+            return
         }
-        const alreadySeen = new Map<string, string[]>();
+        const alreadySeen = new Map<string, string[]>()
         usedLanguages.forEach((usedLanguage, index) => {
-            const seenKeys = alreadySeen.get(usedLanguage.key);
+            const seenKeys = alreadySeen.get(usedLanguage.key)
             if (seenKeys !== null && seenKeys !== undefined) {
                 if (seenKeys.includes(usedLanguage.version)) {
-                    this.validationResult.issue(new Duplicates_Issue(context.concat("language", index, "version"), usedLanguage.version));
+                    this.validationResult.issue(new Duplicates_Issue(context.concat("language", index, "version"), usedLanguage.version))
                 }
             } else {
-                alreadySeen.set(usedLanguage.key, [usedLanguage.version]);
+                alreadySeen.set(usedLanguage.key, [usedLanguage.version])
             }
-        });
+        })
     }
 
     /**
@@ -159,61 +167,67 @@ export class LionWebReferenceValidator {
      */
     checkParentCircular(node: LionWebJsonNode, context: JsonContext) {
         if (node === null || node === undefined) {
-            return;
+            return
         }
         if (node.parent === null || node.parent === undefined) {
-            return;
+            return
         }
-        let current: LionWebJsonNode | undefined = node;
-        const seenParents = [node.id];
+        let current: LionWebJsonNode | undefined = node
+        const seenParents = [node.id]
         while (current !== null && current !== undefined && current.parent !== null && current.parent !== undefined) {
-            const nextParent = current.parent;
+            const nextParent = current.parent
             if (nextParent !== null && nextParent !== undefined && seenParents.includes(nextParent)) {
-                this.validationResult.issue(new Reference_CirculairParent_Issue(context.concat("???"), this.nodesIdMap.get(nextParent), seenParents));
-                return;
+                this.validationResult.issue(
+                    new Reference_CirculairParent_Issue(context.concat("???"), this.nodesIdMap.get(nextParent), seenParents),
+                )
+                return
             }
-            seenParents.push(nextParent);
-            current = this.nodesIdMap.get(nextParent);
+            seenParents.push(nextParent)
+            current = this.nodesIdMap.get(nextParent)
         }
     }
 
     validateExistsAsChild(context: JsonContext, parent: LionWebJsonNode | undefined, child: LionWebJsonNode) {
         if (parent === undefined || parent === null) {
-            return;
+            return
         }
         for (const containment of parent.containments) {
             if (containment.children.includes(child.id)) {
-                return;
+                return
             }
         }
         if (parent.annotations.includes(child.id)) {
-            return;
+            return
         }
-        this.validationResult.issue(new Reference_ChildMissingInParent_Issue(context, child, parent));
+        this.validationResult.issue(new Reference_ChildMissingInParent_Issue(context, child, parent))
     }
 
     validateChildrenHaveCorrectParent(node: LionWebJsonNode, context: JsonContext) {
-        node.containments.forEach((child: LionWebJsonChild) => {
+        node.containments.forEach((child: LionWebJsonContainment) => {
             child.children.forEach((childId: string, index: number) => {
-                const childNode = this.nodesIdMap.get(childId);
+                const childNode = this.nodesIdMap.get(childId)
                 if (childNode !== undefined) {
                     if (childNode.parent !== node.id) {
                         // TODO Check that this is already tested from the child in vaidateExistsAsChild().
                     }
                     if (childNode.parent === null || childNode.parent === undefined) {
-                        this.validationResult.issue(new Reference_ParentMissingInChild_Issue(context.concat("child", "containment", "key", index), node, childNode));
+                        this.validationResult.issue(
+                            new Reference_ParentMissingInChild_Issue(context.concat("child", "containment", "key", index), node, childNode),
+                        )
                     }
                 }
-            });
-        });
+            })
+        })
         node.annotations.forEach((annotationId: string, annotationIndex: number) => {
-            const childNode = this.nodesIdMap.get(annotationId);
+            const childNode = this.nodesIdMap.get(annotationId)
             if (childNode !== undefined) {
                 if (childNode.parent === null || childNode.parent === undefined) {
-                    this.validationResult.issue(new Reference_ParentMissingInChild_Issue(context.concat("annotations", annotationIndex), node, childNode));
+                    this.validationResult.issue(
+                        new Reference_ParentMissingInChild_Issue(context.concat("annotations", annotationIndex), node, childNode),
+                    )
                 }
             }
-        });
+        })
         // for (const childId of NodeUtils.allChildren(node)) {
         //     const childNode = this.nodesIdMap.get(childId);
         //     if (childNode !== undefined) {