clarity-pattern-parser 8.4.14 → 9.0.0

package/src/patterns/FiniteRepeat.test.ts

@@ -3,12 +3,15 @@ import { Cursor } from "./Cursor";
 import { Regex } from "./Regex";
 import { Node } from "../ast/Node";
 import { Literal } from "./Literal";
-import { And } from "./And";
+import { Sequence } from "./Sequence";
+import { arePatternsEqual } from "./arePatternsEqual";
+import { Optional } from "./Optional";
 
 describe("BoundedRepeat", () => {
     test("Bounds Without Divider", () => {
-        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, {
-            min: 2
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), {
+            min: 2,
+            max: 3
         });
 
         let cursor = new Cursor("1");
@@ -62,7 +65,7 @@ describe("BoundedRepeat", () => {
     });
 
     test("Bounds Are Equal Without Divider", () => {
-        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { min: 3});
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), { min: 3, max: 3 });
 
         let cursor = new Cursor("1");
         let result = numbers.parse(cursor);
@@ -104,7 +107,7 @@ describe("BoundedRepeat", () => {
 
     test("Bounds With Divider", () => {
         const divider = new Literal("comma", ",");
-        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { divider, min: 2, trimDivider: true });
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), { divider, min: 2, max: 3, trimDivider: true });
 
         let cursor = new Cursor("1,");
         let result = numbers.parse(cursor);
@@ -151,9 +154,9 @@ describe("BoundedRepeat", () => {
     });
 
     test("Optional Repeating Pattern", () => {
-        const digit = new Regex("digit", "\\d+", true);
+        const digit = new Optional("optional-digit", new Regex("digit", "\\d+"));
         const divider = new Regex("divider", "\\s");
-        const integer = new FiniteRepeat("number", digit, 4, { divider });
+        const integer = new FiniteRepeat("number", digit, { divider, max: 4 });
         const cursor = new Cursor(
             "\n" +
             "3\n" +
@@ -169,13 +172,13 @@ describe("BoundedRepeat", () => {
             new Node("regex", "divider", 4, 4, [], "\n"),
         ]);
 
-        expect(result).toEqual(expected)
-        expect(cursor.hasError).toBeFalsy()
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
     });
 
     test("Bounds Are Equal With Divider", () => {
         const divider = new Literal("comma", ",");
-        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { divider, min: 3, trimDivider: true });
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), { divider, min: 3, max: 3, trimDivider: true });
 
         let cursor = new Cursor("1,");
         let result = numbers.parse(cursor);
@@ -218,14 +221,14 @@ describe("BoundedRepeat", () => {
     });
 
     test("Test", () => {
-        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3);
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), { max: 3 });
         const result = numbers.test("1");
 
         expect(result).toBeTruthy();
     });
 
     test("Exec", () => {
-        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3);
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), { max: 3 });
         const result = numbers.exec("1");
 
         expect(result.ast).not.toBeNull();
@@ -233,7 +236,7 @@ describe("BoundedRepeat", () => {
     });
 
     test("Fail", () => {
-        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3);
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), { max: 3 });
         const result = numbers.exec("f");
 
         expect(result.ast).toBeNull();
@@ -241,7 +244,7 @@ describe("BoundedRepeat", () => {
     });
 
     test("Optional", () => {
-        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { min: 0 });
+        const numbers = new FiniteRepeat("numbers", new Optional("optional-number", new Regex("number", "\\d")), { min: 0, max: 3 });
         const result = numbers.exec("f");
 
         expect(result.ast).toBeNull();
@@ -249,7 +252,7 @@ describe("BoundedRepeat", () => {
     });
 
     test("Optional With Multiple Matches But Still Below Min", () => {
-        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { min: 0 });
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), { min: 0, max: 3 });
         const result = numbers.exec("12f");
 
         expect(result.ast).toBeNull();
@@ -257,19 +260,18 @@ describe("BoundedRepeat", () => {
     });
 
     test("Properties", () => {
-        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { min: 0 });
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), { min: 1, max: 3 });
 
         expect(numbers.type).toBe("finite-repeat");
         expect(numbers.name).toBe("numbers");
         expect(numbers.parent).toBeNull();
         expect(numbers.children.length).toBe(3);
