@lionweb/validation 0.7.0-beta.18 → 0.7.0-beta.19

package/src/runners/RunLioncoreDiff.ts

@@ -0,0 +1,23 @@
+import { LionWebJsonChunk } from "@lionweb/json"
+import { LionWebJsonDiff } from "@lionweb/json-diff"
+import fs from "fs"
+
+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 LionWebJsonDiff()
+    lwDiff.diffLwChunk(json1 as LionWebJsonChunk, json2 as LionWebJsonChunk)
+    if (lwDiff.diffResult.changes.length === 0) {
+        console.log("LionWebJsonDiff: equal")
+    } else {
+        console.log("LionWebJsonDiff: " + lwDiff.diff)
+    }
+} else {
+    console.log("Error in arguments")
+}

package/src/runners/Utils.ts

@@ -0,0 +1,54 @@
+import fs from "fs"
+import path from "path"
+import { ValidationResult } from "../validators/generic/ValidationResult.js"
+
+export function getFilesRecursive(dirPath: string, arrayOfFiles: string[]) {
+    const files = fs.readdirSync(dirPath)
+    arrayOfFiles = arrayOfFiles || []
+
+    files.forEach(function (file: string) {
+        if (fs.statSync(dirPath + "/" + file).isDirectory()) {
+            arrayOfFiles = getFilesRecursive(dirPath + "/" + file, arrayOfFiles)
+        } else {
+            arrayOfFiles.push(path.join(dirPath, "/", file))
+        }
+    })
+    return arrayOfFiles
+}
+
+export function getFilesDirect(dirPath: string, arrayOfFiles: string[]) {
+    const files = fs.readdirSync(dirPath)
+    arrayOfFiles = arrayOfFiles || []
+
+    files.forEach(function (file: string) {
+        if (fs.statSync(dirPath + "/" + file).isFile()) {
+            arrayOfFiles.push(file)
+        }
+    })
+    return arrayOfFiles
+}
+
+export function getAllDirectories(dirPath: string, arrayOfDirs: string[]) {
+    const files = fs.readdirSync(dirPath, { withFileTypes: true })
+    arrayOfDirs = arrayOfDirs || []
+
+    files.forEach(function (file: fs.Dirent) {
+        if (file.isDirectory()) {
+            arrayOfDirs = getAllDirectories(dirPath + "/" + file.name, arrayOfDirs)
+            arrayOfDirs.push(path.join(dirPath, "/", file.name))
+        } else {
+            // ignore files
+        }
+    })
+    return arrayOfDirs
+}
+
+export function printIssues(result: ValidationResult, file?: string): void {
+    result.issues.forEach(issue => console.log((file == undefined ? "" : `File ${file}: `) + issue.errorMsg()))
+}
+
+export function issuestoString(vresult: ValidationResult, file?: string): string {
+    let result = "ISSUES: "
+    vresult.issues.forEach(issue => (result += (file === undefined ? "NOFILE" : `File ${file}: `) + issue.errorMsg() + "\n"))
+    return result
+}

package/src/runners/index.ts

@@ -0,0 +1,2 @@
+export * from "./FileUtils.js"
+export * from "./Utils.js"

package/src/validators/LionWebChunkDefinitions.ts

