clarity-pattern-parser 10.3.7 → 11.0.0

package/src/patterns/FiniteRepeat.ts

@@ -3,6 +3,8 @@ import { Cursor } from "./Cursor";
 import { findPattern } from "./findPattern";
 import { ParseResult } from "./ParseResult";
 import { Pattern } from "./Pattern";
+import { testPattern } from './testPattern';
+import { execPattern } from "./execPattern";
 
 let idIndex = 0;
 
@@ -25,8 +27,6 @@ export class FiniteRepeat implements Pattern {
     private _trimDivider: boolean;
     private _firstIndex: number;
 
-    shouldCompactAst = false;
-
     get id() {
         return this._id;
     }
@@ -152,30 +152,15 @@ export class FiniteRepeat implements Pattern {
 
         const node = new Node(this._type, this.name, firstIndex, lastIndex, nodes);
 
-        if (this.shouldCompactAst) {
-            node.compact();
-        }
-
         return node;
     }
 
-    test(text: string): boolean {
-        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);
     }
 
     clone(name = this._name): Pattern {
@@ -194,8 +179,6 @@ export class FiniteRepeat implements Pattern {
         );
 
         clone._id = this._id;
-        clone.shouldCompactAst = this.shouldCompactAst;
-
         return clone;
     }
 

package/src/patterns/InfiniteRepeat.ts

@@ -1,9 +1,10 @@
 import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
 import { Pattern } from "./Pattern";
-import { clonePatterns } from "./clonePatterns";
 import { findPattern } from "./findPattern";
 import { ParseResult } from "./ParseResult";
+import { execPattern } from "./execPattern";
+import { testPattern } from "./testPattern";
 
 let idIndex = 0;
 