-        expect(numbers.min).toBe(0);
+        expect(numbers.min).toBe(1);
         expect(numbers.max).toBe(3);
-        expect(numbers.isOptional).toBeTruthy();
     });
 
     test("Clone", () => {
-        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { min: 0 });
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), { min: 0, max: 3 });
         const clone = numbers.clone() as FiniteRepeat;
 
         expect(clone.type).toBe(numbers.type);
@@ -278,40 +280,39 @@ describe("BoundedRepeat", () => {
         expect(clone.children.length).toBe(numbers.children.length);
         expect(clone.min).toBe(numbers.min);
         expect(clone.max).toBe(numbers.max);
-        expect(clone.isOptional).toBe(numbers.isOptional);
     });
 
     test("Clone With Custom Overrides", () => {
-        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { min: 0 });
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), { min: 0, max: 3 });
         let clone = numbers.clone();
-        let expected = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { min: 0 });
+        let expected = new FiniteRepeat("numbers", new Regex("number", "\\d"), { min: 0, max: 3 });
 
-        expect(clone).toEqual(expected);
+        expect(arePatternsEqual(clone, expected)).toBeTruthy();
 
         clone = numbers.clone("cloned-numbers");
-        expected = new FiniteRepeat("cloned-numbers", new Regex("number", "\\d"), 3, { min: 0 });
+        expected = new FiniteRepeat("cloned-numbers", new Regex("number", "\\d"), { min: 0, max: 3 });
 
-        expect(clone).toEqual(expected);
+        expect(arePatternsEqual(clone, expected)).toBeTruthy();
 
-        clone = numbers.clone("cloned-numbers", true);
-        expected = new FiniteRepeat("cloned-numbers", new Regex("number", "\\d"), 3, { min: 0 });
+        clone = numbers.clone("cloned-numbers");
+        expected = new FiniteRepeat("cloned-numbers", new Regex("number", "\\d"), { min: 0, max: 3 });
 
-        expect(clone).toEqual(expected);
+        expect(arePatternsEqual(clone, expected)).toBeTruthy();
 
-        clone = numbers.clone("cloned-numbers", false);
-        expected = new FiniteRepeat("cloned-numbers", new Regex("number", "\\d"), 3, { min: 1 });
+        clone = numbers.clone("cloned-numbers");
+        expected = new FiniteRepeat("cloned-numbers", new Regex("number", "\\d"), { min: 0, max: 3 });
 
