@lionweb/validation 0.7.0-beta.11 → 0.7.0-beta.13

package/src/languages/LionCore-builtins.json

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

package/src/languages/LionWebLanguageWrapper.ts

@@ -1,91 +0,0 @@
-import { LionWebJsonChunk, LionWebJsonNode, LionWebKey } from "@lionweb/json"
-import { LionWebJsonChunkWrapper, MetaPointers, NodeUtils } from "@lionweb/json-utils"
-import { visitAndMap } from "@lionweb/ts-utils"
-import { isAnnotation, isConcept, isContainment, isInterface, isProperty, isReference } from "./LanguageUtils.js"
-
-interface LionWebLanguageWrapperInterface {
-    superClassifiers: (classifier: LionWebJsonNode) => LionWebJsonNode[]
-    allClassifiers: (classifier: LionWebJsonNode) => LionWebJsonNode[]
-    propertyDefinitions: (classifier: LionWebJsonNode) => LionWebJsonNode[]
-    allProperties: (classifier: LionWebJsonNode) => LionWebJsonNode[]
-    referenceDefinitions: (classifier: LionWebJsonNode) => LionWebJsonNode[]
-    allReferenceDefinitions: (classifier: LionWebJsonNode) => LionWebJsonNode[]
-    containmentDefinitions: (classifier: LionWebJsonNode) => LionWebJsonNode[]
-    allContainments: (classifier: LionWebJsonNode) => LionWebJsonNode[]
-}
-
-/**
- * Class encapsulating a chunk that represent a language.
- */
-export class LionWebLanguageWrapper extends LionWebJsonChunkWrapper implements LionWebLanguageWrapperInterface {
-    name: string
-    version: string
-    key: LionWebKey
-
-    constructor(chunk: LionWebJsonChunk) {
-        super(chunk)
-        const languageNode: LionWebJsonNode = this.findNodesOfClassifier(MetaPointers.Language)[0]
-        const versionProp = NodeUtils.findProperty(languageNode, MetaPointers.LanguageVersion)
-        const keyProp = NodeUtils.findProperty(languageNode, MetaPointers.IKeyedKey)
-        const nameProp = NodeUtils.findProperty(languageNode, MetaPointers.INamedName)
-        this.version = versionProp?.value || "unknown"
-        this.key = keyProp?.value || "unknown"
-        this.name = nameProp?.value || "unknown"
-    }
-
-    superClassifiers = (classifier: LionWebJsonNode): LionWebJsonNode[] => {
-        const result: LionWebJsonNode[] = []
-
-        if (isConcept(classifier)) {
-            const extnds = NodeUtils.findReference(classifier, MetaPointers.ConceptExtends)
-            const implments = NodeUtils.findReference(classifier, MetaPointers.ConceptImplements)
-            result.push(...this.getReferredNodes(extnds))
-            result.push(...this.getReferredNodes(implments))
-        } else if (isAnnotation(classifier)) {
-            const extnds = NodeUtils.findReference(classifier, MetaPointers.AnnotationExtends)
-            const implments = NodeUtils.findReference(classifier, MetaPointers.AnnotationImplements)
-            result.push(...this.getReferredNodes(extnds))
-            result.push(...this.getReferredNodes(implments))
-        } else if (isInterface(classifier)) {
-            const extnds = NodeUtils.findReference(classifier, MetaPointers.InterfaceExtends)
-            result.push(...this.getReferredNodes(extnds))
-        } else {
-            throw new Error(`concept type ${typeof classifier} not handled`)
-        }
-        return result
-    }
-
-    allClassifiers = (classifier: LionWebJsonNode): LionWebJsonNode[] => {
-        return visitAndMap(this.superClassifiers, this.superClassifiers)(classifier)
-    }
-
-    propertyDefinitions = (classifier: LionWebJsonNode): LionWebJsonNode[] => {
-        const features = NodeUtils.findContainment(classifier, MetaPointers.ClassifierFeatures)
-        const properties = this.getChildrenAsNodes(features).filter(f => isProperty(f))
-        return properties
-    }
-
-    allProperties = (classifier: LionWebJsonNode): LionWebJsonNode[] => {
-        return visitAndMap(this.propertyDefinitions, this.superClassifiers)(classifier)
-    }
-
-    referenceDefinitions = (classifier: LionWebJsonNode): LionWebJsonNode[] => {
-        const features = NodeUtils.findContainment(classifier, MetaPointers.ClassifierFeatures)
-        const references = this.getChildrenAsNodes(features).filter(f => isReference(f))
-        return references
-    }
-
-    allReferenceDefinitions = (classifier: LionWebJsonNode): LionWebJsonNode[] => {
-        return visitAndMap(this.referenceDefinitions, this.superClassifiers)(classifier)
-    }
-
-    containmentDefinitions = (classifier: LionWebJsonNode): LionWebJsonNode[] => {
-        const features = NodeUtils.findContainment(classifier, MetaPointers.ClassifierFeatures)
-        const properties = this.getChildrenAsNodes(features).filter(f => isContainment(f))
-        return properties
-    }
-
-    allContainments = (classifier: LionWebJsonNode): LionWebJsonNode[] => {
-        return visitAndMap(this.containmentDefinitions, this.superClassifiers)(classifier)
-    }
-}