@@ -0,0 +1,104 @@
+import { DefinitionSchema,  MAY_BE_NULL, PropertyDef, PrimitiveDef } from "./generic/index.js"
+import { validateId, validateKey, validateSerializationFormatVersion, validateVersion } from "./ValidationFunctions.js"
+
+/**
+ * The structure below defines the structure of a LionWeb Chunk by defining all the properties.
+ * It can
+ *   - be used by the SyntaxValidator to validate an object sat runtime.
+ *   - used to generate all the TypeScript types for a LionWebChunk.
+ */
+export const LionWebSchema: DefinitionSchema = new DefinitionSchema([
+    {
+        name: "LionWebJsonMetaPointer",
+        properties: [
+            PropertyDef({ name: "key", type: "LionWebKey" }),
+            PropertyDef({ name: "version", type: "LionWebVersion" }),
+            PropertyDef({ name: "language", type: "LionWebKey" })
+        ]
+    },
+    {
+        name: "LionWebJsonMetaPointer",
+        properties: [
+            PropertyDef({ name: "key", type: "LionWebKey" }),
+            PropertyDef({ name: "version", type: "LionWebVersion" }),
+            PropertyDef({ name: "language", type: "LionWebKey" }),
+        ]
+    },
+    {
+        name: "ResponseMessage",
+        properties: [
+            PropertyDef({ name: "kind", type: "JSstring" }),
+            PropertyDef({ name: "message", type: "JSstring" }),
+            PropertyDef({ name: "data", type: "JSobject", mayBeNull: true, isOptional: true })
+        ]
+    },
+    {
+        name: "LionWebJsonChunk",
+        properties: [
+            PropertyDef({ name: "serializationFormatVersion", type: "LionWebSerializationFormatVersion" }),
+            PropertyDef({ name: "languages", type: "LionWebJsonUsedLanguage", isList: true }),
+            PropertyDef({ name: "nodes", type: "LionWebJsonNode", isList: true })
+        ]
+    },
+    {
+        name: "LionWebJsonUsedLanguage",
+        properties: [
+            PropertyDef({ name: "key", type: "LionWebKey" }),
+            PropertyDef({ name: "version", type: "LionWebVersion" })
+        ]
+    },
+    {
+        name: "LionWebJsonNode",
+        properties: [
+            PropertyDef({ name: "id", type: "LionWebId" }),
+            PropertyDef({ name: "classifier", type: "LionWebJsonMetaPointer" }),
+            PropertyDef({ name: "properties", type: "LionWebJsonProperty", isList: true }),
+            PropertyDef({ name: "containments", type: "LionWebJsonContainment", isList: true }),
+            PropertyDef({ name: "references", type: "LionWebJsonReference", isList: true }),
+            PropertyDef({ name: "annotations", type: "LionWebId", isList: true }),
+            PropertyDef({ name: "parent", type: "LionWebId", mayBeNull: MAY_BE_NULL }),
+        ]
+    },
+    {
+        name: "LionWebJsonProperty",
+        properties: [
+            PropertyDef({ name: "property", type: "LionWebJsonMetaPointer" }),
+            PropertyDef({ name: "value", type: "JSstring", mayBeNull: MAY_BE_NULL }),
+        ]
+    },
+    {
+        name: "LionWebJsonContainment",
+        properties: [
+            PropertyDef({ name: "containment", type: "LionWebJsonMetaPointer" }),
+            PropertyDef({ name: "children", type: "LionWebId", isList: true }),
+        ]
+    },
+    {
+        name: "LionWebJsonReference",
+        properties: [
+            PropertyDef({ name: "reference", type: "LionWebJsonMetaPointer"}),
+            PropertyDef({ name: "targets", type: "LionWebJsonReferenceTarget", isList: true}),
+        ]
+    },
+    {
+        name: "LionWebJsonReferenceTarget",
+        properties: [
+            PropertyDef({ name: "resolveInfo", type: "JSstring", mayBeNull: MAY_BE_NULL }),
+            PropertyDef({ name: "reference", type: "LionWebId", mayBeNull: MAY_BE_NULL }),
+        ]
+    },
+    /**
+     * Elements without properties are assumed to be JSON/JS primitive values, and tested using `typeof`
+     * and the (optional) validate function.
+     */
+    PrimitiveDef({ name: "LionWebId", primitiveType: "string", validate: validateId }),
+    PrimitiveDef({ name: "LionWebKey", primitiveType: "string", validate: validateKey }),
+    PrimitiveDef({ name: "LionWebVersion",primitiveType: "string", validate: validateVersion }),
+    PrimitiveDef({ name: "LionWebSerializationFormatVersion",primitiveType: "string", validate: validateSerializationFormatVersion }),
+    PrimitiveDef({ name: "JSstring", primitiveType: "string" }),
+    PrimitiveDef({ name: "JSobject",primitiveType: "object" }),
+])
+
+
+
+

package/src/validators/LionWebLanguageReferenceValidator.ts

