clarity-pattern-parser 8.4.15 → 9.1.0

package/src/patterns/Regex.test.ts

@@ -1,21 +1,21 @@
 import { Cursor } from "./Cursor";
 import { Regex } from "./Regex";
 import { Node } from "../ast/Node"
-import { And } from "./And";
+import { Sequence } from "./Sequence";
 import { Literal } from "./Literal";
 import { Pattern } from "./Pattern";
 
 describe("Regex", () => {
     test("Empty String", () => {
-        expect(() => new Regex("empty", "")).toThrowError()
+        expect(() => new Regex("empty", "")).toThrowError();
     });
 
     test("Starts With ^", () => {
-        expect(() => new Regex("carrot", "^")).toThrowError()
+        expect(() => new Regex("carrot", "^")).toThrowError();
     });
 
     test("Ends With $", () => {
-        expect(() => new Regex("money", ".$")).toThrowError()
+        expect(() => new Regex("money", ".$")).toThrowError();
     });
 
     test("Successful Parse", () => {
@@ -25,8 +25,8 @@ describe("Regex", () => {
         const expected = new Node("regex", "number", 0, 0, [], "1");
 
         expect(result).toEqual(expected);
-        expect(cursor.hasError).toBeFalsy()
-    })
+        expect(cursor.hasError).toBeFalsy();
+    });
 
     test("Failed Parse", () => {
         const number = new Regex("number", "\\d");
@@ -34,7 +34,7 @@ describe("Regex", () => {
         const result = number.parse(cursor);
 
         expect(result).toBeNull();
-        expect(cursor.hasError).toBeTruthy()
+        expect(cursor.hasError).toBeTruthy();
     });
 
 
@@ -54,7 +54,7 @@ describe("Regex", () => {
         const tokens = regex.getTokensAfter(new Literal("bogus", "bogus"));
         const expected: string[] = [];
 
-        expect(tokens).toEqual(expected)
+        expect(tokens).toEqual(expected);
     });
 
     test("Properties", () => {
@@ -85,7 +85,7 @@ describe("Regex", () => {
     });
 
     test("Get Next Tokens", () => {
-        const parent = new And("parent", [new Regex("a", "A"), new Literal("b", "B")]);
+        const parent = new Sequence("parent", [new Regex("a", "A"), new Literal("b", "B")]);
         const aClone = parent.find(p => p.name === "a") as Pattern;
         const tokens = aClone.getNextTokens();
 
@@ -93,7 +93,7 @@ describe("Regex", () => {
     });
 
     test("Get Next Tokens With Null Parent", () => {
-        const a = new Regex("a", "A")
+        const a = new Regex("a", "A");
         const tokens = a.getNextTokens();
 
         expect(tokens).toEqual([]);
@@ -109,21 +109,21 @@ describe("Regex", () => {
     });
 
     test("Get Patterns After", () => {
-        const a = new Regex("a", "A")
+        const a = new Regex("a", "A");
         const patterns = a.getPatternsAfter(new Literal("bogus", "bogus"));
 
         expect(patterns).toEqual([]);
     });
 
     test("Find Pattern", () => {
-        const a = new Regex("a", "A")
+        const a = new Regex("a", "A");
         const pattern = a.find(p => p.name === "other");
 
         expect(pattern).toBeNull();
     });
 
     test("Get Next Patterns", () => {
-        const parent = new And("parent", [new Regex("a", "A"), new Literal("b", "B")]);
+        const parent = new Sequence("parent", [new Regex("a", "A"), new Literal("b", "B")]);
         const aClone = parent.find(p => p.name === "a") as Pattern;
         const bClone = parent.find(p => p.name === "b") as Pattern;
         const patterns = aClone.getNextPatterns();
@@ -133,10 +133,10 @@ describe("Regex", () => {
     });
 
     test("Get Next Patterns With Null Parent", () => {
-        const a = new Regex("a", "A")
+        const a = new Regex("a", "A");
         const patterns = a.getNextPatterns();
 
-        expect(patterns).toEqual([])
+        expect(patterns).toEqual([]);
     });
 
 });

package/src/patterns/Regex.ts

@@ -1,11 +1,14 @@
 import { Node } from "../ast/Node";
 import { Pattern } from "./Pattern";
 import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
+
+let idIndex = 0;
 
 export class Regex implements Pattern {
+  private _id: string;
   private _type: string;
   private _name: string;
-  private _isOptional: boolean;
   private _parent: Pattern | null;
   private _originalRegexString: string;
   private _regex: RegExp;
@@ -15,6 +18,10 @@ export class Regex implements Pattern {
   private _substring = "";
   private _tokens: string[] = [];
 
+  get id(): string {
+    return this._id;
+  }
+
   get type(): string {
     return this._type;
   }
@@ -23,6 +30,10 @@ export class Regex implements Pattern {
     return this._name;
   }
 
+  get value(): string{
+    return this._originalRegexString;
+  }
+
   get parent(): Pattern | null {
     return this._parent;
   }
@@ -35,14 +46,10 @@ export class Regex implements Pattern {
     return [];
   }
 
-  get isOptional(): boolean {
-    return this._isOptional;
-  }
-
-  constructor(name: string, regex: string, isOptional = false) {
-    this._type = "regex"
+  constructor(name: string, regex: string) {
+    this._id = `regex-${idIndex++}`;
+    this._type = "regex";
     this._name = name;
-    this._isOptional = isOptional;
     this._parent = null;
     this._originalRegexString = regex;
     this._regex = new RegExp(`^${regex}`, "g");
@@ -76,8 +83,10 @@ export class Regex 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 {
@@ -87,10 +96,13 @@ export class Regex implements Pattern {
   }
 
   parse(cursor: Cursor) {
+    cursor.startParseWith(this);
+
     this._firstIndex = cursor.index;
     this.resetState(cursor);
     this.tryToParse(cursor);
 
+    cursor.endParse();
     return this._node;
   }
 
@@ -129,18 +141,16 @@ export class Regex implements Pattern {
   }
 
   private processError(cursor: Cursor) {
-    if (!this._isOptional) {
-      cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
-    }
-
+    cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
     this._node = null;
   }
 
-  clone(name = this._name, isOptional = this._isOptional) {
-    const pattern = new Regex(name, this._originalRegexString, isOptional);
-    pattern._tokens = this._tokens.slice();
+  clone(name = this._name) {
+    const clone = new Regex(name, this._originalRegexString);
+    clone._tokens = this._tokens.slice();
 
-    return pattern;
+    clone._id = this._id;
+    return clone;
   }
 
   getTokens() {
@@ -153,7 +163,7 @@ export class Regex implements Pattern {
 
   getNextTokens(): string[] {
     if (this.parent == null) {
-      return []
+      return [];
     }
 
     return this.parent.getTokensAfter(this);
@@ -172,7 +182,7 @@ export class Regex implements Pattern {
       return [];
     }
 
-    return this.parent.getPatternsAfter(this)
+    return this.parent.getPatternsAfter(this);
   }
 
   find(_predicate: (p: Pattern) => boolean): Pattern | null {
@@ -183,4 +193,8 @@ export class Regex implements Pattern {
     this._tokens = tokens;
   }
 
+  isEqual(pattern: Regex): boolean {
+    return pattern.type === this.type && pattern._originalRegexString === this._originalRegexString;
+  }
+
 }

package/src/patterns/Repeat.test.ts

@@ -1,5 +1,6 @@
 import { Node } from "../ast/Node";
-import { And } from "./And";
+import { Sequence } from "./Sequence";
+import { arePatternsEqual } from "./arePatternsEqual";
 import { Cursor } from "./Cursor";
 import { InfiniteRepeat } from "./InfiniteRepeat";
 import { Literal } from "./Literal";
@@ -26,7 +27,7 @@ describe("Repeat", () => {
             new Node("regex", "number", 0, 0, [], "1")
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.toJson()).toEqual(expected.toJson());
         expect(cursor.hasError).toBeFalsy();
 
         cursor = new Cursor("12");
@@ -36,7 +37,7 @@ describe("Repeat", () => {
             new Node("regex", "number", 1, 1, [], "2")
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.toJson()).toEqual(expected.toJson());
         expect(cursor.hasError).toBeFalsy();
 
         cursor = new Cursor("123");
@@ -46,7 +47,7 @@ describe("Repeat", () => {
             new Node("regex", "number", 1, 1, [], "2")
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.toJson()).toEqual(expected.toJson());
         expect(cursor.hasError).toBeFalsy();
         expect(cursor.index).toBe(1);
     });
@@ -76,7 +77,7 @@ describe("Repeat", () => {
             new Node("regex", "number", 1, 1, [], "2")
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.toJson()).toEqual(expected.toJson());
         expect(cursor.hasError).toBeFalsy();
 
         cursor = new Cursor("123");
@@ -86,7 +87,7 @@ describe("Repeat", () => {
             new Node("regex", "number", 1, 1, [], "2")
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.toJson()).toEqual(expected.toJson());
         expect(cursor.hasError).toBeFalsy();
         expect(cursor.index).toBe(1);
     });
@@ -115,7 +116,7 @@ describe("Repeat", () => {
     test("Get Tokens After", () => {
         const number = new Literal("number", "1");
         const repeat = new Repeat("numbers", number);
-        const parent = new And("parent", [repeat, new Literal("b", "B")]);
+        const parent = new Sequence("parent", [repeat, new Literal("b", "B")]);
         const numberClone = parent.find(p => p.name === "number") as Pattern;
         const repeatClone = parent.children[0];
 
@@ -128,7 +129,7 @@ describe("Repeat", () => {
     test("Get Next Tokens", () => {
         const number = new Literal("number", "1");
         const repeat = new Repeat("numbers", number);
-        const parent = new And("parent", [repeat, new Literal("b", "B")]);
+        const parent = new Sequence("parent", [repeat, new Literal("b", "B")]);
         const repeatClone = parent.children[0];
 
         let tokens = repeatClone.getNextTokens();
@@ -140,7 +141,7 @@ describe("Repeat", () => {
     test("Get Next Patterns", () => {
         const number = new Literal("number", "1");
         const repeat = new Repeat("numbers", number);
-        const parent = new And("parent", [repeat, new Literal("b", "B")]);
+        const parent = new Sequence("parent", [repeat, new Literal("b", "B")]);
         const repeatClone = parent.children[0];
         const bClone = parent.find(p => p.name === "b") as Pattern;
 
@@ -178,7 +179,6 @@ describe("Repeat", () => {
         expect(repeat.type).toBe("infinite-repeat");
         expect(repeat.name).toBe("numbers");
         expect(repeat.parent).toBeNull();
-        expect(repeat.isOptional).toBeFalsy();
     });
 
     test("test", () => {
@@ -202,21 +202,11 @@ describe("Repeat", () => {
         let repeatClone = repeat.clone();
         let expected = new Repeat("numbers", number);
 
-        expect(repeatClone).toEqual(expected);
+        expect(arePatternsEqual(repeatClone, expected)).toBeTruthy();
 
         repeatClone = repeat.clone("new-name");
         expected = new Repeat("new-name", number);
 
-        expect(repeatClone).toEqual(expected);
-
-        repeatClone = repeat.clone("new-name", false);
-        expected = new Repeat("new-name", number);
-
-        expect(repeatClone).toEqual(expected);
-
-        repeatClone = repeat.clone("new-name", true);
-        expected = new Repeat("new-name", number, { min: 0 });
-
-        expect(repeatClone).toEqual(expected);
+        expect(arePatternsEqual(repeatClone, expected)).toBeTruthy();
     });
 });

package/src/patterns/Repeat.ts

@@ -5,6 +5,8 @@ import { InfiniteRepeat } from "./InfiniteRepeat";
 import { ParseResult } from "./ParseResult";
 import { Pattern } from "./Pattern";
 
+let idIndex = 0;
+
 export interface RepeatOptions {
     min?: number;
     max?: number;
@@ -19,12 +21,17 @@ interface InternalRepeatOptions {
 }
 
 export class Repeat implements Pattern {
+    private _id: string;
     private _repeatPattern: InfiniteRepeat | FiniteRepeat;
     private _parent: Pattern | null;
     private _pattern: Pattern;
     private _options: InternalRepeatOptions;
     private _children: Pattern[];
 
+    get id() {
+        return this._id;
+    }
+
     get type() {
         return this._repeatPattern.type;
     }
@@ -45,11 +52,8 @@ export class Repeat implements Pattern {
         return this._children;
     }
 
-    get isOptional() {
-        return this._repeatPattern.isOptional;
-    }
-
     constructor(name: string, pattern: Pattern, options: RepeatOptions = {}) {
+        this._id = `repeat-${idIndex++}`;
         this._pattern = pattern;
         this._parent = null;
         this._options = {
@@ -59,12 +63,12 @@ export class Repeat implements Pattern {
         };
 
         if (this._options.max !== Infinity) {
-            this._repeatPattern = new FiniteRepeat(name, pattern, this._options.max, this._options);
+            this._repeatPattern = new FiniteRepeat(name, pattern, this._options);
         } else {
-            this._repeatPattern = new InfiniteRepeat(name, pattern, this._options)
+            this._repeatPattern = new InfiniteRepeat(name, pattern, this._options);
         }
 
-        this._children = [this._repeatPattern]
+        this._children = [this._repeatPattern];
         this._repeatPattern.parent = this;
     }
 
@@ -80,18 +84,12 @@ export class Repeat implements Pattern {
         return this._repeatPattern.test(text);
     }
 
-    clone(name = this.name, isOptional?: boolean) {
+    clone(name = this.name) {
         let min = this._options.min;
+        const clone = new Repeat(name, this._pattern, { ...this._options, min });
 
-        if (isOptional != null) {
-            if (isOptional) {
-                min = 0
-            } else {
-                min = Math.max(this._options.min, 1);
-            }
-        }
-
-        return new Repeat(name, this._pattern, { ...this._options, min });
+        clone._id = this._id;
+        return clone;
     }
 
     getTokens(): string[] {
@@ -100,7 +98,7 @@ export class Repeat implements Pattern {
 
     getTokensAfter(_childReference: Pattern): string[] {
         if (this._parent == null) {
-            return []
+            return [];
         }
 
         return this._parent.getTokensAfter(this);
@@ -108,7 +106,7 @@ export class Repeat implements Pattern {
 
     getNextTokens(): string[] {
         if (this._parent == null) {
-            return []
+            return [];
         }
 
         return this._parent.getTokensAfter(this);
@@ -120,7 +118,7 @@ export class Repeat implements Pattern {
 
     getPatternsAfter(_childReference: Pattern): Pattern[] {
         if (this._parent == null) {
-            return []
+            return [];
         }
 
         return this._parent.getPatternsAfter(this);
@@ -128,7 +126,7 @@ export class Repeat implements Pattern {
 
     getNextPatterns(): Pattern[] {
         if (this._parent == null) {
-            return []
+            return [];
         }
 
         return this._parent.getPatternsAfter(this);
@@ -138,4 +136,7 @@ export class Repeat implements Pattern {
         return this._repeatPattern.find(predicate);
     }
 
+    isEqual(pattern: Repeat): boolean {
+        return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+    }
 }