@lionweb/validation 0.6.1-beta.0 → 0.6.1-beta.1

package/src/languages/LionCore-builtins.json

@@ -0,0 +1,372 @@
+{
+    "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

@@ -0,0 +1,95 @@
+import {
+    LionWebJsonChunkWrapper,
+    MetaPointers,
+    NodeUtils
+} from "../json/index.js"
+import { LionWebJsonChunk, LionWebJsonNode } from "../json/LionWebJson.js"
+import { visitAndMap } from "../util/graphs.js"
+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: string
+    
+    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

@@ -0,0 +1,40 @@
+import { LionWebJsonMetaPointer, LionWebJsonNode, MetaPointers, NodeUtils } from "../json/index.js"
+
+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: string, 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

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

package/src/runners/FileUtils.ts

@@ -1,58 +1,31 @@
 import fs from "fs"
-import { LionWebJsonChunkWrapper, LionWebLanguageDefinition } from "../json/index.js"
+import { LanguageRegistry } from "../languages/index.js"
 import { LionWebValidator } from "../validators/LionWebValidator.js"
 import { ValidationResult } from "../validators/ValidationResult.js"
 import { getFilesRecursive, printIssues } from "./Utils.js"
 
-export function validateFile(file: string): void {
-    const result = validateFileResult(file)
+export function validateFile(file: string, registry: LanguageRegistry): void {
+    const result = validateFileResult(file, false, registry)
     printIssues(result)
 }
 
-export function validateFileResult(file: string): ValidationResult {
+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, null)
+        const validator = new LionWebValidator(json1, registry)
 
         validator.validateSyntax()
         validator.validateReferences()
-        validator.validateForLanguage()
-        return validator.validationResult
-    }
-    return new ValidationResult()
-}
-
-export function validateFileResultWithLanguage(file: string, languageFile?: string | null): ValidationResult {
-    let langDef: LionWebLanguageDefinition | null = null
-
-    if (languageFile !== undefined && languageFile !== null) {
-        const jsonString1 = fs.readFileSync(file, "utf-8")
-        const languageJson = JSON.parse(jsonString1)
-        const validator = new LionWebValidator(languageJson, null)
-
-        validator.validateSyntax()
-        validator.validateReferences()
-        validator.validateForLanguage()
-        if (validator.validationResult.hasErrors()) {
-            return validator.validationResult
+        if (validateAgainstLanguage) {
+            validator.validateForLanguage()
         }
-        langDef = new LionWebLanguageDefinition(new LionWebJsonChunkWrapper(languageJson))
-    }
-
-    if (file !== null) {
-        const fileString = fs.readFileSync(file, "utf-8")
-        const fileJson = JSON.parse(fileString)
-        const validator = new LionWebValidator(fileJson, langDef)
-        validator.validateSyntax()
-        validator.validateReferences()
-        validator.validateForLanguage()
         return validator.validationResult
     }
     return new ValidationResult()
 }
 
-export function validateFolder(folder: string): void {
+export function validateFolder(folder: string, registry: LanguageRegistry): void {
     let totalErrors = 0
     let totalSucceed = 0
     let totalFailed = 0
@@ -60,7 +33,7 @@ export function validateFolder(folder: string): void {
     for (const f of getFilesRecursive(folder, [])) {
         const jsonString1 = fs.readFileSync(f, "utf-8")
         const json1 = JSON.parse(jsonString1)
-        const validator = new LionWebValidator(json1, null)
+        const validator = new LionWebValidator(json1, registry)
 
         try {
             validator.validateAll()

package/src/runners/RunCheckFolder.ts

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

package/src/runners/RunCheckFolderWithLanguage.ts

@@ -1,6 +1,6 @@
 import fs from "fs"
-import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
-import { LionWebLanguageDefinition } from "../json/LionWebLanguageDefinition.js"
+import { LanguageRegistry } from "../languages/index.js"
+import { LionWebLanguageWrapper } from "../languages/LionWebLanguageWrapper.js"
 import { LionWebValidator } from "../validators/LionWebValidator.js"
 import { getFilesRecursive, printIssues } from "./Utils.js"
 
@@ -10,10 +10,13 @@ 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, null)
+const languageValidator = new LionWebValidator(languageJson, registry)
+registry.addLanguage(new LionWebLanguageWrapper(languageJson))
 
+console.log("Language is " + language)
 languageValidator.validateSyntax()
 languageValidator.validateReferences()
 if (languageValidator.validationResult.hasErrors()) {
@@ -25,10 +28,7 @@ if (languageValidator.validationResult.hasErrors()) {
 for (const modelFile of getFilesRecursive(folder, [])) {
     const jsonString1 = fs.readFileSync(modelFile, "utf-8")
     const jsonModel = JSON.parse(jsonString1)
-    const modelValidator = new LionWebValidator(
-        jsonModel,
-        new LionWebLanguageDefinition(languageValidator.chunk as LionWebJsonChunkWrapper),
-    )
+    const modelValidator = new LionWebValidator(jsonModel, registry )
 
     modelValidator.validateAll()
     if (modelValidator.validationResult.hasErrors()) {

package/src/runners/RunCheckOneFile.ts

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

package/src/runners/RunCheckOneFileWithLanguage.ts

@@ -1,6 +1,6 @@
 import fs from "fs"
-import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
-import { LionWebLanguageDefinition } from "../json/LionWebLanguageDefinition.js"
+import { LanguageRegistry } from "../languages/index.js"
+import { LionWebLanguageWrapper } from "../languages/LionWebLanguageWrapper.js"
 import { LionWebValidator } from "../validators/LionWebValidator.js"
 import { printIssues } from "./Utils.js"
 
@@ -12,18 +12,23 @@ if (modelFile !== null) {
     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, null)
+    const languageValidator = new LionWebValidator(languageJson, registry)
 
     languageValidator.validateSyntax()
     languageValidator.validateReferences()
     console.log("===== Language errors ======")
     printIssues(languageValidator.validationResult)
 
-    const modelValidator = new LionWebValidator(
-        jsonModel,
-        new LionWebLanguageDefinition(languageValidator.chunk as LionWebJsonChunkWrapper),
-    )
+    const modelValidator = new LionWebValidator(jsonModel, registry)
     modelValidator.validateAll()
     console.log("===== Model errors ======")
     printIssues(modelValidator.validationResult)