@lionweb/validation 0.5.0-beta.8

package/src/json/std-builtins-copy.json

@@ -0,0 +1,369 @@
+{
+  "serializationFormatVersion": "2023.1",
+  "languages": [
+    {
+      "key": "LionCore-M3",
+      "version": "1"
+    }
+  ],
+  "nodes": [
+    {
+      "id": "LionCore-builtins",
+      "classifier": {
+        "language": "LionCore-M3",
+        "version": "1",
+        "key": "Language"
+      },
+      "properties": [
+        {
+          "property": {
+            "language": "LionCore-builtins",
+            "version": "1",
+            "key": "LionCore-builtins-INamed-name"
+          },
+          "value": "LionCore.builtins"
+        },
+        {
+          "property": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "Language-version"
+          },
+          "value": "1"
+        },
+        {
+          "property": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "IKeyed-key"
+          },
+          "value": "LionCore-builtins"
+        }
+      ],
+      "children": [
+        {
+          "containment": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "Language-entities"
+          },
+          "children": [
+            "LionCore-builtins-String",
+            "LionCore-builtins-Boolean",
+            "LionCore-builtins-Integer",
+            "LionCore-builtins-JSON",
+            "LionCore-builtins-Node",
+            "LionCore-builtins-INamed"
+          ]
+        }
+      ],
+      "references": [
+        {
+          "reference": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "Language-dependsOn"
+          },
+          "targets": []
+        }
+      ],
+      "annotations": [],
+      "parent": null
+    },
+    {
+      "id": "LionCore-builtins-String",
+      "classifier": {
+        "language": "LionCore-M3",
+        "version": "1",
+        "key": "PrimitiveType"
+      },
+      "properties": [
+        {
+          "property": {
+            "language": "LionCore-builtins",
+            "version": "1",
+            "key": "LionCore-builtins-INamed-name"
+          },
+          "value": "String"
+        },
+        {
+          "property": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "IKeyed-key"
+          },
+          "value": "LionCore-builtins-String"
+        }
+      ],
+      "children": [],
+      "references": [],
+      "annotations": [],
+      "parent": "LionCore-builtins"
+    },
+    {
+      "id": "LionCore-builtins-Boolean",
+      "classifier": {
+        "language": "LionCore-M3",
+        "version": "1",
+        "key": "PrimitiveType"
+      },
+      "properties": [
+        {
+          "property": {
+            "language": "LionCore-builtins",
+            "version": "1",
+            "key": "LionCore-builtins-INamed-name"
+          },
+          "value": "Boolean"
+        },
+        {
+          "property": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "IKeyed-key"
+          },
+          "value": "LionCore-builtins-Boolean"
+        }
+      ],
+      "children": [],
+      "references": [],
+      "annotations": [],
+      "parent": "LionCore-builtins"
+    },
+    {
+      "id": "LionCore-builtins-Integer",
+      "classifier": {
+        "language": "LionCore-M3",
+        "version": "1",
+        "key": "PrimitiveType"
+      },
+      "properties": [
+        {
+          "property": {
+            "language": "LionCore-builtins",
+            "version": "1",
+            "key": "LionCore-builtins-INamed-name"
+          },
+          "value": "Integer"
+        },
+        {
+          "property": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "IKeyed-key"
+          },
+          "value": "LionCore-builtins-Integer"
+        }
+      ],
+      "children": [],
+      "references": [],
+      "annotations": [],
+      "parent": "LionCore-builtins"
+    },
+    {
+      "id": "LionCore-builtins-JSON",
+      "classifier": {
+        "language": "LionCore-M3",
+        "version": "1",
+        "key": "PrimitiveType"
+      },
+      "properties": [
+        {
+          "property": {
+            "language": "LionCore-builtins",
+            "version": "1",
+            "key": "LionCore-builtins-INamed-name"
+          },
+          "value": "JSON"
+        },
+        {
+          "property": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "IKeyed-key"
+          },
+          "value": "LionCore-builtins-JSON"
+        }
+      ],
+      "children": [],
+      "references": [],
+      "annotations": [],
+      "parent": "LionCore-builtins"
+    },
+    {
+      "id": "LionCore-builtins-Node",
+      "classifier": {
+        "language": "LionCore-M3",
+        "version": "1",
+        "key": "Concept"
+      },
+      "properties": [
+        {
+          "property": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "Concept-abstract"
+          },
+          "value": "true"
+        },
+        {
+          "property": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "Concept-partition"
+          },
+          "value": "false"
+        },
+        {
+          "property": {
+            "language": "LionCore-builtins",
+            "version": "1",
+            "key": "LionCore-builtins-INamed-name"
+          },
+          "value": "Node"
+        },
+        {
+          "property": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "IKeyed-key"
+          },
+          "value": "LionCore-builtins-Node"
+        }
+      ],
+      "children": [
+        {
+          "containment": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "Classifier-features"
+          },
+          "children": []
+        }
+      ],
+      "references": [
+        {
+          "reference": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "Concept-extends"
+          },
+          "targets": []
+        },
+        {
+          "reference": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "Concept-implements"
+          },
+          "targets": []
+        }
+      ],
+      "annotations": [],
+      "parent": "LionCore-builtins"
+    },
+    {
+      "id": "LionCore-builtins-INamed",
+      "classifier": {
+        "language": "LionCore-M3",
+        "version": "1",
+        "key": "ConceptInterface"
+      },
+      "properties": [
+        {
+          "property": {
+            "language": "LionCore-builtins",
+            "version": "1",
+            "key": "LionCore-builtins-INamed-name"
+          },
+          "value": "INamed"
+        },
+        {
+          "property": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "IKeyed-key"
+          },
+          "value": "LionCore-builtins-INamed"
+        }
+      ],
+      "children": [
+        {
+          "containment": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "Classifier-features"
+          },
+          "children": [
+            "LionCore-builtins-INamed-name"
+          ]
+        }
+      ],
+      "references": [
+        {
+          "reference": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "ConceptInterface-extends"
+          },
+          "targets": []
+        }
+      ],
+      "annotations": [],
+      "parent": "LionCore-builtins"
+    },
+    {
+      "id": "LionCore-builtins-INamed-name",
+      "classifier": {
+        "language": "LionCore-M3",
+        "version": "1",
+        "key": "Property"
+      },
+      "properties": [
+        {
+          "property": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "Feature-optional"
+          },
+          "value": "false"
+        },
+        {
+          "property": {
+            "language": "LionCore-builtins",
+            "version": "1",
+            "key": "LionCore-builtins-INamed-name"
+          },
+          "value": "name"
+        },
+        {
+          "property": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "IKeyed-key"
+          },
+          "value": "LionCore-builtins-INamed-name"
+        }
+      ],
+      "children": [],
+      "references": [
+        {
+          "reference": {
+            "language": "LionCore-M3",
+            "version": "1",
+            "key": "Property-type"
+          },
+          "targets": [
+            {
+              "resolveInfo": "String",
+              "reference": "LionCore-builtins-String"
+            }
+          ]
+        }
+      ],
+      "annotations": [],
+      "parent": "LionCore-builtins-INamed"
+    }
+  ],
+  "annotations": []
+}

