clarity-pattern-parser 8.4.14 → 9.0.0

package/src/patterns/InfiniteRepeat.test.ts

@@ -1,11 +1,13 @@
 import { Node } from "../ast/Node";
-import { And } from "./And";
+import { Sequence } from "./Sequence";
 import { Cursor } from "./Cursor";
 import { findPattern } from "./findPattern";
 import { Literal } from "./Literal";
 import { Pattern } from "./Pattern";
 import { Regex } from "./Regex";
 import { InfiniteRepeat } from "./InfiniteRepeat";
+import { arePatternsEqual } from "./arePatternsEqual";
+import { Optional } from "./Optional";
 
 describe("InfiniteRepeat", () => {
     test("Successful Parse", () => {
@@ -19,8 +21,8 @@ describe("InfiniteRepeat", () => {
             new Node("regex", "digit", 2, 2, [], "7"),
         ]);
 
-        expect(result).toEqual(expected)
-        expect(cursor.hasError).toBeFalsy()
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
     });
 
     test("Bounds", () => {
@@ -51,8 +53,8 @@ describe("InfiniteRepeat", () => {
         const cursor = new Cursor("John");
         const result = integer.parse(cursor);
 
-        expect(result).toBeNull()
-        expect(cursor.hasError).toBeTruthy()
+        expect(result).toBeNull();
+        expect(cursor.hasError).toBeTruthy();
     });
 
     test("Successful Parse With Divider", () => {
@@ -69,8 +71,8 @@ describe("InfiniteRepeat", () => {
             new Node("regex", "digit", 4, 4, [], "7"),
         ]);
 
-        expect(result).toEqual(expected)
-        expect(cursor.hasError).toBeFalsy()
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
     });
 
     test("Successful Parse Text Ends With Divider", () => {
@@ -87,8 +89,8 @@ describe("InfiniteRepeat", () => {
             new Node("regex", "digit", 4, 4, [], "7"),
         ]);
 
-        expect(result).toEqual(expected)
-        expect(cursor.hasError).toBeFalsy()
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
     });
 
     test("Successful Parse Trailing Comma", () => {
@@ -105,18 +107,18 @@ describe("InfiniteRepeat", () => {
             new Node("regex", "digit", 4, 4, [], "7"),
         ]);
 
-        expect(result).toEqual(expected)
-        expect(cursor.hasError).toBeFalsy()
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
     });
 
     test("Failed (Optional)", () => {
-        const digit = new Regex("digit", "\\d");
+        const digit = new Optional("optional-digit", new Regex("digit", "\\d"));
         const integer = new InfiniteRepeat("number", digit, { min: 0 });
         const cursor = new Cursor("John");
         const result = integer.parse(cursor);
 
-        expect(result).toBeNull()
-        expect(cursor.hasError).toBeFalsy()
+        expect(result).toBeNull();
+        expect(cursor.hasError).toBeFalsy();
     });
 
     test("Get Tokens", () => {
@@ -125,7 +127,7 @@ describe("InfiniteRepeat", () => {
         const tokens = manyA.getTokens();
         const expected = ["A"];
 
-        expect(tokens).toEqual(expected)
+        expect(tokens).toEqual(expected);
     });
 
     test("Get Tokens After With Bogus Pattern", () => {
@@ -134,7 +136,7 @@ describe("InfiniteRepeat", () => {
         const tokens = manyA.getTokensAfter(new Literal("bogus", "bogus"));
         const expected: string[] = [];
 
-        expect(tokens).toEqual(expected)
+        expect(tokens).toEqual(expected);
     });
 
     test("Get Tokens After With Divider", () => {
@@ -142,31 +144,31 @@ describe("InfiniteRepeat", () => {
         const b = new Literal("b", "B");
         const divider = new Literal("divider", ",");
         const manyA = new InfiniteRepeat("many-a", a, { divider });
-        const parent = new And("parent", [manyA, b]);
+        const parent = new Sequence("parent", [manyA, b]);
 
-        const clonedManyA = findPattern(parent, p => p.name == "many-a");
+        const clonedManyA = findPattern(parent, p => p.name === "many-a");
         let tokens = clonedManyA?.getTokensAfter(clonedManyA.children[0]);
         let expected = [",", "B"];
 
-        expect(tokens).toEqual(expected)
+        expect(tokens).toEqual(expected);
 
         tokens = clonedManyA?.getTokensAfter(clonedManyA.children[1]);
         expected = ["A"];
 
-        expect(tokens).toEqual(expected)
+        expect(tokens).toEqual(expected);
     });
 
     test("Get Tokens After Without Divider", () => {
         const a = new Literal("a", "A");
         const b = new Literal("b", "B");
         const manyA = new InfiniteRepeat("many-a", a);
-        const parent = new And("parent", [manyA, b]);
+        const parent = new Sequence("parent", [manyA, b]);
 
-        const clonedManyA = findPattern(parent, p => p.name == "many-a");
+        const clonedManyA = findPattern(parent, p => p.name === "many-a");
         const tokens = clonedManyA?.getTokensAfter(clonedManyA.children[0]);
         const expected = ["A", "B"];
 
-        expect(tokens).toEqual(expected)
+        expect(tokens).toEqual(expected);
     });
 
     test("Properties", () => {
@@ -175,7 +177,6 @@ describe("InfiniteRepeat", () => {
         expect(integer.type).toBe("infinite-repeat");
         expect(integer.name).toBe("integer");
         expect(integer.min).toBe(1);
-        expect(integer.isOptional).toBeFalsy()
         expect(integer.parent).toBeNull();
         expect(integer.children[0].name).toBe("digit");
     });
@@ -183,28 +184,28 @@ describe("InfiniteRepeat", () => {
     test("Exec", () => {
         const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
         const { ast: result } = integer.exec("B");
-        expect(result).toBeNull()
+        expect(result).toBeNull();
     });
 
     test("Test With Match", () => {
         const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
         const result = integer.test("1");
-        expect(result).toBeTruthy()
+        expect(result).toBeTruthy();
     });
 
     test("Test With No Match", () => {
         const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
         const result = integer.test("b");
-        expect(result).toBeFalsy()
+        expect(result).toBeFalsy();
     });
 
     test("Get Next Tokens", () => {
         const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
-        const parent = new And("parent", [integer, new Literal("pow", "!")]);
+        const parent = new Sequence("parent", [integer, new Literal("pow", "!")]);
         const integerClone = parent.find(p => p.name === "integer") as Pattern;
         const tokens = integerClone.getNextTokens();
 
-        expect(tokens).toEqual(["!"])
+        expect(tokens).toEqual(["!"]);
     });
 
     test("Get Next Tokens With Null Parents", () => {
@@ -227,12 +228,12 @@ describe("InfiniteRepeat", () => {
         const patterns = manyA.getPatterns();
         const expected = [manyA.find(p => p.name === "a")];
 
-        expect(patterns).toEqual(expected)
+        expect(patterns).toEqual(expected);
     });
 
     test("Get Next Patterns", () => {
         const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
-        const parent = new And("parent", [integer, new Literal("pow", "!")]);
+        const parent = new Sequence("parent", [integer, new Literal("pow", "!")]);
         const integerClone = parent.find(p => p.name === "integer") as Pattern;
         const powClone = parent.find(p => p.name === "pow") as Pattern;
         const patterns = integerClone.getNextPatterns();
@@ -249,26 +250,11 @@ describe("InfiniteRepeat", () => {
     });
 
     test("Clone With Custom Overrides", () => {
-        const numbers = new InfiniteRepeat("numbers", new Regex("number", "\\d"), { min: 0 });
+        const numbers = new InfiniteRepeat("numbers", new Regex("number", "\\d"), { min: 3, divider: new Literal("divider", "divider"), trimDivider: true });
         let clone = numbers.clone();
-        let expected = new InfiniteRepeat("numbers", new Regex("number", "\\d"), { min: 0 });
-
-        expect(clone).toEqual(expected);
-
-        clone = numbers.clone("cloned-numbers");
-        expected = new InfiniteRepeat("cloned-numbers", new Regex("number", "\\d"), { min: 0 });
-
-        expect(clone).toEqual(expected);
-
-        clone = numbers.clone("cloned-numbers", true);
-        expected = new InfiniteRepeat("cloned-numbers", new Regex("number", "\\d"), { min: 0 });
-
-        expect(clone).toEqual(expected);
-
-        clone = numbers.clone("cloned-numbers", false);
-        expected = new InfiniteRepeat("cloned-numbers", new Regex("number", "\\d"), { min: 1 });
+        let expected = new InfiniteRepeat("numbers", new Regex("number", "\\d"), { min: 3, divider: new Literal("divider", "divider"), trimDivider: true });
 
-        expect(clone).toEqual(expected);
+        expect(arePatternsEqual(clone, expected)).toBeTruthy();
     });
 
     test("No Results, min is 0", () => {
@@ -276,6 +262,7 @@ describe("InfiniteRepeat", () => {
         const result = numbers.exec("j");
         expect(result.ast).toBeNull();
         expect(result.cursor.index).toBe(0);
+        expect(result.cursor.hasError).toBeTruthy();
     });
 
 

package/src/patterns/InfiniteRepeat.ts

@@ -3,6 +3,9 @@ import { Cursor } from "./Cursor";
 import { Pattern } from "./Pattern";
 import { clonePatterns } from "./clonePatterns";
 import { findPattern } from "./findPattern";
+import { ParseResult } from "./ParseResult";
+
+let idIndex = 0;
 
 export interface InfiniteRepeatOptions {
   divider?: Pattern;
@@ -11,6 +14,7 @@ export interface InfiniteRepeatOptions {
 }
 
 export class InfiniteRepeat implements Pattern {
+  private _id: string;
   private _type: string;
   private _name: string;
   private _parent: Pattern | null;
@@ -22,6 +26,10 @@ export class InfiniteRepeat implements Pattern {
   private _min: number;
   private _trimDivider: boolean;
 
+  get id(): string {
+    return this._id;
+  }
+
   get type(): string {
     return this._type;
   }
@@ -42,27 +50,24 @@ export class InfiniteRepeat implements Pattern {
     return this._children;
   }
 
-  get isOptional(): boolean {
-    return this._min === 0;
-  }
-
   get min(): number {
     return this._min;
   }
 
   constructor(name: string, pattern: Pattern, options: InfiniteRepeatOptions = {}) {
-    const min = options.min != null ? options.min : 1;
+    const min = options.min != null ? Math.max(options.min, 1) : 1;
     const divider = options.divider;
     let children: Pattern[];
 
     if (divider != null) {
-      children = [pattern.clone(pattern.name, false), divider.clone(divider.name, false)]
+      children = [pattern.clone(), divider.clone()];
     } else {
-      children = [pattern.clone(pattern.name, false)]
+      children = [pattern.clone()];
     }
 
     this._assignChildrenToParent(children);
 
+    this._id = `infinite-repeat-${idIndex++}`;
     this._type = "infinite-repeat";
     this._name = name;
     this._min = min;
@@ -70,7 +75,7 @@ export class InfiniteRepeat implements Pattern {
     this._children = children;
     this._pattern = children[0];
     this._divider = children[1];
-    this._firstIndex = -1
+    this._firstIndex = -1;
     this._nodes = [];
     this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
   }
@@ -88,8 +93,10 @@ export class InfiniteRepeat implements Pattern {
     return ast?.value === text;
   }
 
-  exec(text: string) {
+  exec(text: string, record = false): ParseResult {
     const cursor = new Cursor(text);
+    record && cursor.startRecording();
+
     const ast = this.parse(cursor);
 
     return {
@@ -99,6 +106,8 @@ export class InfiniteRepeat implements Pattern {
   }
 
   parse(cursor: Cursor): Node | null {
+    cursor.startParseWith(this);
+
     this._firstIndex = cursor.index;
     this._nodes = [];
 
@@ -113,14 +122,17 @@ export class InfiniteRepeat implements Pattern {
         cursor.recordMatch(this, node);
       }
 
+      cursor.endParse();
       return node;
     }
 
     if (this._min > 0) {
+      cursor.endParse();
       return null;
     }
 
     cursor.resolveError();
+    cursor.endParse();
     return null;
   }
 
@@ -137,9 +149,14 @@ export class InfiniteRepeat implements Pattern {
 
     while (true) {
       const runningCursorIndex = cursor.index;
-      const repeatedNode = this._pattern.parse(cursor);
+      const repeatNode = this._pattern.parse(cursor);
+
+      const hasError = cursor.hasError;
+      const hasNoErrorAndNoResult = !cursor.hasError && repeatNode == null;
+      const hasDivider = this._divider != null;
+      const hasNoDivider = !hasDivider;
 
-      if (cursor.hasError) {
+      if (hasError) {
         const lastValidNode = this._getLastValidNode();
 
         if (lastValidNode != null) {
@@ -152,8 +169,13 @@ export class InfiniteRepeat implements Pattern {
 
         break;
       } else {
-        if (repeatedNode != null) {
-          this._nodes.push(repeatedNode);
+        if (hasNoErrorAndNoResult && hasNoDivider) {
+          // If we didn't match and didn't error we need to get out. Nothing different will happen.
+          break;
+        }
+
+        if (repeatNode != null) {
+          this._nodes.push(repeatNode);
 
           if (!cursor.hasNext()) {
             passed = true;
@@ -164,20 +186,31 @@ export class InfiniteRepeat implements Pattern {
         }
 
         if (this._divider != null) {
+          const dividerStartIndex = cursor.index;
           const dividerNode = this._divider.parse(cursor);
 
           if (cursor.hasError) {
             passed = true;
             break;
-          } else if (dividerNode != null) {
-            this._nodes.push(dividerNode);
-
-            if (!cursor.hasNext()) {
-              passed = true;
-              break;
+          } else {
+            if (dividerNode == null) {
+              cursor.moveTo(dividerStartIndex);
+
+              if (dividerNode == null && repeatNode == null) {
+                // If neither the repeat pattern or divider pattern matched get out. 
+                passed = true;
+                break;
+              }
+            } else {
+              this._nodes.push(dividerNode);
+
+              if (!cursor.hasNext()) {
+                passed = true;
+                break;
+              }
+
+              cursor.next();
             }
-
-            cursor.next();
           }
         }
       }
@@ -208,10 +241,10 @@ export class InfiniteRepeat implements Pattern {
       cursor.moveTo(dividerNode.firstIndex);
     }
 
-    // if (this._nodes.length === 0) {
-    //   cursor.moveTo(this._firstIndex);
-    //   return null;
-    // }
+    if (this._nodes.length === 0) {
+      cursor.moveTo(this._firstIndex);
+      return null;
+    }
 
     const lastIndex = this._nodes[this._nodes.length - 1].lastIndex;
     cursor.moveTo(lastIndex);
@@ -250,7 +283,7 @@ export class InfiniteRepeat implements Pattern {
 
   getNextTokens(): string[] {
     if (this._parent == null) {
-      return []
+      return [];
     }
 
     return this._parent.getTokensAfter(this);
@@ -303,25 +336,17 @@ export class InfiniteRepeat implements Pattern {
       return [];
     }
 
-    return this._parent.getPatternsAfter(this)
+    return this._parent.getPatternsAfter(this);
   }
 
   find(predicate: (p: Pattern) => boolean): Pattern | null {
     return findPattern(this, predicate);
   }
 
-  clone(name = this._name, isOptional?: boolean): Pattern {
+  clone(name = this._name): Pattern {
     let min = this._min;
 
-    if (isOptional != null) {
-      if (isOptional) {
-        min = 0
-      } else {
-        min = Math.max(this._min, 1);
-      }
-    }
-
-    return new InfiniteRepeat(
+    const clone = new InfiniteRepeat(
       name,
       this._pattern,
       {
@@ -330,6 +355,14 @@ export class InfiniteRepeat implements Pattern {
         trimDivider: this._trimDivider
       }
     );
+
+    clone._id = this._id;
+
+    return clone;
+  }
+
+  isEqual(pattern: InfiniteRepeat): boolean {
+    return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
   }
 }
 

package/src/patterns/Literal.test.ts

@@ -1,13 +1,13 @@
 import { Node } from "../ast/Node";
-import { And } from "./And";
+import { Sequence } from "./Sequence";
 import { Cursor } from "./Cursor";
 import { Literal } from "./Literal"
 
 describe("Literal", () => {
     test("Empty Value", () => {
         expect(() => {
-            new Literal("empty", "")
-        }).toThrowError()
+            new Literal("empty", "");
+        }).toThrowError();
     });
 
     test("Successful Parse", () => {
@@ -20,10 +20,10 @@ describe("Literal", () => {
         expect(result).toEqual(expected);
         expect(cursor.index).toBe(11);
         expect(cursor.error).toBeNull();
-        expect(cursor.leafMatch.node).toEqual(expected)
-        expect(cursor.leafMatch.pattern).toBe(literal)
-        expect(cursor.rootMatch.node).toEqual(expected)
-        expect(cursor.rootMatch.pattern).toBe(literal)
+        expect(cursor.leafMatch.node).toEqual(expected);
+        expect(cursor.leafMatch.pattern).toBe(literal);
+        expect(cursor.rootMatch.node).toEqual(expected);
+        expect(cursor.rootMatch.pattern).toBe(literal);
     });
 
     test("Failed Parse", () => {
@@ -36,7 +36,7 @@ describe("Literal", () => {
         expect(cursor.index).toBe(6);
         expect(cursor.error?.startIndex).toBe(0);
         expect(cursor.error?.endIndex).toBe(6);
-        expect(cursor.error?.pattern).toBe(literal)
+        expect(cursor.error?.pattern).toBe(literal);
     });
 
     test("Failed Parse Because End Of Text", () => {
@@ -49,18 +49,7 @@ describe("Literal", () => {
         expect(cursor.index).toBe(10);
         expect(cursor.error?.startIndex).toBe(0);
         expect(cursor.error?.endIndex).toBe(11);
-        expect(cursor.error?.pattern).toBe(literal)
-    });
-
-    test("Failed Parse (Optional)", () => {
-        const literal = new Literal("greeting", "Hello World!", true);
-
-        const cursor = new Cursor("Hello Saturn!");
-        const result = literal.parse(cursor);
-
-        expect(result).toEqual(null);
-        expect(cursor.index).toBe(0);
-        expect(cursor.error).toBeNull();
+        expect(cursor.error?.pattern).toBe(literal);
     });
 
     test("Clone", () => {
@@ -85,7 +74,7 @@ describe("Literal", () => {
         const tokens = literal.getTokensAfter(new Literal("bogus", "bogus"));
         const expected: string[] = [];
 
-        expect(tokens).toEqual(expected)
+        expect(tokens).toEqual(expected);
     });
 
     test("Properties", () => {
@@ -100,7 +89,7 @@ describe("Literal", () => {
     test("Exec", () => {
         const literal = new Literal("a", "A");
         const { ast: result } = literal.exec("B");
-        expect(result).toBeNull()
+        expect(result).toBeNull();
     });
 
     test("Test With No Match", () => {
@@ -118,8 +107,8 @@ describe("Literal", () => {
     });
 
     test("Get Next Tokens", () => {
-        const sequence = new And("sequence", [new Literal("a", "A")]);
-        const parent = new And("parent", [sequence, new Literal("b", "B")]);
+        const sequence = new Sequence("sequence", [new Literal("a", "A")]);
+        const parent = new Sequence("parent", [sequence, new Literal("b", "B")]);
 
         const a = parent.find(p => p.name === "a");
         const tokens = a?.getNextTokens() || [];
@@ -144,12 +133,12 @@ describe("Literal", () => {
     });
 
     test("Get Next Patterns", () => {
-        const sequence = new And("sequence", [new Literal("a", "A")]);
-        const parent = new And("parent", [sequence, new Literal("b", "B")]);
+        const sequence = new Sequence("sequence", [new Literal("a", "A")]);
+        const parent = new Sequence("parent", [sequence, new Literal("b", "B")]);
 
         const a = parent.find(p => p.name === "a");
         const nextPatterns = a?.getNextPatterns() || [];
-        const b = parent.find(p => p.name === "b")
+        const b = parent.find(p => p.name === "b");
 
         expect(nextPatterns[0]).toBe(b);
     });