@lionweb/validation 0.6.13-beta.6 → 0.6.13-beta.7

package/src/diff/changes/NodeChange.ts

@@ -0,0 +1,63 @@
+import { JsonContext } from "../../issues/index.js"
+import { LionWebJsonMetaPointer, LionWebJsonNode } from "../../json/index.js"
+import { Change, ChangeType } from "./Change.js"
+
+export class NodeClassifierChanged extends Change {
+    readonly changeType: ChangeType = "NodeClassifierChanged"
+
+    constructor(
+        public context: JsonContext,
+        public node: LionWebJsonNode,
+        public oldClassifier: LionWebJsonMetaPointer,
+        public newClassifier: LionWebJsonMetaPointer,
+    ) {
+        super(context)
+    }
+
+    protected msg = () => `Object ${this.node.id} has classifier changed from ${this.oldClassifier.key} to ${this.newClassifier.key}`
+}
+
+export class ParentChanged extends Change {
+    readonly changeType = "ParentChanged"
+
+    constructor(
+        public context: JsonContext,
+        public node: LionWebJsonNode,
+        public beforeParentId: string | null,
+        public afterParentId: string | null,
+    ) {
+        super(context)
+    }
+
+    protected msg = () => `Node "${this.node.id}" changed parent from "${this.beforeParentId}" to "${this.afterParentId}`
+}
+
+export abstract class AnnotationChange extends Change {
+    constructor(
+        ctx: JsonContext,
+        public nodeBefore: LionWebJsonNode,
+        public nodeAfter: LionWebJsonNode,
+        public annotationId: string,
+        public index: number
+    ) {
+        super(ctx)
+    }
+}
+
+export class AnnotationRemoved extends AnnotationChange {
+    readonly changeType = "AnnotationRemoved"
+
+    protected msg = () => `Node "${this.nodeBefore.id}" removed annotation "${this.annotationId}"`
+}
+
+export class AnnotationAdded extends AnnotationChange {
+    readonly changeType = "AnnotationAdded"
+
+    protected msg = () => `Node "${this.nodeAfter.id}" added annotation "${this.annotationId}"`
+}
+
+
+export class AnnotationOrderChanged extends AnnotationChange {
+    readonly changeType = "AnnotationOrderChanged"
+    protected msg = () => `Node "${this.nodeAfter.id}" changed order of annotations`
+}

package/src/diff/changes/PropertyChange.ts

@@ -0,0 +1,31 @@
+import { JsonContext } from "../../issues/index.js"
+import { LionWebJsonMetaPointer, LionWebJsonNode } from "../../json/index.js"
+import { Change, Missing } from "./Change.js"
+
+
+export abstract class PropertyChange extends Change {
+    constructor(
+        public context: JsonContext,
+        public nodeId: string,
+        public property: LionWebJsonMetaPointer,
+        public oldValue: string | null,
+        public newValue: string | null,
+        public missing: Missing = Missing.NotMissing
+    ) {
+        super(context) 
+    }
+}
+
+export class PropertyValueChanged extends PropertyChange {
+    readonly changeType = "PropertyValueChanged"
+    protected msg = () => `Node "${this.nodeId} changed value of property "${this.property.key}" from "${this.oldValue}" to "${this.newValue}"`
+}
+
+export class PropertyAdded extends Change {
+    readonly changeType = "PropertyAdded";
+    constructor(ctx: JsonContext, public node: LionWebJsonNode, public property: LionWebJsonMetaPointer) {
+        super(ctx)
+    }
+
+    protected msg = () => `Node "${this.node.id}" containment added: "${JSON.stringify(this.property)}"`
+}

package/src/diff/changes/ReferenceChange.ts