@@ -26,8 +27,6 @@ export class InfiniteRepeat implements Pattern {
   private _min: number;
   private _trimDivider: boolean;
 
-  shouldCompactAst = false;
-
   get id(): string {
     return this._id;
   }
@@ -56,7 +55,7 @@ export class InfiniteRepeat implements Pattern {
     return this._min;
   }
 
-  get startedOnIndex(){
+  get startedOnIndex() {
     return this._firstIndex;
   }
 
@@ -92,23 +91,13 @@ export class InfiniteRepeat 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): Node | null {
@@ -125,9 +114,6 @@ export class InfiniteRepeat implements Pattern {
         cursor.moveTo(node.lastIndex);
         cursor.recordMatch(this, node);
 
-        if (this.shouldCompactAst) {
-          node.compact();
-        }
       }
 
       return node;
@@ -362,7 +348,6 @@ export class InfiniteRepeat implements Pattern {
     );
 
     clone._id = this._id;
-    clone.shouldCompactAst = this.shouldCompactAst;
 
     return clone;
   }

package/src/patterns/Literal.ts

@@ -2,6 +2,8 @@ import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
 import { ParseResult } from "./ParseResult";
 import { Pattern } from "./Pattern";
+import { execPattern } from "./execPattern";
+import { testPattern } from "./testPattern";
 
 let idIndex = 0;
 
@@ -16,8 +18,6 @@ export class Literal implements Pattern {
   private _lastIndex: number;
   private _endIndex: number;
 
-  shouldCompactAst = false;
-
   get id(): string {
     return this._id;
   }
@@ -66,25 +66,12 @@ export class Literal implements Pattern {
     this._endIndex = 0;
   }
 
-  test(text: string, record = false) {
-    const cursor = new Cursor(text);
-    record && cursor.startRecording();
-
-    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 {
@@ -147,7 +134,6 @@ export class Literal implements Pattern {
   clone(name = this._name): Pattern {
     const clone = new Literal(name, this._token);
     clone._id = this._id;
-    clone.shouldCompactAst = this.shouldCompactAst;
     return clone;
   }
 

package/src/patterns/Not.ts

@@ -2,6 +2,8 @@ import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
 import { ParseResult } from "./ParseResult";
 import { Pattern } from "./Pattern";
+import { execPattern } from "./execPattern";
+import { testPattern } from "./testPattern";
 
 let idIndex = 0;
 
@@ -12,8 +14,6 @@ export class Not implements Pattern {
   private _parent: Pattern | null;
   private _children: Pattern[];
 
-  shouldCompactAst = false;
-
   get id(): string {
     return this._id;
   }
@@ -51,23 +51,12 @@ export class Not implements Pattern {
     this._children[0].parent = this;
   }
 
-  test(text: string) {
-    const cursor = new Cursor(text);
-    this.parse(cursor);
-
-    return !cursor.hasError;
+  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 {

package/src/patterns/Optional.ts

@@ -12,8 +12,6 @@ export class Optional implements Pattern {
   private _parent: Pattern | null;
   private _children: Pattern[];
 
-  shouldCompactAst = false;
-
   get id(): string {
     return this._id;
   }
@@ -80,10 +78,6 @@ export class Optional implements Pattern {
 
       return null;
     } else {
-      if (node != null && this.shouldCompactAst) {
-        node.compact();
-      }
-
       return node;
     }
 
@@ -92,7 +86,6 @@ export class Optional implements Pattern {
   clone(name = this._name): Pattern {
     const clone = new Optional(name, this._children[0]);
     clone._id = this._id;
-    clone.shouldCompactAst = this.shouldCompactAst;
     return clone;
   }
 

package/src/patterns/Options.ts

@@ -5,6 +5,8 @@ import { clonePatterns } from "./clonePatterns";
 import { findPattern } from "./findPattern";
 import { ParseResult } from "./ParseResult";
 import { isRecursivePattern } from "./isRecursivePattern";
+import { execPattern } from "./execPattern";
+import { testPattern } from "./testPattern";
 
 let idIndex = 0;
 
@@ -17,8 +19,6 @@ export class Options implements Pattern {
   private _isGreedy: boolean;
   private _firstIndex: number;
 
-  shouldCompactAst = false;
-
   get id(): string {
     return this._id;
   }
@@ -70,23 +70,12 @@ export class Options 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): Node | null {
@@ -97,10 +86,6 @@ export class Options implements Pattern {
       cursor.moveTo(node.lastIndex);
       cursor.resolveError();
 
-      if (this.shouldCompactAst) {
-        node.compact();
-      }
-
       return node;
     }
 
@@ -221,7 +206,6 @@ export class Options implements Pattern {
   clone(name = this._name): Pattern {
     const clone = new Options(name, this._children, this._isGreedy);
     clone._id = this._id;
-    clone.shouldCompactAst = this.shouldCompactAst;
     return clone;
   }
 

package/src/patterns/Pattern.ts

@@ -6,7 +6,6 @@ export interface Pattern {
   id: string;
   type: string;
   name: string;
-  shouldCompactAst: boolean;
   startedOnIndex: number;
   parent: Pattern | null;
   children: Pattern[];

package/src/patterns/PrecedenceTree.test.ts

@@ -0,0 +1,162 @@
+import { PrecedenceTree } from "./PrecedenceTree";
+import { Node } from "../ast/Node";
+
+describe("Precedence Tree", () => {
+    test("add Binary", () => {
+        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", "||", "||"));
+        tree.addAtom(Node.createValueNode("literal", "d", "d"));
+        tree.addBinary("add", Node.createValueNode("literal", "+", "+"));
+        tree.addAtom(Node.createValueNode("literal", "e", "e"));
+
+        const result = tree.commit();
+        const expected = Node.createNode("expression", "bool", [
+            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"),
+                ]),
+            ]),
+            Node.createValueNode("literal", "||", "||"),
+            Node.createNode("expression", "add", [
+                Node.createValueNode("literal", "d", "d"),
+                Node.createValueNode("literal", "+", "+"),
+                Node.createValueNode("literal", "e", "e"),
+            ]),
+        ]);
+
+
+        expect(result?.toString()).toBe("a+b*c||d+e");
+        expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
+    });
+
+    test("add Prefix", () => {
+        const tree = new PrecedenceTree();
+
+        tree.addPrefix("negate", Node.createValueNode("literal", "!", "!"));
+        tree.addPrefix("increment", Node.createValueNode("literal", "++", "++"));
+        tree.addPrefix("plus", Node.createValueNode("literal", "+", "+"));
+        tree.addAtom(Node.createValueNode("literal", "a", "a"));
+
+        let result = tree.commit();
+        const expected = Node.createNode("expression", "negate", [
+            Node.createValueNode("literal", "!", "!"),
+            Node.createNode("expression", "increment", [
+                Node.createValueNode("literal", "++", "++"),
+                Node.createNode("expression", "plus", [
+                    Node.createValueNode("literal", "+", "+"),
+                    Node.createValueNode("literal", "a", "a"),
+                ]),
+            ]),
+        ]);
+
+        expect(result?.toString()).toBe("!+++a");
+        expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
+    });
+
+    test("add Postfix", () => {
+        const tree = new PrecedenceTree();
+
+        tree.addPostfix("decrement", Node.createValueNode("literal", "--", "--"));
+        tree.addPostfix("increment", Node.createValueNode("literal", "++", "++"));
+        tree.addAtom(Node.createValueNode("literal", "a", "a"));
+
+        const expected = Node.createNode("expression", "increment", [
+            Node.createNode("expression", "decrement", [
+                Node.createValueNode("literal", "a", "a"),
+                Node.createValueNode("literal", "--", "--"),
+            ]),
+            Node.createValueNode("literal", "++", "++"),
+        ]);
+
+        const result = tree.commit();
+        expect(result?.toString()).toBe("a--++");
+        expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
+    });
+
+    test("all", () => {
+        const tree = new PrecedenceTree({
+            mul: 0,
+            add: 1,
+            bool: 2
+        }, {});
+
+        tree.addPrefix("negate", Node.createValueNode("literal", "!", "!"));
+        tree.addPostfix("increment", Node.createValueNode("literal", "++", "++"));
+        tree.addAtom(Node.createValueNode("literal", "a", "a"));
+        tree.addBinary("mul", Node.createValueNode("literal", "*", "*"));
+        tree.addAtom(Node.createValueNode("literal", "b", "b"));
+        tree.addBinary("add", Node.createValueNode("literal", "+", "+"));
+        tree.addAtom(Node.createValueNode("literal", "c", "c"));
+
+        const result = tree.commit();
+        const expected = Node.createNode("expression", "add", [
+            Node.createNode("expression", "mul", [
+                Node.createNode("expression", "increment", [
+                    Node.createNode("expression", "negate", [
+                        Node.createValueNode("literal", "!", "!"),
+                        Node.createValueNode("literal", "a", "a"),
+                    ]),
+                    Node.createValueNode("literal", "++", "++"),
+                ]),
+                Node.createValueNode("literal", "*", "*"),
+                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("Incomplete", () => {
+        const tree = new PrecedenceTree({
+            mul: 0,
+            add: 1,
+            bool: 2
+        }, {});
+
+        tree.addPrefix("negate", Node.createValueNode("literal", "!", "!"));
+        tree.addPostfix("increment", Node.createValueNode("literal", "++", "++"));
+        tree.addAtom(Node.createValueNode("literal", "a", "a"));
+        tree.addBinary("mul", Node.createValueNode("literal", "*", "*"));
+        tree.addAtom(Node.createValueNode("literal", "b", "b"));
+        tree.addBinary("add", 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.createNode("expression", "mul", [
+                Node.createNode("expression", "increment", [
+                    Node.createNode("expression", "negate", [
+                        Node.createValueNode("literal", "!", "!"),
+                        Node.createValueNode("literal", "a", "a"),
+                    ]),
+                    Node.createValueNode("literal", "++", "++"),
+                ]),
+                Node.createValueNode("literal", "*", "*"),
+                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());
+    });
+});