clarity-pattern-parser 10.3.7 → 11.0.0

package/src/patterns/PrecedenceTree.ts

@@ -0,0 +1,207 @@
+import { Node } from "../ast/Node";
+
+export enum Association {
+    left = 0,
+    right,
+}
+
+export class PrecedenceTree {
+    private _prefixPlaceholder: Node;
+    private _prefixNode: Node | null;
+    private _postfixPlaceholder: Node;
+    private _postfixNode: Node | null;
+    private _binaryPlaceholder: Node;
+    private _binaryNode: Node | null;
+    private _atomNode: Node | null;
+    private _orphanedAtom: Node | null;
+    private _precedenceMap: Record<string, number>;
+    private _associationMap: Record<string, Association>;
+
+    constructor(precedenceMap: Record<string, number> = {}, associationMap: Record<string, Association> = {}) {
+        this._prefixPlaceholder = Node.createNode("placeholder", "prefix-placeholder");
+        this._prefixNode = null;
+        this._postfixPlaceholder = Node.createNode("placeholder", "postfix-placeholder");
+        this._postfixNode = null;
+        this._binaryPlaceholder = Node.createNode("placeholder", "binary-placeholder");
+        this._atomNode = null;
+        this._binaryNode = null;
+        this._orphanedAtom = null;
+        this._precedenceMap = precedenceMap;
+        this._associationMap = associationMap;
+    }
+
+    addPrefix(name: string, ...prefix: Node[]) {
+        const lastPrefixNode = this._prefixNode;
+
+        if (lastPrefixNode == null) {
+            const node = Node.createNode("expression", name, [...prefix]);
+            this._prefixNode = node;
+            this._prefixNode.append(this._prefixPlaceholder);
+            return;
+        }
+
+        const node = Node.createNode("expression", name, [...prefix]);
+        this._prefixPlaceholder.replaceWith(node);
+        node.append(this._prefixPlaceholder);
+
+        this._prefixNode = node;
+    }
+
+    addPostfix(name: string, ...postfix: Node[]) {
+        const lastPostfixNode = this._postfixNode;
+
+        if (lastPostfixNode == null) {
+            const node = Node.createNode("expression", name, [this._postfixPlaceholder, ...postfix]);
+            this._postfixNode = node;
+            return;
+        }
+
+        const node = Node.createNode("expression", name, [lastPostfixNode, ...postfix]);
+        this._postfixNode = node;
+    }
+
+    addBinary(name: string, ...delimiterNode: Node[]) {
+        const lastBinaryNode = this._binaryNode;
+        const lastPrecendece = this._getPrecedenceFromNode(this._binaryNode);
+        const precedence = this._getPrecedence(name);
+        const association = this._associationMap[name];
+        const lastAtomNode = this._compileAtomNode();
+
+        if (lastAtomNode == null) {
+            throw new Error("Cannot add a binary without an atom node.");
+        }
+
+        this._binaryPlaceholder.remove();
+        this._orphanedAtom = lastAtomNode;
+
+        if (lastBinaryNode == null) {
+            const node = Node.createNode("expression", name, [lastAtomNode, ...delimiterNode, this._binaryPlaceholder]);
+
+            this._binaryNode = node;
+            return;
+        }
+
+        if (precedence === lastPrecendece && association === Association.right) {
+            const node = Node.createNode("expression", name, [lastAtomNode, ...delimiterNode, this._binaryPlaceholder]);
+
+            lastBinaryNode.appendChild(node);
+
+            this._binaryNode = node;
+        } else if (precedence === lastPrecendece) {
+            const node = Node.createNode("expression", name, []);
+
+            lastBinaryNode.replaceWith(node);
+            lastBinaryNode.appendChild(lastAtomNode);
+
+            node.append(lastBinaryNode, ...delimiterNode, this._binaryPlaceholder);
+            this._binaryNode = node;
+        } else if (precedence > lastPrecendece) {
+            let ancestor = lastBinaryNode.parent;
+            let root = lastBinaryNode;
+
+            while (ancestor != null) {
+                const nodePrecedence = this._precedenceMap[ancestor.name];
+
+                if (nodePrecedence > precedence) {
+                    break;
+                }
+                root = ancestor;
+                ancestor = ancestor.parent;
+            }
+
+            lastBinaryNode.appendChild(lastAtomNode);
+
+            const node = Node.createNode("expression", name, []);
+            root.replaceWith(node);
+            node.append(root, ...delimiterNode, this._binaryPlaceholder);
+
+            this._binaryNode = node;
+
+
+        } else {
+            const node = Node.createNode("expression", name, [lastAtomNode, ...delimiterNode, this._binaryPlaceholder]);
+            lastBinaryNode.appendChild(node);
+
+            this._binaryNode = node;
+        }
+
+    }
+
+    private _getPrecedenceFromNode(node: Node | null) {
+        if (node == null) {
+            return 0;
+        }
+
+        return this._getPrecedence(node.name);
+    }
+
+    private _getPrecedence(name: string) {
+        if (this._precedenceMap[name] != null) {
+            return this._precedenceMap[name];
+        }
+
+        return 0;
+    }
+
+    private _compileAtomNode() {
+        let node = this._atomNode;
+
+        if (this._prefixNode != null && this._atomNode != null) {
+            node = this._prefixNode;
+            this._prefixPlaceholder.replaceWith(this._atomNode);
+        }
+
+        if (this._postfixNode != null && node != null) {
+            this._postfixPlaceholder.replaceWith(node);
+            node = this._postfixNode;
+        }
+
+        this._prefixNode = null;
+        this._atomNode = null;
+        this._postfixNode = null;
+
+        if (node == null) {
+            return null;
+        }
+
+        return node.findRoot();
+    }
+
+    addAtom(node: Node) {
+        this._atomNode = node;
+    }
+
+    hasAtom(){
+        return this._atomNode != null;
+    }
+
+    commit() {
+        if (this._binaryNode == null) {
+            return this._compileAtomNode();
+        }
+
+        const atomNode = this._compileAtomNode();
+
+        if (atomNode == null) {
+            let root = this._binaryPlaceholder.findRoot();
+            this._binaryPlaceholder.parent?.replaceWith(this._orphanedAtom as Node);
+            this.reset();
+            return root;
+        } else {
+            this._binaryPlaceholder.replaceWith(atomNode);
+            const root = this._binaryNode.findRoot();
+            this.reset();
+            return root;
+        }
+
+    }
+
+    private reset() {
+        this._prefixNode = null;
+        this._atomNode = null;
+        this._orphanedAtom = null;
+        this._postfixNode = null;
+        this._binaryNode = null;
+    }
+
+}

