clarity-pattern-parser 11.0.3 → 11.0.4

package/dist/patterns/PrecedenceTree.d.ts

@@ -11,9 +11,9 @@ export declare class PrecedenceTree {
     private _binaryPlaceholder;
     private _binaryNode;
     private _atomNode;
-    private _orphanedAtom;
     private _precedenceMap;
     private _associationMap;
+    private _revertBinary;
     constructor(precedenceMap?: Record<string, number>, associationMap?: Record<string, Association>);
     addPrefix(name: string, ...prefix: Node[]): void;
     addPostfix(name: string, ...postfix: Node[]): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "11.0.3",
+  "version": "11.0.4",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",

package/src/patterns/PrecedenceTree.test.ts

@@ -1,4 +1,4 @@
-import { PrecedenceTree } from "./PrecedenceTree";
+import { Association, PrecedenceTree } from "./PrecedenceTree";
 import { Node } from "../ast/Node";
 
 describe("Precedence Tree", () => {
@@ -159,4 +159,116 @@ describe("Precedence Tree", () => {
         expect(result?.toString()).toBe("!a++*b+c");
         expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
     });
+
+    test("add Partial Binary With Lower Precedence", () => {
+        const tree = new PrecedenceTree({
+            mul: 0,
+            add: 1,
+            bool: 2
+        }, {});
+
+        tree.addAtom(Node.createValueNode("literal", "a", "a"));
+        tree.addBinary("add", Node.createValueNode("literal", "+", "+"));
+        tree.addAtom(Node.createValueNode("literal", "b", "b"));
+        tree.addBinary("mul", Node.createValueNode("literal", "*", "*"));
+        tree.addAtom(Node.createValueNode("literal", "c", "c"));
+        tree.addBinary("bool", Node.createValueNode("literal", "||", "||"));
+
+        const result = tree.commit();
+        const expected = Node.createNode("expression", "add", [
+            Node.createValueNode("literal", "a", "a"),
+            Node.createValueNode("literal", "+", "+"),
+            Node.createNode("expression", "mul", [
+                Node.createValueNode("literal", "b", "b"),
+                Node.createValueNode("literal", "*", "*"),
+                Node.createValueNode("literal", "c", "c"),
+            ]),
+        ]);
+
+
+        expect(result?.toString()).toBe("a+b*c");
+        expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
+    });
+
+    test("add Partial Binary With Equal Precedence", () => {
+        const tree = new PrecedenceTree({
+            mul: 0,
+            add: 1,
+            bool: 2
+        }, {});
+
+        tree.addAtom(Node.createValueNode("literal", "a", "a"));
+        tree.addBinary("add", Node.createValueNode("literal", "+", "+"));
+        tree.addAtom(Node.createValueNode("literal", "b", "b"));
+        tree.addBinary("mul", Node.createValueNode("literal", "*", "*"));
+        tree.addAtom(Node.createValueNode("literal", "c", "c"));
+        tree.addBinary("mul", Node.createValueNode("literal", "*", "*"));
+
+        const result = tree.commit();
+        const expected = Node.createNode("expression", "add", [
+            Node.createValueNode("literal", "a", "a"),
+            Node.createValueNode("literal", "+", "+"),
+            Node.createNode("expression", "mul", [
+                Node.createValueNode("literal", "b", "b"),
+                Node.createValueNode("literal", "*", "*"),
+                Node.createValueNode("literal", "c", "c"),
+            ]),
+        ]);
+
+        expect(result?.toString()).toBe("a+b*c");
+        expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
+    });
+
+    test("add Partial Binary With Equal Precedence And Right Associated", () => {
+        const tree = new PrecedenceTree({
+            mul: 0,
+            add: 1,
+            bool: 2
+        }, { mul: Association.right });
+
+        tree.addAtom(Node.createValueNode("literal", "a", "a"));
+        tree.addBinary("add", Node.createValueNode("literal", "+", "+"));
+        tree.addAtom(Node.createValueNode("literal", "b", "b"));
+        tree.addBinary("mul", Node.createValueNode("literal", "*", "*"));
+        tree.addAtom(Node.createValueNode("literal", "c", "c"));
+        tree.addBinary("mul", Node.createValueNode("literal", "*", "*"));
+
+        const result = tree.commit();
+        const expected = Node.createNode("expression", "add", [
+            Node.createValueNode("literal", "a", "a"),
+            Node.createValueNode("literal", "+", "+"),
+            Node.createNode("expression", "mul", [
+                Node.createValueNode("literal", "b", "b"),
+                Node.createValueNode("literal", "*", "*"),
+                Node.createValueNode("literal", "c", "c"),
+            ]),
+        ]);
+
+        expect(result?.toString()).toBe("a+b*c");
+        expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
+    });
+
+    test("add Partial Binary With Greater Precedence", () => {
+        const tree = new PrecedenceTree({
+            mul: 0,
+            add: 1,
+            bool: 2
+        }, {});
+
+        tree.addAtom(Node.createValueNode("literal", "a", "a"));
+        tree.addBinary("add", Node.createValueNode("literal", "+", "+"));
+        tree.addAtom(Node.createValueNode("literal", "b", "b"));
+        tree.addBinary("mul", Node.createValueNode("literal", "*", "*"));
+
+
+        const result = tree.commit();
+        const expected = Node.createNode("expression", "add", [
+            Node.createValueNode("literal", "a", "a"),
+            Node.createValueNode("literal", "+", "+"),
+            Node.createValueNode("literal", "b", "b"),
+        ]);
+
+        expect(result?.toString()).toBe("a+b");
+        expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
+    });
 });

package/src/patterns/PrecedenceTree.ts

@@ -13,9 +13,9 @@ export class PrecedenceTree {
     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>;
+    private _revertBinary: () => void;
 
     constructor(precedenceMap: Record<string, number> = {}, associationMap: Record<string, Association> = {}) {
         this._prefixPlaceholder = Node.createNode("placeholder", "prefix-placeholder");
@@ -25,9 +25,9 @@ export class PrecedenceTree {
         this._binaryPlaceholder = Node.createNode("placeholder", "binary-placeholder");
         this._atomNode = null;
         this._binaryNode = null;
-        this._orphanedAtom = null;
         this._precedenceMap = precedenceMap;
         this._associationMap = associationMap;
+        this._revertBinary = () => { };
     }
 
     addPrefix(name: string, ...prefix: Node[]) {
@@ -72,12 +72,17 @@ export class PrecedenceTree {
         }
 
         this._binaryPlaceholder.remove();
-        this._orphanedAtom = lastAtomNode;
 
         if (lastBinaryNode == null) {
             const node = Node.createNode("expression", name, [lastAtomNode, ...delimiterNode, this._binaryPlaceholder]);
 
             this._binaryNode = node;
+
+            this._revertBinary = () => {
+                lastAtomNode.remove();
+                this._binaryNode = lastAtomNode;
+            };
+
             return;
         }
 
@@ -86,6 +91,11 @@ export class PrecedenceTree {
 
             lastBinaryNode.appendChild(node);
 
+            this._revertBinary = () => {
+                node.replaceWith(lastAtomNode);
+                this._binaryNode = lastBinaryNode;
+            };
+
             this._binaryNode = node;
         } else if (precedence === lastPrecendece) {
             const node = Node.createNode("expression", name, []);
@@ -94,6 +104,13 @@ export class PrecedenceTree {
             lastBinaryNode.appendChild(lastAtomNode);
 
             node.append(lastBinaryNode, ...delimiterNode, this._binaryPlaceholder);
+
+            this._revertBinary = () => {
+                lastBinaryNode.remove();
+                node.replaceWith(lastBinaryNode);
+                this._binaryNode = lastBinaryNode;
+            };
+
             this._binaryNode = node;
         } else if (precedence > lastPrecendece) {
             let ancestor = lastBinaryNode.parent;
@@ -115,6 +132,12 @@ export class PrecedenceTree {
             root.replaceWith(node);
             node.append(root, ...delimiterNode, this._binaryPlaceholder);
 
+            this._revertBinary = () => {
+                root.remove();
+                node.replaceWith(root);
+                this._binaryNode = root;
+            };
+
             this._binaryNode = node;
 
 
@@ -122,6 +145,12 @@ export class PrecedenceTree {
             const node = Node.createNode("expression", name, [lastAtomNode, ...delimiterNode, this._binaryPlaceholder]);
             lastBinaryNode.appendChild(node);
 
+            this._revertBinary = () => {
+                lastAtomNode.remove();
+                node.replaceWith(lastAtomNode);
+                this._binaryNode = lastBinaryNode;
+            };
+
             this._binaryNode = node;
         }
 
@@ -171,7 +200,7 @@ export class PrecedenceTree {
         this._atomNode = node;
     }
 
-    hasAtom(){
+    hasAtom() {
         return this._atomNode != null;
     }
 
@@ -183,8 +212,8 @@ export class PrecedenceTree {
         const atomNode = this._compileAtomNode();
 
         if (atomNode == null) {
-            let root = this._binaryPlaceholder.findRoot();
-            this._binaryPlaceholder.parent?.replaceWith(this._orphanedAtom as Node);
+            this._revertBinary();
+            let root = this._binaryNode.findRoot();
             this.reset();
             return root;
         } else {
@@ -199,7 +228,6 @@ export class PrecedenceTree {
     private reset() {
         this._prefixNode = null;
         this._atomNode = null;
-        this._orphanedAtom = null;
         this._postfixNode = null;
         this._binaryNode = null;
     }