@@ -0,0 +1,201 @@
+import { isEqualMetaPointer, LionWebJsonContainment, LionWebJsonNode, LionWebJsonProperty, LionWebJsonReference } from "@lionweb/json"
+import {
+    JsonContext,
+    LION_CORE_BUILTINS_INAMED_NAME,
+    LIONWEB_BOOLEAN_TYPE, LIONWEB_INTEGER_TYPE, LIONWEB_JSON_TYPE, LIONWEB_STRING_TYPE,
+    LionWebJsonChunkWrapper,
+    M3_Keys,
+    MetaPointers,
+    NodeUtils
+} from "@lionweb/json-utils"
+import {
+    Language_ContainmentMetaPointerNotInClass_Issue,
+    Language_IncorrectPropertyMetaPointer_Issue,
+    Language_PropertyMetaPointerNotInClass_Issue,
+    Language_PropertyValue_Issue,
+    Language_ReferenceMetaPointerNotInClass_Issue,
+    Language_UnknownConcept_Issue
+} from "../issues/index.js"
+import {
+    Language_IncorrectContainmentMetaPointer_Issue,
+    Language_IncorrectReferenceMetaPointer_Issue,
+    Language_UnknownContainment_Issue,
+    Language_UnknownProperty_Issue,
+    Language_UnknownReference_Issue
+} from "../issues/LanguageIssues.js"
+// import {
+//     KnownLanguages, LanguageRegistry
+// } from "../languages/LanguageRegistry.js"
+import { LanguageRegistry } from "../languages/index.js"
+import { ValidationResult } from "./generic/ValidationResult.js"
+import { validateBoolean, validateInteger, validateJSON } from "./ValidationFunctions.js"
+
+
+/**
+ * Check against the language definition
+ */
+export class LionWebLanguageReferenceValidator {
+    validationResult: ValidationResult
+
+    constructor(validationResult: ValidationResult, private registry: LanguageRegistry) {
+        this.validationResult = validationResult
+    }
+
+    // reset() {
+    //     this.validationResult.reset();
+    // }
+
+    // TODO test reference and children implementation
+    validate(obj: LionWebJsonChunkWrapper): void {
+        obj.jsonChunk.nodes.forEach((node, nodeIndex) => {
+            const nodeContext = new JsonContext(null, ["node", nodeIndex])
+            const nodeConcept = this.registry.getNodeByMetaPointer(node.classifier)
+            if (nodeConcept === undefined && nodeContext !== undefined) {
+                this.validationResult.issue(new Language_UnknownConcept_Issue(nodeContext, node.classifier))
+                return
+            }
+            node.properties.forEach((property, propIndex) => {
+                this.validateProperty(node, nodeConcept, property, nodeContext.concat("properties", propIndex))
+            })
+            node.containments.forEach((containment, childIndex) => {
+                this.validateContainment(node, nodeConcept, containment, nodeContext.concat("containments", childIndex))
+            })
+            node.references.forEach((reference, refIndex) => {
+                this.validateReference(node, nodeConcept, reference, nodeContext.concat("references", refIndex))
+            })
+        })
+    }
+
+    private validateContainment(_node: LionWebJsonNode, nodeConcept: LionWebJsonNode | undefined, containment: LionWebJsonContainment, context: JsonContext) {
+        const metaConcept = this.registry.getNodeByMetaPointer(containment.containment)
+        if (metaConcept === null || metaConcept === undefined) {
+            this.validationResult.issue(new Language_UnknownContainment_Issue(context, containment.containment))
+            return
+        }
+        if (metaConcept.classifier.key !== M3_Keys.Containment) {
+            this.validationResult.issue(new Language_IncorrectContainmentMetaPointer_Issue(context, containment.containment, metaConcept.classifier.key))
+        }
+        if (nodeConcept !== undefined) {
+            const cons = this.registry.languages.allContainments(nodeConcept)
+            if (!cons.includes(metaConcept)) {
+                this.validationResult.issue(new Language_ContainmentMetaPointerNotInClass_Issue(context, containment.containment, nodeConcept))
+                return
+            }
+        }
+        // TODO check type of children
+    }
+
+    private validateReference(_node: LionWebJsonNode, nodeConcept: LionWebJsonNode | undefined, ref: LionWebJsonReference, context: JsonContext) {
+        const referenceDefinition = this.registry.getNodeByMetaPointer(ref.reference)
+        if (referenceDefinition === null || referenceDefinition === undefined) {
+            this.validationResult.issue(new Language_UnknownReference_Issue(context, ref.reference))
+            return
+        }
+        if (referenceDefinition.classifier.key !== M3_Keys.Reference) {
+            this.validationResult.issue(new Language_IncorrectReferenceMetaPointer_Issue(context, ref.reference, referenceDefinition.classifier.key))
+        }
+        if (nodeConcept !== undefined) {
+            const refs = this.registry.languages.allReferenceDefinitions(nodeConcept)
+            if (!refs.includes(referenceDefinition)) {
+                this.validationResult.issue(new Language_ReferenceMetaPointerNotInClass_Issue(context, ref.reference, nodeConcept))
+                return
+            }
+        }
+
+        // TODO Check type of reference (if possible)
+
+        // TODO Check for duplicate targets?
+        // No, already done without language check
+        // 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(_node: LionWebJsonNode, nodeConcept: LionWebJsonNode | undefined, prop: LionWebJsonProperty, context: JsonContext): void {
+        if (prop.value === null) {
+            return
+        }
+        const propertyDefinition = this.registry.getNodeByMetaPointer(prop.property)
+        if ( propertyDefinition === undefined) {
+            this.validationResult.issue(new Language_UnknownProperty_Issue(context, prop.property))
+            return
+        }
+        if (propertyDefinition.classifier.key !== M3_Keys.Property) {
+            this.validationResult.issue(new Language_IncorrectPropertyMetaPointer_Issue(context, prop.property, propertyDefinition.classifier.key))
+            return
+        }
+        if (nodeConcept !== undefined) {
+            const props = this.registry.languages.allProperties(nodeConcept)
+            if (!props.includes(propertyDefinition)) {
+                this.validationResult.issue(new Language_PropertyMetaPointerNotInClass_Issue(context, prop.property, nodeConcept))
+                return
+            }
+        }
+        
+        const refType = NodeUtils.findReference(propertyDefinition, MetaPointers.PropertyType)
+        // const refType = propertyDefinition.references.find(ref => isEqualMetaPointer(ref.reference, MetaPointers.PropertyType))
+        const propertyName = propertyDefinition.properties.find(p => p.property.key === LION_CORE_BUILTINS_INAMED_NAME)?.value
+        // console.log("Found type should be " + refType.targets[0].reference);
+        if (propertyName !== null && propertyName !== undefined) {
+            if (refType !== null && refType !== undefined) {
+                const typeReferenceId = refType.targets[0].reference
+                switch (typeReferenceId) {
+                    case LIONWEB_BOOLEAN_TYPE:
+                        validateBoolean(prop.value, this.validationResult, context)
+                        break
+                    case LIONWEB_INTEGER_TYPE:
+                        validateInteger(prop.value, this.validationResult, context)
+                        break
+                    case LIONWEB_STRING_TYPE:
+                        // Each string is correct and having another JSON type is already captured
+                        break
+                    case LIONWEB_JSON_TYPE:
+                        validateJSON(prop.value, this.validationResult, context)
+                        break
+                    default: {
+                        // Check for enumeration
+                        // console.log("validateProperty: 0")
+                        const propTypeReference = NodeUtils.findReference(propertyDefinition, MetaPointers.PropertyType)
+                        if (propTypeReference === undefined) {
+                            // console.log("validateProperty: 1")
+                            break
+                        }
+                        const propType =  this.registry.findNode(propTypeReference.targets[0].reference)
+                        if (propType === undefined) {
+                            // console.log("validateProperty: 1.4 for " + prop.value + " ==> " + propTypeReference.targets[0].reference)
+                            break
+                        }
+                        let match = false
+                        if (isEqualMetaPointer(propType.classifier, MetaPointers.Enumeration)) {
+                            const literalsContainment = NodeUtils.findContainment(propType, MetaPointers.EnumerationLiterals)
+                            if (literalsContainment === undefined) {
+                                // console.log("validateProperty: 2")
+                                break;
+                            }
+                            const literals = literalsContainment.children.map(child => this.registry.findNode(child))
+                            match = literals.some(lit => {
+                                if (lit === undefined) {
+                                    // console.log("validateProperty: 3")
+                                    return false
+                                }
+                                const litKeyProp = NodeUtils.findProperty(lit, MetaPointers.IKeyedKey)
+                                if (litKeyProp === undefined) {
+                                    // console.log("validateProperty: 4")
+                                    return false
+                                }
+                                return prop.value === litKeyProp.value
+                            })
+                        }
+                        if (!match) {
+                            this.validationResult.issue(new Language_PropertyValue_Issue(context, prop.property.key, prop.value, propType.classifier.key))
+                        }
+                    }
+                }
+            } else {
+                // TODO refType not found, but
+            }
+        }
+    }
+}