-        expect(clone).toEqual(expected);
+        expect(arePatternsEqual(clone, expected)).toBeTruthy();
     });
 
     test("Get Tokens", () => {
         const numbers = new FiniteRepeat(
             "numbers",
             new Literal("one", "1"),
-            3,
             {
                 divider: new Literal("comma", ","),
-                min: 0
+                min: 0,
+                max: 3
             });
 
         const tokens = numbers.getTokens();
@@ -323,10 +324,10 @@ describe("BoundedRepeat", () => {
         const numbers = new FiniteRepeat(
             "numbers",
             new Literal("one", "1"),
-            2,
             {
                 divider: new Literal("comma", ","),
                 min: 0,
+                max: 2,
                 trimDivider: true
             });
 
@@ -350,14 +351,14 @@ describe("BoundedRepeat", () => {
         const numbers = new FiniteRepeat(
             "numbers",
             new Literal("one", "1"),
-            2,
             {
                 divider: new Literal("comma", ","),
                 trimDivider: true,
-                min: 0
+                min: 0,
+                max: 2
             });
 
-        const parent = new And("parent", [numbers, new Literal("b", "B")]);
+        const parent = new Sequence("parent", [numbers, new Literal("b", "B")]);
         const numbersClone = parent.children[0];
         let child = numbersClone.children[0];
         let tokens = numbersClone.getTokensAfter(child);
@@ -380,14 +381,14 @@ describe("BoundedRepeat", () => {
         const numbers = new FiniteRepeat(
             "numbers",
             new Literal("one", "1"),
-            2,
             {
                 divider: new Literal("comma", ","),
-                min: 0
+                min: 0,
+                max: 2
             }
         );
 
-        const parent = new And("parent", [numbers, new Literal("b", "B")]);
+        const parent = new Sequence("parent", [numbers, new Literal("b", "B")]);
         const numbersClone = parent.children[0];
         const tokens = numbersClone.getNextTokens();
 
@@ -399,10 +400,10 @@ describe("BoundedRepeat", () => {
         const numbers = new FiniteRepeat(
             "numbers",
             new Literal("one", "1"),
-            2,
             {
                 divider: new Literal("comma", ","),
-                min: 0
+                min: 0,
+                max: 2
             }
         );
 
@@ -416,10 +417,10 @@ describe("BoundedRepeat", () => {
         const numbers = new FiniteRepeat(
             "numbers",
             new Literal("one", "1"),
-            2,
             {
                 divider: new Literal("comma", ","),
-                min: 0
+                min: 0,
+                max: 2
             }
         );
 
@@ -432,10 +433,10 @@ describe("BoundedRepeat", () => {
         const numbers = new FiniteRepeat(
             "numbers",
             new Literal("one", "1"),
-            2,
             {
                 divider: new Literal("comma", ","),
-                min: 0
+                min: 0,
+                max: 2
             }
         );
 
@@ -448,14 +449,14 @@ describe("BoundedRepeat", () => {
         const numbers = new FiniteRepeat(
             "numbers",
             new Literal("one", "1"),
-            2,
             {
                 divider: new Literal("comma", ","),
-                min: 0
+                min: 0,
+                max: 2
             }
         );
 
-        const parent = new And("parent", [numbers, new Literal("b", "B")]);
+        const parent = new Sequence("parent", [numbers, new Literal("b", "B")]);
         const numbersClone = parent.children[0];
 
         const patterns = numbersClone.getNextPatterns();
@@ -467,10 +468,10 @@ describe("BoundedRepeat", () => {
         const numbers = new FiniteRepeat(
             "numbers",
             new Literal("one", "1"),
-            2,
             {
                 divider: new Literal("comma", ","),
-                min: 0
+                min: 0,
+                max: 2
             }
         );
 

package/src/patterns/FiniteRepeat.ts

@@ -4,13 +4,17 @@ import { findPattern } from "./findPattern";
 import { ParseResult } from "./ParseResult";
 import { Pattern } from "./Pattern";
 
+let idIndex = 0;
+
 export interface FiniteRepeatOptions {
     divider?: Pattern;
     min?: number;
+    max?: number;
     trimDivider?: boolean;
 }
 
 export class FiniteRepeat implements Pattern {
+    private _id: string;
     private _type: string;
     private _name: string;
     private _parent: Pattern | null;
@@ -20,6 +24,10 @@ export class FiniteRepeat implements Pattern {
     private _max: number;
     private _trimDivider: boolean;
 
+    get id() {
+        return this._id;
+    }
+
     get type() {
         return this._type;
     }
@@ -40,10 +48,6 @@ export class FiniteRepeat implements Pattern {
         return this._children;
     }
 
-    get isOptional() {
-        return this._min === 0;
-    }
-
     get min() {
         return this._min;
     }
@@ -52,46 +56,56 @@ export class FiniteRepeat implements Pattern {
         return this._max;
     }
 
-    constructor(name: string, pattern: Pattern, repeatAmount: number, options: FiniteRepeatOptions = {}) {
+    constructor(name: string, pattern: Pattern, options: FiniteRepeatOptions = {}) {
+        this._id = `finite-repeat-${idIndex++}`;
         this._type = "finite-repeat";
         this._name = name;
         this._parent = null;
         this._children = [];
         this._hasDivider = options.divider != null;
-        this._min = options.min != null ? options.min : 1;
-        this._max = repeatAmount;
+        this._min = options.min != null ? Math.max(options.min, 1) : 1;
+        this._max = Math.max(this.min, options.max || this.min);
         this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
 
-        for (let i = 0; i < repeatAmount; i++) {
-            this._children.push(pattern.clone(pattern.name));
+        for (let i = 0; i < this._max; i++) {
+            const child = pattern.clone();
+            child.parent = this;
+
+            this._children.push(child);
 
-            if (options.divider != null && (i < repeatAmount - 1 || !this._trimDivider)) {
-                this._children.push(options.divider.clone(options.divider.name, false));
+            if (options.divider != null && (i < this._max - 1 || !this._trimDivider)) {
+                const divider = options.divider.clone();
+                divider.parent = this;
+                this._children.push(divider);
             }
         }
+
     }
 
     parse(cursor: Cursor): Node | null {
+        cursor.startParseWith(this);
+
         const startIndex = cursor.index;
         const nodes: Node[] = [];
         const modulo = this._hasDivider ? 2 : 1;
         let matchCount = 0;
 
-
         for (let i = 0; i < this._children.length; i++) {
             const childPattern = this._children[i];
+            const runningIndex = cursor.index;
             const node = childPattern.parse(cursor);
 
-            if (i % modulo === 0 && !cursor.hasError) {
-                matchCount++
-            }
-
             if (cursor.hasError) {
-                cursor.resolveError();
                 break;
             }
 
-            if (node != null) {
+            if (i % modulo === 0 && !cursor.hasError) {
+                matchCount++;
+            }
+
+            if (node == null) {
+                cursor.moveTo(runningIndex);
+            } else {
                 nodes.push(node);
 
                 if (cursor.hasNext()) {
@@ -100,13 +114,13 @@ export class FiniteRepeat implements Pattern {
                     break;
                 }
             }
-
         }
 
         if (this._trimDivider && this._hasDivider) {
-            if (cursor.leafMatch.pattern === this.children[1]) {
+            const isDividerLastMatch = cursor.leafMatch.pattern === this.children[1];
+            if (isDividerLastMatch) {
                 const node = nodes.pop() as Node;
-                cursor.moveTo(node.firstIndex)
+                cursor.moveTo(node.firstIndex);
             }
         }
 
@@ -114,17 +128,22 @@ export class FiniteRepeat implements Pattern {
             const lastIndex = cursor.index;
             cursor.moveTo(startIndex);
             cursor.recordErrorAt(startIndex, lastIndex, this);
+            cursor.endParse();
             return null;
-        } else if (nodes.length === 0) {
-            cursor.resolveError();
-            cursor.moveTo(startIndex)
+        }
+
+        if (nodes.length === 0 && !cursor.hasError) {
+            cursor.moveTo(startIndex);
+            cursor.endParse();
             return null;
         }
 
         const firstIndex = nodes[0].firstIndex;
         const lastIndex = nodes[nodes.length - 1].lastIndex;
 
+        cursor.resolveError();
         cursor.moveTo(lastIndex);
+        cursor.endParse();
 
         return new Node(this._type, this.name, firstIndex, lastIndex, nodes);
     }
@@ -136,8 +155,10 @@ export class FiniteRepeat implements Pattern {
         return ast?.value === text;
     }
 
-    exec(text: string): ParseResult {
+    exec(text: string, record = false): ParseResult {
         const cursor = new Cursor(text);
+        record && cursor.startRecording();
+
         const ast = this.parse(cursor);
 
         return {
@@ -146,27 +167,24 @@ export class FiniteRepeat implements Pattern {
         };
     }
 
-    clone(name = this._name, isOptional?: boolean): Pattern {
+    clone(name = this._name): Pattern {
         let min = this._min;
+        let max = this._max;
 
-        if (isOptional != null) {
-            if (isOptional) {
-                min = 0
-            } else {
-                min = Math.max(this._min, 1);
-            }
-        }
-
-        return new FiniteRepeat(
+        const clone = new FiniteRepeat(
             name,
             this._children[0],
-            this._max,
             {
                 divider: this._hasDivider ? this._children[1] : undefined,
                 min,
+                max,
                 trimDivider: this._trimDivider
             }
         );
+
+        clone._id = this._id;
+
+        return clone;
     }
 
     getTokens(): string[] {
@@ -184,7 +202,7 @@ export class FiniteRepeat implements Pattern {
 
     getNextTokens(): string[] {
         if (this._parent == null) {
-            return []
+            return [];
         }
 
         return this._parent.getTokensAfter(this);
@@ -214,7 +232,7 @@ export class FiniteRepeat implements Pattern {
         // Get the next childs patterns.
         const nextChild = this._children[childIndex + 1];
 
-        return nextChild.getPatterns()
+        return nextChild.getPatterns();
     }
 
     getNextPatterns(): Pattern[] {
@@ -229,4 +247,8 @@ export class FiniteRepeat implements Pattern {
         return findPattern(this, predicate);
     }
 
+    isEqual(pattern: FiniteRepeat): boolean {
+        return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+    }
+
 }