@lionweb/validation 0.5.0-beta.8

package/src/issues/SyntaxIssues.ts

@@ -0,0 +1,68 @@
+import { JsonContext, ValidationIssue } from "./ValidationIssue";
+
+export abstract class Syntax_PropertyIssue extends ValidationIssue {
+    constructor(public context: JsonContext, protected property: string) {
+        super(context);
+    }
+}
+
+export class Syntax_PropertyMissingIssue extends Syntax_PropertyIssue {
+    readonly id = 'PropertyMissing';
+    protected msg = () => `Property "${this.property}" is missing`;
+}
+
+export class Syntax_PropertyUnknownIssue extends Syntax_PropertyIssue {
+    readonly id = 'PropertyUnknown';
+    protected msg = () => `Property "${this.property}" is not defined as a LionWeb property`;
+}
+
+export class Syntax_PropertyNullIssue extends Syntax_PropertyIssue {
+    readonly id = 'PropertyNull';
+    protected msg = () => `Property "${this.property}" is null, but it should have a value`;
+}
+
+export class Syntax_PropertyTypeIssue extends Syntax_PropertyIssue {
+    readonly id = 'PropertyTypeIncorrect';
+
+    constructor(context: JsonContext, property: string, protected expectedType: string, protected actualType: string) {
+        super(context, property);
+    }
+
+    protected msg = () => `Property ${this.property} should have type "${this.expectedType}", but has type "${this.actualType}"`;
+}
+
+export class Syntax_ArrayContainsNull_Issue extends Syntax_PropertyIssue {
+    readonly id = "ArrayContainsNull";
+
+    constructor(context: JsonContext, property: string, public index: number) {
+        super(context, property);
+    }
+
+    protected msg = () => `Property "${this.property}" of type array contains null at index "${"" + this.index}" `
+}
+
+export abstract class Syntax_IncorrectFormat_Issue extends ValidationIssue {
+    constructor(context: JsonContext, public value: string) {
+        super(context);
+    }
+}
+
+export class Syntax_SerializationFormatVersion_Issue extends Syntax_IncorrectFormat_Issue {
+    readonly id = "SerializationFormatVersion";
+    protected msg = () => `SerializationFormatVersion "${this.value}" is not a number`
+}
+
+export class Syntax_VersionFormat_Issue extends Syntax_IncorrectFormat_Issue {
+    readonly id = "VersionFormat";
+    protected msg = () => `Version "${this.value}" is an empty string.`
+}
+
+export class Syntax_KeyFormat_Issue extends Syntax_IncorrectFormat_Issue {
+    readonly id = "KeyFormat";
+    protected msg = () => `Key "${this.value}" has incorrect format.`
+}
+
+export class Syntax_IdFormat_Issue extends Syntax_IncorrectFormat_Issue {
+    readonly id = "IdFormat";
+    protected msg = () => `Id "${this.value}" has incorrect format.`
+}

package/src/issues/ValidationIssue.ts

@@ -0,0 +1,46 @@
+type JsonPath = (string | number)[];
+
+export class JsonContext {
+    private parent: JsonContext | null;
+    private local_path: JsonPath;
+    
+    concat(... items: JsonPath) : JsonContext {
+        return new JsonContext(this, items);
+    }
+    
+    path(): JsonPath {
+        return this.parent === null ? this.local_path : this.parent.path().concat(this.local_path);
+    }
+    
+    constructor(parent: JsonContext | null, path: JsonPath) {
+        this.parent = parent;
+        this.local_path = path;
+    }
+    
+    toString(): string {
+        let result = "";
+        this.path().forEach((part, index) => {
+            if (typeof part === "string") {
+                result += (index === 0 ? "" : ".") + part;
+            } else if (typeof part === "number") {
+                result += "[" + part + "]";
+            }
+        });
+        return result;
+    }
+}
+
+export abstract class ValidationIssue {
+    abstract readonly id: string;
+    context: JsonContext;
+    
+    constructor(context: JsonContext) {
+        this.context = context;
+    }
+
+    protected abstract msg(): string;
+    
+    public errorMsg(): string {
+        return `${this.id}: ${this.msg()} at ${this.context.toString()} `
+    }
+}

