@lionweb/validation 0.7.0-beta.10 → 0.7.0-beta.12

package/src/languages/LanguageRegistry.ts

@@ -1,44 +0,0 @@
-import { LionWebId, LionWebJsonMetaPointer, LionWebJsonNode } from "@lionweb/json"
-import { CompositeLionWebLanguageWrapper } from "./CompositeLionWebLanguageWrapper.js"
-import { LionWebLanguageWrapper } from "./LionWebLanguageWrapper.js"
-
-/**
- * Collection of language definitions
- */
-export class LanguageRegistry {
-    languages: CompositeLionWebLanguageWrapper = new CompositeLionWebLanguageWrapper({nodes: [], languages: [], serializationFormatVersion: "2023.1"})
-    
-    addLanguage(lionWebLanguage: LionWebLanguageWrapper) {
-        // console.log("LanguageRegistry.add: " + lionWebLanguage.name + "  " + lionWebLanguage.jsonChunk.nodes.length)
-
-        this.languages.addLanguage(lionWebLanguage)
-    }
-    
-    clear(): void {
-        this.languages = new CompositeLionWebLanguageWrapper({nodes: [], languages: [], serializationFormatVersion: "2023.1"})
-    }
-
-    getLanguage(pointer: LionWebJsonMetaPointer): LionWebLanguageWrapper | undefined {
-        return this.languages.languageMap.get(pointer.language)?.get(pointer.version)
-    }
-
-    /**
-     * Gets the node with _metaPointer_ in any of the known languages
-     * @param metaPointer
-     */
-    getNodeByMetaPointer(metaPointer: LionWebJsonMetaPointer): LionWebJsonNode | undefined {
-        return this.languages.getNodeByMetaPointer(metaPointer)
-    }
-
-    findNode(nodeId: LionWebId) {
-        for (const chunk of this.languages.languages) {
-            const node = chunk.getNode(nodeId)
-            if (node !== undefined) {
-                return node
-            }
-        }
-        return undefined
-    }
-}
-
-// export const KnownLanguages = new LanguageRegistry()

package/src/languages/LanguageUtils.ts

@@ -1,63 +0,0 @@
-import { isEqualMetaPointer, LionWebJsonChunk, LionWebJsonNode } from "@lionweb/json"
-import { LION_CORE_M3_KEY, MetaPointers } from "@lionweb/json-utils"
-
-import { createRequire } from "module"
-
-const require = createRequire(import.meta.url)
-const LionCore_M3 = require("./LionCore-M3.json")
-const LionCore_builtins = require("./LionCore-builtins.json")
-
-export const LionCore_M3_Json = LionCore_M3 as LionWebJsonChunk
-export const LionCore_builtins_Json = LionCore_builtins as LionWebJsonChunk
-
-export function isLionCoreLanguage(node: LionWebJsonNode) {
-    return node.classifier.language === LION_CORE_M3_KEY && node.classifier.version === "2023.1"
-}
-
-/**
- * Does _node_ represent a language concept?
- * @param node
- */
-export const isConcept = (node: LionWebJsonNode): boolean => {
-    return isEqualMetaPointer(node.classifier, MetaPointers.Concept)
-}
-
-/**
- * Does _node_ represent a language annotation?
- * @param node
- */
-export const isAnnotation = (node: LionWebJsonNode): boolean => {
-    return isEqualMetaPointer(node.classifier, MetaPointers.Annotation)
-}
-
-/**
- * Does _node_ represent a language interface?
- * @param node
- */
-export const isInterface = (node: LionWebJsonNode): boolean => {
-    return isEqualMetaPointer(node.classifier, MetaPointers.Interface)
-}
-
-/**
- * Does _node_ represent a language property?
- * @param node
- */
-export const isProperty = (node: LionWebJsonNode): boolean => {
-    return isEqualMetaPointer(node.classifier, MetaPointers.Property)
-}
-
-/**
- * Does _node_ represent a language containment?
- * @param node
- */
-export const isContainment = (node: LionWebJsonNode): boolean => {
-    return isEqualMetaPointer(node.classifier, MetaPointers.Containment)
-}
-
-/**
- * Does _node_ represent a language reference?
- * @param node
- */
-export const isReference = (node: LionWebJsonNode): boolean => {
-    return isEqualMetaPointer(node.classifier, MetaPointers.Reference)
-}

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)
-}

package/src/runners/RunLioncoreDiff.ts

@@ -1,23 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

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

package/src/validators/LionWebLanguageValidator.ts

@@ -1,78 +0,0 @@
-import { isEqualMetaPointer, LionWebJsonChunk, LionWebJsonNode } from "@lionweb/json"
-import { isLionWebM3Language, JsonContext, LionWebJsonChunkWrapper, MetaPointers } from "@lionweb/json-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 + " => " + JSON.stringify(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}`)
-                )
-            }
-        })
-    }
-}

package/src/validators/LionWebSyntaxValidator.ts

@@ -1,14 +0,0 @@
-import { SyntaxValidator } from "./generic/SyntaxValidator.js"
-import { ValidationResult } from "./generic/ValidationResult.js"
-import { LionWebSchema } from "./LionWebChunkDefinitions.js"
-
-/**
- * LionWebSyntaxValidator can check whether objects are structurally LionWeb objects.
- */
-export class LionWebSyntaxValidator extends SyntaxValidator {
-
-    constructor(validationResult: ValidationResult) {
-        super(validationResult, LionWebSchema)
-    }
-}
-