package/src/validators/LionWebLanguageValidator.ts

@@ -0,0 +1,79 @@
+import { isEqualMetaPointer, LionWebJsonChunk, LionWebJsonNode } from "@lionweb/json"
+import { isLionWebM3Language, JsonContext, LionWebJsonChunkWrapper, MetaPointers } from "@lionweb/json-utils"
+import { asMinimalJsonString } from "@lionweb/ts-utils"
+import { GenericIssue } from "../issues/index.js"
+import { MissingM3Language_Issue } from "../issues/LanguageIssues.js"
+import { isConcept, LanguageRegistry } from "../languages/index.js"
+import { ValidationResult } from "./generic/ValidationResult.js"
+
+/**
+ * Validates whether a chunk is a valid language definition
+ */
+export class LionWebLanguageValidator {
+    validationResult: ValidationResult
+    chunkWrapper: LionWebJsonChunkWrapper | undefined
+    // availableLanguages: LionWebLanguageDefinition[] = []
+
+    constructor(validationResult: ValidationResult, private registry: LanguageRegistry) {
+        this.validationResult = validationResult
+        this.chunkWrapper = undefined
+    }
+
+    /**
+     * Check whether the metamodel is a Language.
+     * Assumption is that _chunk_ is already validated as a correct :LionWebJsonChunk
+     * @param chunk
+     */
+    validateLanguage(chunk: LionWebJsonChunk) {
+        this.chunkWrapper = new LionWebJsonChunkWrapper(chunk)
+        const usedM3Language = chunk.languages.find(lang => isLionWebM3Language(lang))
+        if (usedM3Language === undefined) {
+            this.validationResult.issue(new MissingM3Language_Issue(new JsonContext(null, ["languages"])))
+        }
+
+        const languageNodes = this.chunkWrapper.findNodesOfClassifier(MetaPointers.Language)
+        if (languageNodes.length !== 1) {
+            // TODO Better error handling.
+            console.error("Error: xpected exactly one Language node, found " + languageNodes.length + " => " + asMinimalJsonString(languageNodes))
+        }
+        chunk.nodes.forEach((node, index) => {
+            if (!isConcept(node)) {
+                this.validationResult.issue(new GenericIssue(new JsonContext(null, ["nodes", index]), `node ${node.id} is not a concept`))
+            } else {
+                this.validateConcept(node)
+            }
+        })
+    }
+
+    validateConcept(node: LionWebJsonNode): void {
+        node.properties.forEach(prop => {
+            const properties = this.chunkWrapper?.findNodesOfClassifier(MetaPointers.Property)
+            const matchedProperty = properties?.find(p => isEqualMetaPointer(p.classifier, prop.property))
+            // DUMMY
+            return matchedProperty !== undefined
+        })
+    }
+
+    validateNode(node: LionWebJsonNode): void {
+        const classifier = this.registry.getNodeByMetaPointer(node.classifier)
+        if (classifier === undefined) {
+            this.validationResult.issue(
+                new GenericIssue(new JsonContext(null, ["nodes"]), `Classifier ${node.classifier.key} not found for node ${node.id}`)
+            )
+            return
+        }
+        this.validateProperties(node, classifier)
+    }
+    
+    validateProperties(node: LionWebJsonNode, classifier: LionWebJsonNode): void {
+        node.properties.forEach(actualProp => {
+            const propClassifier = this.registry.getNodeByMetaPointer(actualProp.property)
+            if (propClassifier === undefined) {
+                this.validationResult.issue(
+                    new GenericIssue(new JsonContext(null, ["nodes", "properties"]), 
+                        `Property ${actualProp.property.key} not found for classifier ${classifier.id}`)
+                )
+            }
+        })
+    }
+}