package/src/runners/RunCheckFolder.ts

@@ -0,0 +1,36 @@
+import fs from "fs";
+import { LionWebValidator } from "../validators/LionWebValidator";
+import { getAllFiles, printIssues } from "./Utils";
+
+const folder = process.argv[2];
+let totalErrors = 0;
+let totalSucceed = 0;
+let totalFailed = 0;
+
+
+for (const f of getAllFiles(folder, [])) {
+    const jsonString1 = fs.readFileSync(f, "utf-8");
+    const json1 = JSON.parse(jsonString1);
+    const validator = new LionWebValidator(json1, null)
+
+    try {
+        validator.validateAll();
+
+        if (!validator.validationResult.hasErrors()) {
+            totalSucceed += 1;
+            console.log("V PASSED " + f) ;
+            printIssues(validator.validationResult, f)
+        } else {
+            printIssues(validator.validationResult, f)
+            totalFailed += 1;
+            totalErrors += validator.validationResult.issues.length;
+        }
+    } catch(e: unknown) {
+        console.log("EXCEPTION in file: " + f);
+        console.log("EXCEPTION " + (e as Error)?.stack);
+    }
+}
+
+console.log("Total without errors: " + totalSucceed);
+console.log("Total with errors: " + totalFailed);
+console.log("Total number of errors: " + totalErrors);