package/src/languages/MetaPointerMap.ts

@@ -1,41 +0,0 @@
-import { LionWebJsonMetaPointer, LionWebJsonNode, LionWebKey } from "@lionweb/json"
-import { MetaPointers, NodeUtils } from "@lionweb/json-utils"
-
-export class MetaPointerMap {
-    /**
-     * Map from languageKey => languageVersion => key => LionWebJsonNode
-     */
-    map: Map<string, Map<string, Map<string, LionWebJsonNode>>> = new Map<string, Map<string, Map<string, LionWebJsonNode>>>()
-
-    add(languageKey: LionWebKey, languageVersion: string, node: LionWebJsonNode): void {
-        const keyProperty = NodeUtils.findProperty(node, MetaPointers.IKeyedKey)
-        if (keyProperty === undefined) {
-            console.log("MetaPointerMap.add: trying to add node without key property.")
-            return
-        }
-        const key = keyProperty.value
-        if (key === undefined || key == null || key === "") {
-            console.log("MetaPointerMap.add: trying to add node without key property being empty or null.")
-            return
-        }
-        this.set({ language: languageKey, version: languageVersion, key: key }, node)
-    }
-
-    set(mp: LionWebJsonMetaPointer, node: LionWebJsonNode): void {
-        let language = this.map.get(mp.language)
-        if (language === undefined) {
-            language = new Map<string, Map<string, LionWebJsonNode>>()
-            this.map.set(mp.language, language)
-        }
-        let version = language.get(mp.version)
-        if (version === undefined) {
-            version = new Map<string, LionWebJsonNode>()
-            language.set(mp.version, version)
-        }
-        version.set(mp.key, node)
-    }
-
-    get(mp: LionWebJsonMetaPointer): LionWebJsonNode | undefined {
-        return this.map.get(mp.language)?.get(mp.version)?.get(mp.key)
-    }
-}

package/src/languages/index.ts

@@ -1,2 +0,0 @@
-export * from "./LanguageRegistry.js"
-export * from "../languages/LanguageUtils.js"

package/src/runners/FileUtils.ts