@@ -0,0 +1,34 @@
+import { JsonContext } from "../../issues/index.js"
+import { LionWebJsonNode, LionWebJsonReference, LionWebJsonReferenceTarget } from "../../json/index.js"
+import { Change, Missing } from "./Change.js"
+
+export abstract class ReferenceChange extends Change {
+    constructor(
+        public context: JsonContext,
+        public node: LionWebJsonNode,
+        public beforeReference: LionWebJsonReference | undefined,
+        public afterReference: LionWebJsonReference | undefined,
+        public target: LionWebJsonReferenceTarget,
+        public missing = Missing.NotMissing
+    ) {
+        super(context)
+    }
+}
+
+export class TargetAdded extends ReferenceChange {
+    readonly changeType = "TargetAdded"
+    protected msg = () =>
+        `Node "${this.node.id}" added target "${this.target.reference}" to reference "${this?.afterReference?.reference?.key}"`
+}
+
+export class TargetRemoved extends ReferenceChange {
+    readonly changeType = "TargetRemoved"
+    protected msg = () =>
+        `Node "${this.node.id}" removed target "${this.target.reference}" from reference "${this?.beforeReference?.reference?.key}"`
+}
+
+export class TargetOrderChanged extends ReferenceChange {
+    readonly changeType = "TargetOrderChanged"
+    protected msg = () => `Node "${this.node.id}" changed order of targets in reference "${this.afterReference?.reference?.key}"`
+}
+

package/src/diff/changes/index.ts

@@ -0,0 +1,6 @@
+export * from "./Change.js"
+export * from "./ChunkChange.js"
+export * from "./ContainmentChange.js"
+export * from "./NodeChange.js"
+export * from "./PropertyChange.js"
+export * from "./ReferenceChange.js"

package/src/diff/index.ts

@@ -0,0 +1,3 @@
+export * from "./changes/index.js"
+export * from "./DiffResult.js"
+export * from "./LionWebJsonDiff.js"

package/src/index.ts

@@ -1,4 +1,7 @@
 export * from "./issues/index.js"
+export * from "./json/index.js"
 export * from "./validators/index.js"
+export * from "./diff/index.js"
 export * from "./runners/index.js"
 export * from "./languages/index.js"
+export * from "./util/graphs.js"

package/src/issues/LanguageIssues.ts