package/src/runners/RunCheckFolderWithLanguage.ts

@@ -0,0 +1,44 @@
+import fs from "fs";
+import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper";
+import { LionWebLanguageDefinition} from "../json/LionWebLanguageDefinition";
+import { LionWebValidator } from "../validators/LionWebValidator";
+import { getAllFiles, printIssues } from "./Utils";
+
+const folder = process.argv[2];
+const language = process.argv[3];
+
+let totalSucceed = 0;
+let totalFailed = 0;
+
+
+const languageString = fs.readFileSync(language, "utf-8");
+const languageJson = JSON.parse(languageString);
+const languageValidator = new LionWebValidator(languageJson, null);
+
+languageValidator.validateSyntax();
+languageValidator.validateReferences();
+if (languageValidator.validationResult.hasErrors()) {
+    console.log("===== Language errors, ignoring folder ======");
+    printIssues(languageValidator.validationResult);
+    process.exit(1);
+}
+
+for (const modelFile of getAllFiles(folder, [])) {
+    const jsonString1 = fs.readFileSync(modelFile, "utf-8");
+    const jsonModel = JSON.parse(jsonString1);
+    const modelValidator = new LionWebValidator(jsonModel, new LionWebLanguageDefinition(languageValidator.chunk as LionWebJsonChunkWrapper));
+
+    modelValidator.validateAll();
+    if (modelValidator.validationResult.hasErrors()) {
+        totalFailed++;
+        // console.log("FAILED: " + modelFile)
+        printIssues(modelValidator.validationResult, modelFile);
+    } else {
+        console.log("SUCCEEDED: " + modelFile);
+        totalSucceed++;
+    }
+}
+
+console.log("Total without errors: " + totalSucceed);
+console.log("Total with errors: " + totalFailed);
+

package/src/runners/RunCheckOneFile.ts

@@ -0,0 +1,16 @@
+import fs from "fs";
+import { LionWebValidator } from "../validators/LionWebValidator";
+import { printIssues } from "./Utils";
+
+const file1 = process.argv[2];
+
+if (file1 !== null) {
+    const jsonString1 = fs.readFileSync(file1, "utf-8");
+    const json1 = JSON.parse(jsonString1);
+    const validator = new LionWebValidator(json1, null);
+
+    validator.validateSyntax();
+    validator.validateReferences();
+    validator.validateForLanguage();
+    printIssues(validator.validationResult);
+}

package/src/runners/RunCheckOneFileWithLanguage.ts

@@ -0,0 +1,28 @@
+import fs from "fs";
+import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper";
+import { LionWebLanguageDefinition} from "../json/LionWebLanguageDefinition";
+import { LionWebValidator } from "../validators/LionWebValidator";
+import { printIssues } from "./Utils";
+
+
+const modelFile = process.argv[2];
+const language = process.argv[3];
+
+if (modelFile !== null) {
+    const jsonString1 = fs.readFileSync(modelFile, "utf-8");
+    const jsonModel = JSON.parse(jsonString1);
+    const languageString = fs.readFileSync(language, "utf-8");
+    const languageJson = JSON.parse(languageString);
+
+    const languageValidator = new LionWebValidator(languageJson, null);
+
+    languageValidator.validateSyntax();
+    languageValidator.validateReferences();
+    console.log("===== Language errors ======")
+    printIssues(languageValidator.validationResult);
+
+    const modelValidator = new LionWebValidator(jsonModel, new LionWebLanguageDefinition(languageValidator.chunk as LionWebJsonChunkWrapper));
+    modelValidator.validateAll();
+    console.log("===== Model errors ======")
+    printIssues(modelValidator.validationResult);
+}

package/src/runners/RunLioncoreDiff.ts