package/src/json/ChunkUtils.ts

@@ -0,0 +1,53 @@
+import {
+    LionWebJsonChunk,
+    LionWebJsonNode,
+    LwJsonUsedLanguage
+} from "./LionWebJson";
+
+/**
+ * Utility functions for LionWeb chunks
+ */
+export class ChunkUtils {
+    /**
+     * Find a used language in `chunk` with `key`.
+     * @param chunk
+     * @param key
+     */
+    static findLwUsedLanguage(chunk: LionWebJsonChunk, key: string): LwJsonUsedLanguage | null {
+        for (const language of chunk.languages) {
+            if (language.key === key) {
+                return language;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Find a used language in `chunk` with `key` and 'version'.
+     * @param chunk
+     * @param key
+     * @param version
+     */
+    static findLwUsedLanguageWithVersion(chunk: LionWebJsonChunk, key: string, version: string): LwJsonUsedLanguage | null {
+        for (const language of chunk.languages) {
+            if (language.key === key && language.version === version) {
+                return language;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Find node with id equals `id` in `chunk`.
+     * @param chunk
+     * @param id
+     */
+    static findNode(chunk: LionWebJsonChunk, id: string): LionWebJsonNode | null {
+        for (const node of chunk.nodes) {
+            if (node.id === id) {
+                return node;
+            }
+        }
+        return null;
+    }
+}

package/src/json/LanguageUtils.ts

@@ -0,0 +1,12 @@
+import { LionWebJsonChunk } from "./LionWebJson";
+import { LionWebJsonChunkWrapper } from "./LionWebJsonChunkWrapper";
+
+/**
+ * Contains methods for getting information from a LionWebJsonChunk representing a language.
+ */
+export class LanguageWrapper extends LionWebJsonChunkWrapper {
+   
+    constructor(languageJson: LionWebJsonChunk) {
+        super(languageJson);
+    }
+}

package/src/json/LionWebJson.ts

@@ -0,0 +1,77 @@
+/**
+ * The types defining the structure of the LionWeb JSON format.
+ * @see https://lionweb-io.github.io/specification/serialization/serialization.html
+ * We use types instead of classes, because the purpose is to define the Lionweb JSON to be sent over the line.
+ */
+export const LION_CORE_BUILTINS_KEY = "LionCore-builtins";
+export const LION_CORE_BUILTINS_INAMED_NAME = "LionCore-builtins-INamed-name";
+
+export const LIONWEB_BOOLEAN_TYPE = "LionCore-builtins-Boolean";
+export const LIONWEB_JSON_TYPE = "LionCore-builtins-JSON";
+export const LIONWEB_INTEGER_TYPE = "LionCore-builtins-Integer";
+export const LIONWEB_STRING_TYPE = "LionCore-builtins-String";
+
+export type Id = string;
+
+export type LionWebJsonMetaPointer = {
+    language: string;
+    version: string;
+    key: string;
+};
+
+export function isEqualMetaPointer(p1: LionWebJsonMetaPointer, p2: LionWebJsonMetaPointer): boolean {
+    return p1.key === p2.key && p1.version === p2.version && p1.language === p2.language;
+}
+
+export type LionWebJsonChunk = {
+    serializationFormatVersion: string;
+    languages: LwJsonUsedLanguage[];
+    nodes: LionWebJsonNode[];
+};
+
+export type LwJsonUsedLanguage = {
+    key: string;
+    version: string;
+};
+
+export type LionWebJsonNode = {
+    id: Id;
+    classifier: LionWebJsonMetaPointer;
+    properties: LionWebJsonProperty[];
+    containments: LionWebJsonChild[];
+    references: LionWebJsonReference[];
+    annotations: Id[];
+    parent: Id | null;
+};
+
+export function createLwNode(): LionWebJsonNode {
+    return {
+        id: "",
+        classifier: { language: "", version: "", key: "" },
+        properties: [],
+        containments: [],
+        references: [],
+        annotations: [],
+        parent: null,
+    };
+}
+
+export type LionWebJsonProperty = {
+    property: LionWebJsonMetaPointer;
+    value: string;
+};
+
+export type LionWebJsonChild = {
+    containment: LionWebJsonMetaPointer;
+    children: string[];
+};
+
+export type LionWebJsonReference = {
+    reference: LionWebJsonMetaPointer;
+    targets: LionWebJsonReferenceTarget[];
+};
+
+export type LionWebJsonReferenceTarget = {
+    resolveInfo: string;
+    reference: string;
+};

package/src/json/LionWebJsonChunkWrapper.ts

@@ -0,0 +1,74 @@
+import { LionWebJsonChunk, LionWebJsonNode, LionWebJsonProperty } from "./LionWebJson";
+import { LionWebLanguageDefinition } from "./LionWebLanguageDefinition";
+import { NodeUtils } from "./NodeUtils";
+
+export type NodeId = string;
+
+/**
+ * Wraps around a LionWebJsonChunk, providing access to information inside, using caches to improve performance.
+ */
+export class LionWebJsonChunkWrapper {
+    jsonChunk: LionWebJsonChunk;
+    language: LionWebLanguageDefinition  | null = null;
+    /**
+     * Map to get quick access to nodes by id.
+     * @protected
+     */
+    protected nodesIdMap: Map<NodeId, LionWebJsonNode> = new Map<NodeId, LionWebJsonNode>();
+
+    constructor(chunk: unknown) {
+        this.jsonChunk = chunk as LionWebJsonChunk;
+        // this.prepareNodeIds();
+    }
+
+    /** Put all nodes in a map, validate that there are no two nodes with the same id.
+     *  The check should logically be in LionWebReferenceValidator, but the created map is needed here.
+     */
+    prepareNodeIds() {
+        this.nodesIdMap = new Map<NodeId, LionWebJsonNode>();
+        this.jsonChunk.nodes.forEach((node) => {
+            this.nodesIdMap.set(node.id, node);
+        });
+    }
+
+    getMap(): Map<NodeId, LionWebJsonNode> {
+        if (this.nodesIdMap === undefined) {
+            this.prepareNodeIds();
+        }
+        return this.nodesIdMap;
+    }
+
+    getNode(id: string): LionWebJsonNode | undefined {
+        return this.getMap().get(id);
+    }
+
+    findNodesOfConcept(conceptKey: string): LionWebJsonNode[] {
+        const result: LionWebJsonNode[] = [];
+        for (const node of this.jsonChunk.nodes) {
+            if (node.classifier.key === conceptKey) {
+                result.push(node);
+            }
+        }
+        return result;
+        // return this.jsonChunk.nodes.filter(node => node.classifier.key === conceptKey);
+    }
+
+    allProperties(conceptNode: LionWebJsonNode): LionWebJsonProperty[] {
+        const result: LionWebJsonProperty[] = [];
+        result.push(...conceptNode.properties);
+        const extendsReference = NodeUtils.findLwReference(conceptNode, "Concept-extends");
+        if (extendsReference !==null) {
+            // extendsReference.targets.forEach(target => {
+            //     // Find the extended concept
+            //     if (this.language !== null) {
+            //         // const targetNode = this.language.languageChunkWrapper.getNode(target.reference);
+            //         // TODO etc., but need to cleanup LanguageDefinition first.
+            //     }
+            // });
+        }
+        return result;
+    }
+
+}
+
+

package/src/json/LionWebLanguageDefinition.ts

@@ -0,0 +1,141 @@
+import {
+    LION_CORE_BUILTINS_INAMED_NAME,
+    LionWebJsonMetaPointer,
+    LionWebJsonNode,
+} from "./LionWebJson";
+import { LionWebJsonChunkWrapper } from "./LionWebJsonChunkWrapper";
+import { NodeUtils } from "./NodeUtils";
+
+type LanguageId = {
+    name?: string;
+    version?: string;
+    key?: string;
+};
+
+export const LIONWEB_M3_PROPERTY_KEY = "Property";
+export const LIONWEB_M3_CONCEPT_KEY = "Concept";
+export const LIONWEB_M3_REFERENCE_KEY = "Reference";
+export const LIONWEB_M3_PROPERTY_TYPE_KEY = "Property-type";
+/**
+ * Collection of language definitions
+ */
+// export class LionwebLanguages {
+//     // The builtin language of LionWeb.
+//     static M3 = LionCore_M3 as LionWebJsonChunk;
+//
+//     languageMap = new Map<string, Map<string, Map<string, LionwebLanguageDefinition>>>();
+//
+//     setLanguage(lionWebLanguage: LionwebLanguageDefinition) {
+//         // Assume LwNode is a concept of type "Language"
+//         let language = this.languageMap.get(lionWebLanguage.languageId.name);
+//         if (language === undefined) {
+//             language = new Map<string, Map<string, LionwebLanguageDefinition>>();
+//             this.languageMap.set(lionWebLanguage.languageId.name, language);
+//         }
+//         let version = language.get(lionWebLanguage.languageId.version);
+//         if (version === undefined) {
+//             version = new Map<string, LionwebLanguageDefinition>();
+//             language.set(lionWebLanguage.languageId.version, version);
+//         }
+//         let key = version.get(lionWebLanguage.languageId.key);
+//         if (key === undefined) {
+//             version.set(lionWebLanguage.languageId.key, lionWebLanguage);
+//         }
+//     }
+//
+//     getLanguage(pointer: LionWebJsonMetaPointer): LionwebLanguageDefinition {
+//         return this.languageMap.get(pointer.language)?.get(pointer.version)?.get(pointer.key);
+//     }
+// }
+
+/**
+ * Represents a LionWeb serialiation chunk which represents a language definition / metamodel
+ */
+export class LionWebLanguageDefinition {
+    languageId: LanguageId | null = null;
+    /**
+     * All nodes in the language
+     */
+    nodeKeymap = new Map<string, LionWebJsonNode>();
+    languageChunkWrapper: LionWebJsonChunkWrapper;
+
+    /**
+     * Assume chunk represents a language metamodel according to Lionweb M3.
+     * @param chunk
+     */
+    constructor(chunk: LionWebJsonChunkWrapper) {
+        // console.log("CHUNK " + JSON.stringify(chunk))
+        const languageNodes = chunk.findNodesOfConcept("Language");
+        if (languageNodes.length !== 1) {
+            // TODO Better error handling.
+            console.error("1 Expected exactly one Language node, found " + languageNodes.length + " => " + JSON.stringify(languageNodes));
+        } else {
+            const languageNode = languageNodes[0];
+            this.setLanguage(languageNode);
+        }
+        this.languageChunkWrapper = chunk;
+
+    }
+
+    protected setLanguage(languageNode: LionWebJsonNode) {
+        // Assume LwNode is a concept of type "Language"
+        const nameProp = languageNode.properties.find(prop => prop.property.key === LION_CORE_BUILTINS_INAMED_NAME);
+        const versionProp = languageNode.properties.find(prop => prop.property.key === "Language-version");
+        const keyProp = languageNode.properties.find(prop => prop.property.key === "IKeyed-key");
+        this.languageId = {
+            name: nameProp?.value,
+            version: versionProp?.value,
+            key: keyProp?.value
+        }
+    }
+
+    /**
+     * Store the node `node` under `key`.
+     * @param key
+     * @param node
+     */
+    setNodeByKey(key: string, node: LionWebJsonNode): void {
+        this.nodeKeymap.set(key, node);
+    }
+
+    getNodeByKey(key: string): LionWebJsonNode | undefined {
+        return this.nodeKeymap.get(key);
+    }
+
+    getNodeByMetaPointer(metaPointer: LionWebJsonMetaPointer): LionWebJsonNode | undefined {
+        // console.log("get metapointer " + JSON.stringify(metaPointer))
+        const result = this.languageChunkWrapper.jsonChunk.nodes.find(node => {
+            const keyProp = NodeUtils.findLwProperty(node, "IKeyed-key");
+            // const versionProp = NodeUtils.findLwProperty(node, "Language-version");
+            // return ((!!keyProp) && (keyProp.value === metaPointer.key) && (!!versionProp) && (versionProp.value === metaPointer.version));
+
+            // console.log("   getNodeByMetaPointer.looking into " + node.id + " found " + JSON.stringify(keyProp));
+            return ((!!keyProp) && (keyProp.value === metaPointer.key) );
+        });
+        return result;
+    }
+
+    getPropertyByKey(key: string) {
+        // console.log("get property by key " + key)
+        const propertyNode = this.languageChunkWrapper.findNodesOfConcept("Property").find(n => {
+            // console.log("   getPropertyByKey.looking into " + n.id);
+            const keyProp = (n as LionWebJsonNode).properties.find(prop => {
+                return prop.property.key === "IKeyed-key" && prop.value === key;
+            });
+            return keyProp;
+        });
+        return propertyNode;
+    }
+
+    getConceptByKey(key: string) {
+        // console.log("get property by key " + key)
+        const conceptNode = this.languageChunkWrapper.findNodesOfConcept("Concept").find(n => {
+            // console.log("   looking into " + JSON.stringify(n));
+            const keyProp = (n as LionWebJsonNode).properties.find(prop => {
+                return prop.property.key === "IKeyed-key" && prop.value === key;
+            });
+            return keyProp;
+        });
+        return conceptNode;
+    }
+}

package/src/json/NodeUtils.ts

@@ -0,0 +1,72 @@
+import {
+    LionWebJsonChild,
+    LionWebJsonNode,
+    LionWebJsonProperty,
+    LionWebJsonReference,
+    LionWebJsonReferenceTarget
+} from "./LionWebJson";
+
+/**
+ * Utility functions for LionWebJsonNode's
+ */
+export class NodeUtils {
+    /**
+     * Find property with key equals `key` in `node`.
+     * @param node
+     * @param key
+     */
+    static findLwProperty(node: LionWebJsonNode, key: string): LionWebJsonProperty | null {
+        for (const property of node.properties) {
+            if (property.property.key === key) {
+                return property;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Find containment child with key equals `key` in `node`.
+     * @param node
+     * @param key
+     */
+    static findLwChild(node: LionWebJsonNode, key: string): LionWebJsonChild | null {
+        for (const containment of node.containments) {
+            if (containment.containment.key === key) {
+                return containment;
+            }
+        }
+        return null;
+    }
+
+    static findLwReference(node: LionWebJsonNode, key: string): LionWebJsonReference | null {
+        for (const reference of node.references) {
+            if (reference.reference.key === key) {
+                return reference;
+            }
+        }
+        return null;
+    }
+
+    static findLwReferenceTarget(lwReferenceTargets: LionWebJsonReferenceTarget[], target: LionWebJsonReferenceTarget): LionWebJsonReferenceTarget | null {
+        for (const refTarget of lwReferenceTargets) {
+            if (refTarget.reference === target.reference && refTarget.resolveInfo === target.resolveInfo) {
+                return refTarget;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Get all nodes that are children for `node`: both the containment and annotaion children
+     * @param node
+     */
+    static allChildren(node: LionWebJsonNode): string[] {
+        const result: string[] = [];
+        for (const containment of node.containments) {
+            result.push(...containment.children);
+        }
+        result.push(...node.annotations);
+        return result;
+    }
+
+}