@@ -1,5 +1,5 @@
-import { LionWebJsonMetaPointer, LionWebJsonNode } from "@lionweb/json"
-import { JsonContext } from "@lionweb/json-utils"
+import { LionWebJsonMetaPointer, LionWebJsonNode } from "../json/LionWebJson.js"
+import { JsonContext } from "../json/JsonContext.js"
 import { ValidationIssue } from "./ValidationIssue.js"
 
 export class Language_PropertyValue_Issue extends ValidationIssue {
@@ -8,13 +8,13 @@ export class Language_PropertyValue_Issue extends ValidationIssue {
     constructor(
         context: JsonContext,
         public property: string,
-        public value: string | null,
-        public expectedType: string
+        public value: (string | null),
+        public expectedType: string,
     ) {
         super(context)
     }
 
-    msg = (): string => `Property "${this.property}" with value "${this.value}" is not of type "${this.expectedType}"`
+    msg = (): string => `Property  "${this.property}" with value "${this.value}" is not of type "${this.expectedType}"`
 }
 
 // Incorrect Meta Pointers
@@ -24,7 +24,7 @@ export abstract class Language_IncorrectMetaPointerType_Issue extends Validation
     constructor(
         context: JsonContext,
         public metaPointer: LionWebJsonMetaPointer,
-        public incorrectType: string
+        public incorrectType: string,
     ) {
         super(context)
     }
@@ -43,7 +43,7 @@ export abstract class Language_FeatureMetaPointerNotInClassifier_Issue extends V
     constructor(
         context: JsonContext,
         public featureMetaPointer: LionWebJsonMetaPointer,
-        public classifierPointer: LionWebJsonNode
+        public classifierPointer: LionWebJsonNode,
     ) {
         super(context)
     }
@@ -82,7 +82,7 @@ export abstract class Language_UnknownMetaPointer_Issue extends ValidationIssue
 
     constructor(
         context: JsonContext,
-        public metaPointer: LionWebJsonMetaPointer
+        public metaPointer: LionWebJsonMetaPointer,
     ) {
         super(context)
     }
@@ -112,7 +112,7 @@ export class NumberOfLanguagesUsed_Issue extends ValidationIssue {
     readonly issueType = "NumberOfLanguagesUsed"
     constructor(
         context: JsonContext,
-        public nrOfLanguages: number
+        public nrOfLanguages: number,
     ) {
         super(context)
     }
@@ -120,7 +120,9 @@ export class NumberOfLanguagesUsed_Issue extends ValidationIssue {
 }
 export class MissingM3Language_Issue extends ValidationIssue {
     readonly issueType = "MissingM3Language"
-    constructor(context: JsonContext) {
+    constructor(
+        context: JsonContext
+    ) {
         super(context)
     }
     msg = () => `Missing used language LionCore-M3`
@@ -129,7 +131,7 @@ export class NotLionCoreLanguageKey_Issue extends ValidationIssue {
     readonly issueType = "NotLionCoreLanguageKey"
     constructor(
         context: JsonContext,
-        public incorrectKey: string
+        public incorrectKey: string,
     ) {
         super(context)
     }
@@ -139,7 +141,7 @@ export class IncorrectLionCoreVersion_Issue extends ValidationIssue {
     readonly issueType = "IncorrectLionCoreVersion"
     constructor(
         context: JsonContext,
-        public incorrectVersion: string
+        public incorrectVersion: string,
     ) {
         super(context)
     }

package/src/issues/ReferenceIssues.ts

@@ -1,5 +1,5 @@
-import { LionWebId, LionWebJsonMetaPointer, LionWebJsonNode } from "@lionweb/json"
-import { JsonContext } from "@lionweb/json-utils"
+import { LionWebJsonMetaPointer, LionWebJsonNode } from "../json/LionWebJson.js"
+import { JsonContext } from "../json/JsonContext.js"
 import { ValidationIssue } from "./ValidationIssue.js"
 
 export class Reference_DuplicateNodeId_Issue extends ValidationIssue {
@@ -7,7 +7,7 @@ export class Reference_DuplicateNodeId_Issue extends ValidationIssue {
 
     constructor(
         context: JsonContext,
-        public nodeId: LionWebId
+        public nodeId: string,
     ) {
         super(context)
     }
@@ -21,7 +21,7 @@ export class Reference_ChildMissingInParent_Issue extends ValidationIssue {
     constructor(
         context: JsonContext,
         public child: LionWebJsonNode,
-        public parent: LionWebJsonNode
+        public parent: LionWebJsonNode,
     ) {
         super(context)
     }
@@ -35,7 +35,7 @@ export class Reference_ParentMissingInChild_Issue extends ValidationIssue {
     constructor(
         context: JsonContext,
         public parent: LionWebJsonNode,
-        public child: LionWebJsonNode
+        public child: LionWebJsonNode,
     ) {
         super(context)
     }
@@ -49,7 +49,7 @@ export class Reference_CirculairParent_Issue extends ValidationIssue {
     constructor(
         context: JsonContext,
         public node: LionWebJsonNode | undefined,
-        public parentPath: string[]
+        public parentPath: string[],
     ) {
         super(context)
     }
@@ -62,7 +62,7 @@ export class Reference_LanguageUnknown_Issue extends ValidationIssue {
 
     constructor(
         context: JsonContext,
-        public languageRef: LionWebJsonMetaPointer
+        public languageRef: LionWebJsonMetaPointer,
     ) {
         super(context)
     }
@@ -75,9 +75,9 @@ export class Duplicates_Issue extends ValidationIssue {
 
     constructor(
         context: JsonContext,
-        public nodeId: LionWebId
+        public nodeid: string,
     ) {
         super(context)
     }
-    msg = () => `Duplicate value "${this.nodeId}"`
+    msg = () => `Duplicate value "${this.nodeid}"`
 }

package/src/issues/SyntaxIssues.ts

@@ -1,10 +1,10 @@
-import { JsonContext } from "@lionweb/json-utils"
+import { JsonContext } from "../json/JsonContext.js"
 import { ValidationIssue } from "./ValidationIssue.js"
 
 export abstract class Syntax_PropertyIssue extends ValidationIssue {
     constructor(
         public context: JsonContext,
-        protected property: string
+        protected property: string,
     ) {
         super(context)
     }
@@ -32,7 +32,7 @@ export class Syntax_PropertyTypeIssue extends Syntax_PropertyIssue {
         context: JsonContext,
         property: string,
         protected expectedType: string,
-        protected actualType: string
+        protected actualType: string,
     ) {
         super(context, property)
     }
@@ -46,7 +46,7 @@ export class Syntax_ArrayContainsNull_Issue extends Syntax_PropertyIssue {
     constructor(
         context: JsonContext,
         property: string,
-        public index: number
+        public index: number,
     ) {
         super(context, property)
     }
@@ -57,7 +57,7 @@ export class Syntax_ArrayContainsNull_Issue extends Syntax_PropertyIssue {
 export abstract class Syntax_IncorrectFormat_Issue extends ValidationIssue {
     constructor(
         context: JsonContext,
-        public value: string
+        public value: string,
     ) {
         super(context)
     }

package/src/issues/ValidationIssue.ts

@@ -1,4 +1,4 @@
-import { JsonContext } from "@lionweb/json-utils"
+import { JsonContext } from "../json/JsonContext.js"
 
 export abstract class ValidationIssue {
     abstract readonly issueType: string
@@ -17,13 +17,10 @@ export abstract class ValidationIssue {
 
 export class GenericIssue extends ValidationIssue {
     readonly issueType = "GenericIssue"
-
-    constructor(
-        context: JsonContext,
-        public text: string
-    ) {
+    
+    constructor(context: JsonContext, public text: string) {
         super(context)
     }
-
+    
     protected msg = () => this.text
 }

package/src/issues/index.ts

@@ -1,3 +1,4 @@
+export * from "../json/JsonContext.js"
 export * from "./ValidationIssue.js"
 export * from "./SyntaxIssues.js"
 export * from "./ReferenceIssues.js"

package/src/json/ChunkUtils.ts

@@ -0,0 +1,49 @@
+import { LionWebJsonChunk, LionWebJsonNode, LwJsonUsedLanguage } from "./LionWebJson.js"
+
+/**
+ * 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/JsonContext.ts

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

package/src/json/LionWebJson.ts

@@ -0,0 +1,80 @@
+import { LION_CORE_M3_KEY, LION_CORE_M3_VERSION } from "./M3definitions.js"
+
+/**
+ * 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 function isLionWebM3Language(language: LwJsonUsedLanguage): boolean {
+    return language.key === LION_CORE_M3_KEY && language.version === LION_CORE_M3_VERSION
+}
+export type LionWebId = string
+
+export type LionWebJsonMetaPointer = {
+    language: string
+    version: string
+    key: string             // key of concept, property, containment, referenve or property
+}
+
+export function isEqualMetaPointer(p1: LionWebJsonMetaPointer, p2: LionWebJsonMetaPointer): boolean {
+    return p1.key === p2.key && p1.version === p2.version && p1.language === p2.language
+}
+
+export function isEqualReferenceTarget(first: LionWebJsonReferenceTarget, second: LionWebJsonReferenceTarget): boolean {
+    return first.reference === second.reference && first.resolveInfo === second.resolveInfo
+}
+
+export type LionWebJsonChunk = {
+    serializationFormatVersion: string
+    languages: LwJsonUsedLanguage[]
+    nodes: LionWebJsonNode[]
+}
+
+export type LwJsonUsedLanguage = {
+    key: string
+    version: string
+}
+
+export type LionWebJsonNode = {
+    id: LionWebId
+    classifier: LionWebJsonMetaPointer
+    properties: LionWebJsonProperty[]
+    containments: LionWebJsonContainment[]
+    references: LionWebJsonReference[]
+    annotations: LionWebId[]
+    parent: (LionWebId | null)
+}
+
+export function createLwNode(): LionWebJsonNode {
+    return {
+        id: "",
+        classifier: { language: "", version: "", key: "" },
+        properties: [],
+        containments: [],
+        references: [],
+        annotations: [],
+        parent: null,
+    }
+}
+
+export type LionWebJsonProperty = {
+    property: LionWebJsonMetaPointer
+    value: (string | null)
+}
+
+export type LionWebJsonContainment = {
+    containment: LionWebJsonMetaPointer
+    children: LionWebId[]
+}
+
+export type LionWebJsonReference = {
+    reference: LionWebJsonMetaPointer
+    targets: LionWebJsonReferenceTarget[]
+}
+
+export type LionWebJsonReferenceTarget = {
+    resolveInfo: (string | null)
+    reference: LionWebId
+}

package/src/json/LionWebJsonChunkWrapper.ts

@@ -0,0 +1,136 @@
+import {
+    isEqualMetaPointer,
+    LionWebId,
+    LionWebJsonChunk,
+    LionWebJsonContainment,
+    LionWebJsonMetaPointer,
+    LionWebJsonNode,
+    LionWebJsonReference
+} from "./LionWebJson.js"
+import { MetaPointers } from "./M3definitions.js"
+import { NodeUtils } from "./NodeUtils.js"
+
+/**
+ * Wraps around a LionWebJsonChunk, providing access to information inside, might be using caches to improve performance.
+ * NB Make sure that the contents of the chunk are not changed after creating the wrapper!
+ * NB BE aware that with `pushChunk(...)` the original chunk will be changed.
+ */
+export class LionWebJsonChunkWrapper {
+    jsonChunk: LionWebJsonChunk
+    /**
+     * Map to get quick access to nodes by id.
+     * @protected
+     */
+    protected nodesIdMap: Map<LionWebId, LionWebJsonNode> = new Map<LionWebId, LionWebJsonNode>()
+
+    /**
+     * Create a wrapper with `chunk` as its chunk
+     * @param chunk
+     */
+    constructor(chunk: LionWebJsonChunk) {
+        this.jsonChunk = chunk
+        this.prepareNodeIds(chunk)
+    }
+
+    /** 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(chunk: LionWebJsonChunk) {
+        chunk.nodes.forEach(node => {
+            this.nodesIdMap.set(node.id, node)
+        })
+    }
+
+    getNode(id: string): LionWebJsonNode | undefined {
+        return this.nodesIdMap.get(id)
+    }
+
+    findNodesOfClassifier(concept: LionWebJsonMetaPointer): LionWebJsonNode[] {
+        return this.jsonChunk.nodes.filter(node => isEqualMetaPointer(node.classifier, concept))
+    }
+
+    /**
+     * Return the target nodes inside `reference` as a list of actual nodes (LionWebJsonNode[])
+     * @param reference
+     */
+    getReferredNodes(reference: LionWebJsonReference | undefined) {
+        if (reference === undefined) {
+            return []
+        }
+        const result = reference.targets.flatMap(target => {
+            if (target.reference === null) {
+                return []
+            } else {
+                const referredNode = this.getNode(target.reference)
+                return referredNode === undefined ? [] : [referredNode]
+            }
+        })
+        return result
+    }
+
+    /**
+     * Return the target nodes inside `reference` as a list of actual nodes (LionWebJsonNode[])
+     * @param reference
+     */
+    getChildrenAsNodes(containment: LionWebJsonContainment | undefined) {
+        if (containment === undefined) {
+            return []
+        }
+        const result: LionWebJsonNode[] = []
+        containment.children.forEach(ch => {
+            const childNode = this.getNode(ch)
+            if (childNode !== undefined) {
+                result.push(childNode)
+            }
+        })
+        return result
+    }
+
+    asString(): string {
+        let result = ""
+        const partitions = this.jsonChunk.nodes.filter(n => n.parent === null)
+        partitions.forEach(partition => {
+            const pString = this.recursiveToString(partition, 1)
+            result += pString
+        })
+        return result
+    }
+
+    private recursiveToString(node: LionWebJsonNode | undefined, depth: number): string {
+        if (node === undefined) {
+            return ""
+        }
+        let result: string = ""
+        const nameProperty = NodeUtils.findProperty(node, MetaPointers.INamedName)
+        const name = nameProperty === undefined ? "" : " " + nameProperty.value
+        result += this.indent(depth) + "(" + node.id + ")" + name + "\n"
+        if (node.annotations !== undefined && node.annotations.length !== 0) {
+            result += this.indent(depth + 1) + "*Annotations*" + "\n"
+            node.annotations.forEach(ann => {
+                result += this.recursiveToString(this.getNode(ann), depth + 1)
+                // result += this.indent(depth) + "[[" + JSON.stringify(ann) + "]]\n"
+            })
+        }
+        node.properties
+            .filter(p => p !== nameProperty)
+            .forEach(property => {
+                result += this.indent(depth + 1) + "*property* " + property.property.key + ": " + property.value + "\n"
+            })
+        node.references.forEach(ref => {
+            result += this.indent(depth + 1) + "*" + ref.reference.key + "*: " + JSON.stringify(ref.targets) + "\n"
+        })
+        node.containments.forEach(cont => {
+            if (cont.children.length !== 0) {
+                result += this.indent(depth + 1) + "*" + cont.containment.key + "*" + "\n"
+                cont.children.forEach(ch => {
+                    result += this.recursiveToString(this.getNode(ch), depth + 1)
+                })
+            }
+        })
+        return result
+    }
+
+    private indent(depth: number): string {
+        return Array(depth).join("    ")
+    }
+}