@@ -0,0 +1,23 @@
+import fs from "fs";
+import { LwDiff } from "../diff/LionwebDiff";
+import { LionWebJsonChunk } from "../json/LionWebJson";
+
+const file1 = process.argv[2];
+const file2 = process.argv[3];
+
+if (file1 !== null && file1 !== undefined) {
+    const jsonString1 = fs.readFileSync(file1, "utf-8");
+    const json1 = JSON.parse(jsonString1);
+    const jsonString2 = fs.readFileSync(file2, "utf-8");
+    const json2 = JSON.parse(jsonString2);
+
+    const lwDiff = new LwDiff();
+    lwDiff.diffLwChunk(json1 as LionWebJsonChunk, json2 as LionWebJsonChunk);
+    if (lwDiff.errors.length === 0) {
+        console.log("LwDiff: equal");
+    } else {
+        console.log("LwDiff: " + lwDiff.errors);
+    }
+} else {
+    console.log("Error in arguments");
+}

package/src/runners/Utils.ts

@@ -0,0 +1,21 @@
+import fs from "fs";
+import path from "path";
+import { ValidationResult } from "../validators/ValidationResult";
+
+export function getAllFiles(dirPath: string, arrayOfFiles: string[]) {
+    const files = fs.readdirSync(dirPath);
+    arrayOfFiles = arrayOfFiles || [];
+
+    files.forEach(function (file: string) {
+        if (fs.statSync(dirPath + "/" + file).isDirectory()) {
+            arrayOfFiles = getAllFiles(dirPath + "/" + file, arrayOfFiles);
+        } else {
+            arrayOfFiles.push(path.join(dirPath, "/", file));
+        }
+    });
+    return arrayOfFiles;
+}
+
+export function printIssues(result: ValidationResult, file?: string): void {
+    result.issues.forEach(issue => console.log((file == undefined ? "" : `File ${file}: `) + issue.errorMsg()));
+}

package/src/validators/LionWebLanguageReferenceValidator.ts

