clarity-pattern-parser 11.0.2 → 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/dist/patterns/RightAssociatedPattern.d.ts

@@ -0,0 +1,31 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
+import { Pattern } from "./Pattern";
+export declare class RightAssociatedPattern implements Pattern {
+    private _id;
+    private _type;
+    private _name;
+    private _parent;
+    private _children;
+    get id(): string;
+    get type(): string;
+    get name(): string;
+    get parent(): Pattern | null;
+    set parent(pattern: Pattern | null);
+    get children(): Pattern[];
+    get startedOnIndex(): number;
+    constructor(pattern: Pattern);
+    parse(cursor: Cursor): Node | null;
+    exec(text: string, record?: boolean | undefined): ParseResult;
+    test(text: string, record?: boolean | undefined): boolean;
+    clone(_name?: string | undefined): Pattern;
+    getTokens(): string[];
+    getTokensAfter(_childReference: Pattern): string[];
+    getNextTokens(): string[];
+    getPatterns(): Pattern[];
+    getPatternsAfter(_childReference: Pattern): Pattern[];
+    getNextPatterns(): Pattern[];
+    find(predicate: (pattern: Pattern) => boolean): Pattern | null;
+    isEqual(pattern: Pattern): boolean;
+}

package/package.json

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

package/src/grammar/Grammar.test.ts

@@ -584,4 +584,15 @@ describe("Grammar", () => {
         expect(result).toBe(result);
     });
 
+    test("Expression Pattern With Right Association", () => {
+        const { expression } = patterns`
+            variables = "a" | "b" | "c" | "d" | "e"
+            ternary = expression + " ? " + expression + " : " + expression
+            expression = ternary right | variables
+        `;
+        let result = expression.exec("a ? b : c ? d : e");
+        debugger;
+        expect(result).toBe(result);
+    });
+
 });

package/src/grammar/Grammar.ts

@@ -11,7 +11,8 @@ import { Repeat, RepeatOptions } from "../patterns/Repeat";
 import { AutoComplete } from "../intellisense/AutoComplete";
 import { Optional } from "../patterns/Optional";
 import { Context } from "../patterns/Context";
-import {ExpressionPattern} from "../patterns/ExpressionPattern";
+import { ExpressionPattern } from "../patterns/ExpressionPattern";
+import { RightAssociatedPattern } from "../patterns/RightAssociatedPattern";
 
 let anonymousIndexId = 0;
 
@@ -248,14 +249,22 @@ export class Grammar {
     private _buildOptions(name: string, node: Node) {
         const patternNodes = node.children.filter(n => n.name !== "default-divider" && n.name !== "greedy-divider");
         const isGreedy = node.find(n => n.name === "greedy-divider") != null;
-        const patterns = patternNodes.map(n => this._buildPattern(n));
-        const hasRecursivePattern = patterns.some(p=>this._isRecursive(name, p));
+        const patterns = patternNodes.map(n => {
+            const rightAssociated = n.find(n => n.name === "right-associated");
+            if (rightAssociated != null) {
+                return new RightAssociatedPattern(this._buildPattern(n.children[0]));
+            } else {
+                return this._buildPattern(n.children[0]);
+            }
 
-        if (hasRecursivePattern && !isGreedy){
+        });
+        
+        const hasRecursivePattern = patterns.some(p => this._isRecursive(name, p));
+        if (hasRecursivePattern && !isGreedy) {
             try {
                 const expression = new ExpressionPattern(name, patterns);
                 return expression;
-            } catch{}
+            } catch { }
         }
 
         const or = new Options(name, patterns, isGreedy);
@@ -271,10 +280,16 @@ export class Grammar {
     }
 
     private _isRecursivePattern(name: string, pattern: Pattern) {
-        return pattern.type === "sequence" &&
-            pattern.children[0].type === "reference" &&
-            pattern.children[0].name === name &&
-            pattern.children.length > 2;
+        if (pattern.children.length === 0){
+            return false;
+        }
+
+        const firstChild = pattern.children[0];
+        const lastChild = pattern.children[pattern.children.length - 1];
+        const isLongEnough = pattern.children.length >= 2;
+        return pattern.type === "sequence" && isLongEnough &&
+            (firstChild.type === "reference" && firstChild.name === name) ||
+            (lastChild.type === "reference" && lastChild.name === name);
     }
 
     private _buildPattern(node: Node): Pattern {

package/src/grammar/patterns/optionsLiteral.ts

@@ -3,11 +3,17 @@ import { Regex } from "../../patterns/Regex";
 import { name } from "./name";
 import { anonymousPattern } from "./anonymousPattern";
 import { Options } from "../../patterns/Options";
+import { Sequence } from "../../patterns/Sequence";
+import { Optional } from "../../patterns/Optional";
+import { Literal } from "../../patterns/Literal";
 
 const patternName = name.clone("pattern-name");
 patternName.setTokens(["[PATTERN_NAME]"]);
 
-const patterns = new Options("options-patterns", [patternName, anonymousPattern]);
+const patterns = new Sequence("patterns", [
+    new Options("options-patterns", [patternName, anonymousPattern]),
+    new Optional("optional-right-associated", new Literal("right-associated", " right"))
+]);
 const defaultDivider = new Regex("default-divider", "\\s*[|]\\s*");
 defaultDivider.setTokens(["|"]);
 

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;
     }

package/src/patterns/RightAssociatedPattern.ts

@@ -12,8 +12,6 @@ export class RightAssociatedPattern implements Pattern {
     private _parent: Pattern | null;
     private _children: Pattern[];
 
-    shouldCompactAst = false;
-
     get id(): string {
         return this._id;
     }