package/src/patterns/Reference.ts

@@ -4,6 +4,8 @@ import { Pattern } from "./Pattern";
 import { findPattern } from "./findPattern";
 import { ParseResult } from "./ParseResult";
 import { Context } from "./Context";
+import { testPattern } from "./testPattern";
+import { execPattern } from "./execPattern";
 
 let idIndex = 0;
 
@@ -17,8 +19,6 @@ export class Reference implements Pattern {
   private _children: Pattern[];
   private _firstIndex: number;
 
-  shouldCompactAst = false;
-
   get id(): string {
     return this._id;
   }
@@ -58,23 +58,12 @@ export class Reference implements Pattern {
     this._firstIndex = 0;
   }
 
-  test(text: string) {
-    const cursor = new Cursor(text);
-    const ast = this.parse(cursor);
-
-    return ast?.value === text;
+  test(text: string, record = false): boolean {
+    return testPattern(this, text, record);
   }
 
   exec(text: string, record = false): ParseResult {
-    const cursor = new Cursor(text);
-    record && cursor.startRecording();
-
-    const ast = this.parse(cursor);
-
-    return {
-      ast: ast?.value === text ? ast : null,
-      cursor
-    };
+    return execPattern(this, text, record);
   }
 
   parse(cursor: Cursor): Node | null {
@@ -205,7 +194,6 @@ export class Reference implements Pattern {
   clone(name = this._name): Pattern {
     const clone = new Reference(name);
     clone._id = this._id;
-    clone.shouldCompactAst = this.shouldCompactAst;
 
     // Optimize future clones, by caching the pattern we already found.
     if (this._pattern != null) {

package/src/patterns/Regex.ts

@@ -2,6 +2,8 @@ import { Node } from "../ast/Node";
 import { Pattern } from "./Pattern";
 import { Cursor } from "./Cursor";
 import { ParseResult } from "./ParseResult";
+import { testPattern } from "./testPattern";
+import { execPattern } from "./execPattern";
 
 let idIndex = 0;
 
@@ -18,8 +20,6 @@ export class Regex implements Pattern {
   private _substring = "";
   private _tokens: string[] = [];
 
-  shouldCompactAst = false;
-
   get id(): string {
     return this._id;
   }
@@ -82,23 +82,12 @@ export class Regex implements Pattern {
     }
   }
 
-  test(text: string) {
-    const cursor = new Cursor(text);
-    const ast = this.parse(cursor);
-
-    return ast?.value === text;
+  test(text: string, record = false): boolean {
+    return testPattern(this, text, record);
   }
 
   exec(text: string, record = false): ParseResult {
-    const cursor = new Cursor(text);
-    record && cursor.startRecording();
-
-    const ast = this.parse(cursor);
-
-    return {
-      ast: ast?.value === text ? ast : null,
-      cursor
-    };
+    return execPattern(this, text, record);
   }
 
   parse(cursor: Cursor) {
@@ -152,7 +141,6 @@ export class Regex implements Pattern {
     const clone = new Regex(name, this._originalRegexString);
     clone._tokens = this._tokens.slice();
     clone._id = this._id;
-    clone.shouldCompactAst = this.shouldCompactAst;
 
     return clone;
   }

package/src/patterns/Repeat.ts

@@ -27,16 +27,6 @@ export class Repeat implements Pattern {
     private _pattern: Pattern;
     private _options: InternalRepeatOptions;
     private _children: Pattern[];
-    private _shouldCompactAst: boolean;
-
-    get shouldCompactAst() {
-        return this._shouldCompactAst;
-    }
-
-    set shouldCompactAst(value: boolean) {
-        this._shouldCompactAst = value;
-        this._repeatPattern.shouldCompactAst = value;
-    }
 
     get id() {
         return this._id;
@@ -70,7 +60,7 @@ export class Repeat implements Pattern {
         return this._options.max;
     }
 
-    get startedOnIndex(){
+    get startedOnIndex() {
         return this._repeatPattern.startedOnIndex;
     }
 
@@ -78,7 +68,6 @@ export class Repeat implements Pattern {
         this._id = `repeat-${idIndex++}`;
         this._pattern = pattern;
         this._parent = null;
-        this._shouldCompactAst = false;
         this._options = {
             ...options,
             min: options.min == null ? 1 : options.min,
@@ -112,7 +101,6 @@ export class Repeat implements Pattern {
         const clone = new Repeat(name, this._pattern, { ...this._options, min });
 
         clone._id = this._id;
-        clone.shouldCompactAst = this.shouldCompactAst;
         return clone;
     }
 

package/src/patterns/Sequence.ts

@@ -5,6 +5,9 @@ import { clonePatterns } from "./clonePatterns";
 import { filterOutNull } from "./filterOutNull";
 import { findPattern } from "./findPattern";
 import { isRecursivePattern } from "./isRecursivePattern";
+import { testPattern } from "./testPattern";
+import { execPattern } from "./execPattern";
+import { ParseResult } from "./ParseResult";
 
 let idIndex = 0;
 
@@ -17,8 +20,6 @@ export class Sequence implements Pattern {
   private _nodes: (Node | null)[];
   private _firstIndex: number;
 
-  shouldCompactAst = false;
-
   get id(): string {
     return this._id;
   }
@@ -70,23 +71,12 @@ export class Sequence implements Pattern {
     }
   }
 
-  test(text: string) {
-    const cursor = new Cursor(text);
-    const ast = this.parse(cursor);
-
-    return ast?.value === text;
+  test(text: string, record = false): boolean {
+    return testPattern(this, text, record);
   }
 
-  exec(text: string, record = false) {
-    const cursor = new Cursor(text);
-    record && cursor.startRecording();
-
-    const ast = this.parse(cursor);
-
-    return {
-      ast: ast?.value === text ? ast : null,
-      cursor
-    };
+  exec(text: string, record = false): ParseResult {
+    return execPattern(this, text, record);
   }
 
   parse(cursor: Cursor): Node | null {
@@ -99,10 +89,6 @@ export class Sequence implements Pattern {
 
       if (node !== null) {
         cursor.recordMatch(this, node);
-
-        if (this.shouldCompactAst) {
-          node.compact();
-        }
       }
 
       return node;
@@ -344,7 +330,6 @@ export class Sequence implements Pattern {
   clone(name = this._name): Pattern {
     const clone = new Sequence(name, this._children);
     clone._id = this._id;
-    clone.shouldCompactAst = this.shouldCompactAst;
 
     return clone;
   }

package/src/patterns/execPattern.ts

@@ -0,0 +1,16 @@
+import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
+import { Pattern } from "./Pattern";
+
+export function execPattern(pattern: Pattern, text: string, record = false): ParseResult {
+    const cursor = new Cursor(text);
+    record && cursor.startRecording();
+
+    const ast = pattern.parse(cursor);
+    const isMatch = ast?.value.length === text.length;
+
+    return {
+        ast: isMatch ? ast : null,
+        cursor
+    };
+}

package/src/patterns/testPattern.ts

@@ -0,0 +1,11 @@
+import { Cursor } from "./Cursor";
+import { Pattern } from "./Pattern";
+
+export function testPattern (pattern: Pattern, text: string, record = false): boolean{
+    const cursor = new Cursor(text);
+    record && cursor.startRecording();
+
+    const ast = pattern.parse(cursor);
+
+    return ast?.value.length === text.length;
+}