@@ -0,0 +1,135 @@
+import {
+    Language_IncorrectContainmentMetaPointer_Issue,
+    Language_IncorrectPropertyMetaPointer_Issue, Language_IncorrectReferenceMetaPointer_Issue,
+    Language_UnknownConcept_Issue,
+    Language_UnknownContainment_Issue,
+    Language_UnknownProperty_Issue,
+    Language_UnknownReference_Issue
+} from "../issues/LanguageIssues";
+import { JsonContext } from "../issues/ValidationIssue";
+import {
+    LION_CORE_BUILTINS_INAMED_NAME,
+    LIONWEB_BOOLEAN_TYPE,
+    LIONWEB_INTEGER_TYPE,
+    LIONWEB_JSON_TYPE,
+    LIONWEB_STRING_TYPE, LionWebJsonChild,
+    LionWebJsonProperty, LionWebJsonReference
+} from "../json/LionWebJson";
+import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper";
+import { LIONWEB_M3_CONCEPT_KEY, LIONWEB_M3_PROPERTY_KEY, LIONWEB_M3_PROPERTY_TYPE_KEY, LionWebLanguageDefinition } from "../json/LionWebLanguageDefinition";
+import { SimpleFieldValidator } from "./SimpleFieldValidator";
+import { ValidationResult } from "./ValidationResult";
+
+/**
+ * Check against the language definition
+ */
+export class LionWebLanguageReferenceValidator {
+    validationResult: ValidationResult;
+    language: LionWebLanguageDefinition;
+    simpleFieldValidator: SimpleFieldValidator;
+
+    constructor(validationResult: ValidationResult, lang: LionWebLanguageDefinition) {
+        this.validationResult = validationResult;
+        this.language = lang;
+        this.simpleFieldValidator = new SimpleFieldValidator(this.validationResult);
+    }
+
+    // reset() {
+    //     this.validationResult.reset();
+    // }
+
+    // TODO test reference and children implementation
+    validate(obj: LionWebJsonChunkWrapper): void {
+        if (this.language === undefined || this.language === null) {
+            return;
+        }
+        obj.jsonChunk.nodes.forEach((node, nodeIndex) => {
+            const nodeContext = new JsonContext(null, ["node", nodeIndex]);
+            const jsonConcept = this.language.getNodeByMetaPointer(node.classifier);
+            if (jsonConcept === null || jsonConcept === undefined) {
+                this.validationResult.issue(new Language_UnknownConcept_Issue(nodeContext, node.classifier));
+                return;
+            }
+            node.properties.forEach((property, propIndex) => {
+                this.validateProperty(property, nodeContext.concat("properties", propIndex));
+            });
+            node.containments.forEach((containment, childIndex) => {
+                this.validateContainment(containment, nodeContext.concat("containments", childIndex));
+            });
+            node.references.forEach((reference, refIndex) => {
+                this.validateReference(reference, nodeContext.concat("references", refIndex));
+            });
+        });
+    }
+
+    private validateContainment(child: LionWebJsonChild, context: JsonContext) {
+        const type = this.language.getNodeByMetaPointer(child.containment);
+        if (type === null || type === undefined) {
+            this.validationResult.issue(new Language_UnknownContainment_Issue(context, child.containment));
+            return;
+        }
+        if (type.classifier.key !== LIONWEB_M3_CONCEPT_KEY) {
+            this.validationResult.issue(new Language_IncorrectContainmentMetaPointer_Issue(context, child.containment, type.classifier.key));
+        }
+        // TODO check type of children
+    }
+
+    private validateReference(ref: LionWebJsonReference, context: JsonContext) {
+        const type = this.language.getNodeByMetaPointer(ref.reference);
+        if (type === null || type === undefined) {
+            this.validationResult.issue(new Language_UnknownReference_Issue(context, ref.reference));
+            return;
+        }
+        if (type.classifier.key !== LIONWEB_M3_CONCEPT_KEY) {
+            this.validationResult.issue(new Language_IncorrectReferenceMetaPointer_Issue(context, ref.reference, type.classifier.key));
+        }
+        // TODO Check type of reference (if possible)
+
+        // TODO Check for duplicate targets?
+        // If so, what to check because there can be either or both a `resolveInfo` and a `reference`
+    }
+    
+    /**
+     * Checks wwhether the value of `prop1` is correct in relation with its property definition in the referred language.
+     * @param prop
+     */
+    validateProperty(prop: LionWebJsonProperty, context: JsonContext): void {
+        if (prop.value === null) {
+            return;
+        }
+        const type = this.language.getNodeByMetaPointer(prop.property);
+        if (type === null || type === undefined) {
+            this.validationResult.issue(new Language_UnknownProperty_Issue(context, prop.property));
+            return;
+        }
+        if (type.classifier.key !== LIONWEB_M3_PROPERTY_KEY) {
+            this.validationResult.issue(new Language_IncorrectPropertyMetaPointer_Issue(context, prop.property, type.classifier.key));
+            return;
+        }
+        // TODO check for property to exist inside the concept in the language
+        //      Need to find inherited and implemented properties as well: complex!
+
+        const refType = type.references.find((ref) => (ref.reference.key === LIONWEB_M3_PROPERTY_TYPE_KEY));
+        const propertyName = type.properties.find(p => p.property.key === LION_CORE_BUILTINS_INAMED_NAME)?.value;
+        // console.log("Fount type should be " + refType.targets[0].reference);
+        if (propertyName !== undefined) {
+            if (refType !== null && refType !== undefined) {
+                switch (refType.targets[0].reference) {
+                    case LIONWEB_BOOLEAN_TYPE:
+                        this.simpleFieldValidator.validateBoolean(prop, propertyName, context);
+                        break;
+                    case LIONWEB_INTEGER_TYPE:
+                        this.simpleFieldValidator.validateInteger(prop, propertyName, context);
+                        break;
+                    case LIONWEB_STRING_TYPE:
+                        break;
+                    case LIONWEB_JSON_TYPE:
+                        this.simpleFieldValidator.validateJSON(prop, propertyName, context);
+                        break;
+                }
+            } else {
+                // TODO refType not found, but 
+            }
+        }
+    }
+}