@@ -1,59 +0,0 @@
-import fs from "fs"
-import { LanguageRegistry } from "../languages/index.js"
-import { ValidationResult } from "../validators/generic/ValidationResult.js"
-import { LionWebValidator } from "../validators/LionWebValidator.js"
-import { getFilesRecursive, printIssues } from "./Utils.js"
-
-export function validateFile(file: string, registry: LanguageRegistry): void {
-    const result = validateFileResult(file, false, registry)
-    printIssues(result)
-}
-
-export function validateFileResult(file: string, validateAgainstLanguage: boolean, registry: LanguageRegistry): ValidationResult {
-    if (file !== null) {
-        const jsonString1 = fs.readFileSync(file, "utf-8")
-        const json1 = JSON.parse(jsonString1)
-        const validator = new LionWebValidator(json1, registry)
-
-        validator.validateSyntax()
-        validator.validateReferences()
-        if (validateAgainstLanguage) {
-            validator.validateForLanguage()
-        }
-        return validator.validationResult
-    }
-    return new ValidationResult()
-}
-
-export function validateFolder(folder: string, registry: LanguageRegistry): void {
-    let totalErrors = 0
-    let totalSucceed = 0
-    let totalFailed = 0
-
-    for (const f of getFilesRecursive(folder, [])) {
-        const jsonString1 = fs.readFileSync(f, "utf-8")
-        const json1 = JSON.parse(jsonString1)
-        const validator = new LionWebValidator(json1, registry)
-
-        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/RunCheckFolder.ts

@@ -1,7 +0,0 @@
-import { LanguageRegistry } from "../languages/index.js"
-import { validateFolder } from "./FileUtils.js"
-
-const folder = process.argv[2]
-
-const registry = new LanguageRegistry()
-validateFolder(folder, registry)

package/src/runners/RunCheckFolderWithLanguage.ts

@@ -1,45 +0,0 @@
-import fs from "fs"
-import { LanguageRegistry } from "../languages/index.js"
-import { LionWebLanguageWrapper } from "../languages/LionWebLanguageWrapper.js"
-import { LionWebValidator } from "../validators/LionWebValidator.js"
-import { getFilesRecursive, printIssues } from "./Utils.js"
-
-const folder = process.argv[2]
-const language = process.argv[3]
-
-let totalSucceed = 0
-let totalFailed = 0
-
-const registry = new LanguageRegistry()
-const languageString = fs.readFileSync(language, "utf-8")
-const languageJson = JSON.parse(languageString)
-const languageValidator = new LionWebValidator(languageJson, registry)
-registry.addLanguage(new LionWebLanguageWrapper(languageJson))
-
-console.log("Language is " + language)
-languageValidator.validateSyntax()
-languageValidator.validateReferences()
-if (languageValidator.validationResult.hasErrors()) {
-    console.log("===== Language errors, ignoring folder ======")
-    printIssues(languageValidator.validationResult)
-    process.exit(1)
-}
-
-for (const modelFile of getFilesRecursive(folder, [])) {
-    const jsonString1 = fs.readFileSync(modelFile, "utf-8")
-    const jsonModel = JSON.parse(jsonString1)
-    const modelValidator = new LionWebValidator(jsonModel, registry)
-
-    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

@@ -1,7 +0,0 @@
-import { LanguageRegistry } from "../languages/index.js"
-import { validateFile } from "./FileUtils.js"
-
-const file1 = process.argv[2]
-
-const registry = new LanguageRegistry()
-validateFile(file1, registry)

package/src/runners/RunCheckOneFileWithLanguage.ts

@@ -1,35 +0,0 @@
-import fs from "fs"
-import { LanguageRegistry } from "../languages/index.js"
-import { LionWebLanguageWrapper } from "../languages/LionWebLanguageWrapper.js"
-import { LionWebValidator } from "../validators/LionWebValidator.js"
-import { printIssues } from "./Utils.js"
-
-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 m3String = fs.readFileSync("src/json/LionCore_M3.json", "utf-8")
-    const m3Json = JSON.parse(m3String)
-    const builtinString = fs.readFileSync("src/json/LionCore_builtins.json", "utf-8")
-    const builtinJson = JSON.parse(builtinString)
-    const registry = new LanguageRegistry()
-    registry.addLanguage(new LionWebLanguageWrapper(m3Json))
-    registry.addLanguage(new LionWebLanguageWrapper(builtinJson))
-    registry.addLanguage(new LionWebLanguageWrapper(languageJson))
-
-    const languageValidator = new LionWebValidator(languageJson, registry)
-
-    languageValidator.validateSyntax()
-    languageValidator.validateReferences()
-    console.log("===== Language errors ======")
-    printIssues(languageValidator.validationResult)
-
-    const modelValidator = new LionWebValidator(jsonModel, registry)
-    modelValidator.validateAll()
-    console.log("===== Model errors ======")
-    printIssues(modelValidator.validationResult)
-}