clarity-pattern-parser 8.4.14 → 9.0.0

package/src/patterns/{And.test.ts → Sequence.test.ts}

@@ -1,20 +1,21 @@
 import { Cursor } from "./Cursor";
-import { And } from "./And";
+import { Sequence } from "./Sequence";
 import { Literal } from "./Literal";
-import { Node } from "../ast/Node"
+import { Node } from "../ast/Node";
+import { Optional } from "./Optional";
 
-describe("And", () => {
+describe("Sequence", () => {
     test("No Patterns", () => {
         expect(() => {
-            new And("empty", [])
-        }).toThrowError()
+            new Sequence("empty", []);
+        }).toThrowError();
     });
 
     test("One Pattern Match Successful", () => {
-        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const sequence = new Sequence("sequence", [new Literal("a", "A")]);
         const cursor = new Cursor("A");
         const result = sequence.parse(cursor);
-        const expected = new Node("and", "sequence", 0, 0, [
+        const expected = new Node("sequence", "sequence", 0, 0, [
             new Node("literal", "a", 0, 0, [], "A")
         ]);
 
@@ -24,7 +25,7 @@ describe("And", () => {
     });
 
     test("One Pattern Match Fails", () => {
-        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const sequence = new Sequence("sequence", [new Literal("a", "A")]);
         const cursor = new Cursor("V");
         const result = sequence.parse(cursor);
 
@@ -35,13 +36,13 @@ describe("And", () => {
     });
 
     test("Two Pattern Match Successful", () => {
-        const sequence = new And("sequence", [
+        const sequence = new Sequence("sequence", [
             new Literal("a", "A"),
             new Literal("b", "B")
         ]);
         const cursor = new Cursor("AB");
         const result = sequence.parse(cursor);
-        const expected = new Node("and", "sequence", 0, 1, [
+        const expected = new Node("sequence", "sequence", 0, 1, [
             new Node("literal", "a", 0, 0, [], "A"),
             new Node("literal", "b", 1, 1, [], "B")
         ]);
@@ -52,7 +53,7 @@ describe("And", () => {
     });
 
     test("Two Pattern Match Fails", () => {
-        const sequence = new And("sequence", [
+        const sequence = new Sequence("sequence", [
             new Literal("a", "A"),
             new Literal("b", "B")
         ]);
@@ -66,39 +67,39 @@ describe("And", () => {
     });
 
     test("One Pattern Match Fails (Optional)", () => {
-        const sequence = new And("sequence", [new Literal("a", "A")], true);
+        const sequence = new Optional("optional-sequence", new Sequence("sequence", [new Literal("a", "A")]));
         const cursor = new Cursor("V");
         const result = sequence.parse(cursor);
 
         expect(result).toEqual(null);
-        expect(cursor.error).toBe(null)
+        expect(cursor.error).toBe(null);
         expect(cursor.index).toBe(0);
     });
 
     test("Trailing Optional Child Patterns", () => {
-        const sequence = new And("sequence", [
+        const sequence = new Sequence("sequence", [
             new Literal("a", "A"),
-            new Literal("b", "B", true)
+            new Optional("b", new Literal("b", "B"))
         ]);
         const cursor = new Cursor("AD");
         const result = sequence.parse(cursor);
-        const expected = new Node("and", "sequence", 0, 0, [
+        const expected = new Node("sequence", "sequence", 0, 0, [
             new Node("literal", "a", 0, 0, [], "A")
         ]);
 
         expect(result).toEqual(expected);
-        expect(cursor.error).toBe(null)
+        expect(cursor.error).toBe(null);
         expect(cursor.index).toBe(0);
     });
 
     test("Trailing Optional Child Patterns With No More Text", () => {
-        const sequence = new And("sequence", [
+        const sequence = new Sequence("sequence", [
             new Literal("a", "A"),
-            new Literal("b", "B", true)
+            new Optional("b", new Literal("b", "B"))
         ]);
         const cursor = new Cursor("A");
         const result = sequence.parse(cursor);
-        const expected = new Node("and", "sequence", 0, 0, [
+        const expected = new Node("sequence", "sequence", 0, 0, [
             new Node("literal", "a", 0, 0, [], "A")
         ]);
 
@@ -108,27 +109,27 @@ describe("And", () => {
     });
 
     test("Incomplete Parse (Optional)", () => {
-        const sequence = new And("sequence", [
+        const sequence = new Optional("optional-sequence", new Sequence("sequence", [
             new Literal("a", "A"),
             new Literal("b", "B")
-        ], true);
+        ]));
         const cursor = new Cursor("A");
         const result = sequence.parse(cursor);
 
         expect(result).toEqual(null);
-        expect(cursor.error).toBe(null)
+        expect(cursor.error).toBe(null);
         expect(cursor.index).toBe(0);
     });
 
     test("Optional Child Pattern With More Patterns", () => {
-        const sequence = new And("sequence", [
-            new Literal("a", "A", true),
+        const sequence = new Optional("optional-sequence", new Sequence("sequence", [
+            new Optional("a", new Literal("a", "A")),
             new Literal("b", "B"),
             new Literal("c", "C")
-        ], true);
+        ]));
         const cursor = new Cursor("BC");
         const result = sequence.parse(cursor);
-        const expected = new Node("and", "sequence", 0, 1, [
+        const expected = new Node("sequence", "sequence", 0, 1, [
             new Node("literal", "b", 0, 0, [], "B"),
             new Node("literal", "c", 1, 1, [], "C"),
         ]);
@@ -139,49 +140,48 @@ describe("And", () => {
     });
 
     test("Nothing Matched", () => {
-        const sequence = new And("sequence", [
+        const sequence = new Optional("optional-sequence", new Sequence("sequence", [
             new Literal("a", "A"),
-        ], true);
+        ]));
         const cursor = new Cursor("BC");
         const result = sequence.parse(cursor);
 
         expect(result).toEqual(null);
-        expect(cursor.error).toBe(null)
+        expect(cursor.error).toBe(null);
         expect(cursor.index).toBe(0);
     });
 
     test("No Matches On Optional Child Patterns", () => {
-        const sequence = new And("sequence", [
-            new Literal("a", "A", true),
-            new Literal("b", "B", true),
-        ], true);
+        const sequence = new Optional("optional-sequence", new Sequence("sequence", [
+            new Optional("a", new Literal("a", "A")),
+            new Optional("b", new Literal("b", "B")),
+        ]));
         const cursor = new Cursor("XYZ");
         const result = sequence.parse(cursor);
 
         expect(result).toEqual(null);
-        expect(cursor.error).toBe(null)
+        expect(cursor.error).toBe(null);
         expect(cursor.index).toBe(0);
     });
 
     test("Properties", () => {
-        const a = new Literal("a", "A", true)
-        const sequence = new And("sequence", [
+        const a = new Literal("a", "A");
+        const sequence = new Sequence("sequence", [
             a,
-        ], true);
+        ]);
 
-        expect(sequence.type).toBe("and");
+        expect(sequence.type).toBe("sequence");
         expect(sequence.name).toBe("sequence");
         expect(sequence.parent).toBe(null);
-        expect(sequence.isOptional).toBe(true);
         expect(sequence.children[0].type).toBe("literal");
         expect(sequence.children[0].name).toBe("a");
     });
 
     test("Exec", () => {
-        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const sequence = new Sequence("sequence", [new Literal("a", "A")]);
 
         const { ast: result, cursor } = sequence.exec("A");
-        const expected = new Node("and", "sequence", 0, 0, [
+        const expected = new Node("sequence", "sequence", 0, 0, [
             new Node("literal", "a", 0, 0, undefined, "A")
         ]);
 
@@ -190,71 +190,71 @@ describe("And", () => {
     });
 
     test("Test With Match", () => {
-        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const sequence = new Sequence("sequence", [new Literal("a", "A")]);
         const hasMatch = sequence.test("A");
 
         expect(hasMatch).toBeTruthy();
     });
 
     test("Test With No Match", () => {
-        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const sequence = new Sequence("sequence", [new Literal("a", "A")]);
         const hasMatch = sequence.test("B");
 
         expect(hasMatch).toBeFalsy();
     });
 
     test("Set Parent", () => {
-        const a = new Literal("a", "A", true)
-        const sequence = new And("sequence", [
+        const a = new Optional("a", new Literal("a", "A"));
+        const sequence = new Sequence("sequence", [
             a,
-        ], true);
-        const parent = new And("parent", [sequence]);
+        ]);
+        const parent = new Sequence("parent", [sequence]);
 
-        expect(parent.type).toBe("and");
-        expect(parent.children[0].type).toBe("and");
+        expect(parent.type).toBe("sequence");
+        expect(parent.children[0].type).toBe("sequence");
     });
 
     test("Get Tokens", () => {
-        const sequence = new And("sequence", [
-            new Literal("a", "A", true),
+        const sequence = new Sequence("sequence", [
+            new Optional("a", new Literal("a", "A")),
             new Literal("b", "B"),
-        ], true);
-        const tokens = sequence.getTokens()
+        ]);
+        const tokens = sequence.getTokens();
         const expected = ["A", "B"];
 
         expect(tokens).toEqual(expected);
     });
 
     test("Get Tokens After", () => {
-        const sequence = new And("sequence", [
+        const sequence = new Sequence("sequence", [
             new Literal("a", "A"),
-            new Literal("b", "B", true),
+            new Optional("b", new Literal("b", "B")),
             new Literal("c", "C"),
-        ], true);
+        ]);
 
-        const tokens = sequence.getTokensAfter(sequence.children[0])
+        const tokens = sequence.getTokensAfter(sequence.children[0]);
         const expected = ["B", "C"];
 
         expect(tokens).toEqual(expected);
     });
 
     test("Get Tokens After With Invalid Pattern", () => {
-        const sequence = new And("sequence", [
+        const sequence = new Sequence("sequence", [
             new Literal("a", "A"),
-            new Literal("b", "B", true),
+            new Optional("b", new Literal("b", "B")),
             new Literal("c", "C"),
-        ], true);
+        ]);
 
-        const tokens = sequence.getTokensAfter(new Literal("not-child", "not-child"))
+        const tokens = sequence.getTokensAfter(new Literal("not-child", "not-child"));
 
         expect(tokens).toEqual([]);
     });
 
     test("Get Tokens After With Last Child", () => {
-        const sequence = new And("sequence", [
+        const sequence = new Sequence("sequence", [
             new Literal("a", "A"),
-        ], true);
-        const parent = new And("parent", [sequence, new Literal("b", "B")]);
+        ]);
+        const parent = new Sequence("parent", [sequence, new Literal("b", "B")]);
 
 
         const tokens = parent.children[0].getTokensAfter(parent.children[0].children[0])
@@ -263,11 +263,11 @@ describe("And", () => {
     });
 
     test("Get Tokens After With Last Optional Child", () => {
-        const sequence = new And("sequence", [
+        const sequence = new Sequence("sequence", [
             new Literal("a", "A"),
-            new Literal("b", "B", true),
-        ], true);
-        const parent = new And("parent", [sequence, new Literal("c", "C")]);
+            new Optional("b", new Literal("b", "B")),
+        ]);
+        const parent = new Sequence("parent", [sequence, new Literal("c", "C")]);
 
         const tokens = parent.children[0].getTokensAfter(parent.children[0].children[0])
 
@@ -275,8 +275,8 @@ describe("And", () => {
     });
 
     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 sequenceClone = parent.find(p => p.name === "sequence");
         const tokens = sequenceClone?.getNextTokens() || [];
@@ -285,17 +285,17 @@ describe("And", () => {
     });
 
     test("Get Next Tokens With Null Parent", () => {
-        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const sequence = new Sequence("sequence", [new Literal("a", "A")]);
         const tokens = sequence.getNextTokens();
 
         expect(tokens.length).toBe(0);
     });
 
     test("Get Patterns", () => {
-        const sequence = new And("sequence", [
-            new Literal("a", "A", true),
+        const sequence = new Sequence("sequence", [
+            new Optional("a", new Literal("a", "A")),
             new Literal("b", "B"),
-        ], true);
+        ]);
         const tokens = sequence.getPatterns();
         const a = sequence.find(p => p.name === "a");
         const b = sequence.find(p => p.name === "b");
@@ -305,8 +305,8 @@ describe("And", () => {
     });
 
     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 sequenceClone = parent.find(p => p.name === "sequence");
         const nextPatterns = sequenceClone?.getNextPatterns() || [];
@@ -316,7 +316,7 @@ describe("And", () => {
     });
 
     test("Get Next Patterns With Null Parent", () => {
-        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const sequence = new Sequence("sequence", [new Literal("a", "A")]);
         const nextPatterns = sequence.getNextPatterns()
 
         expect(nextPatterns.length).toBe(0);

package/src/patterns/{And.ts → Sequence.ts}

@@ -5,15 +5,21 @@ import { clonePatterns } from "./clonePatterns";
 import { filterOutNull } from "./filterOutNull";
 import { findPattern } from "./findPattern";
 
-export class And implements Pattern {
+let idIndex = 0;
+
+export class Sequence implements Pattern {
+  private _id: string;
   private _type: string;
   private _name: string;
   private _parent: Pattern | null;
   private _children: Pattern[];
-  private _isOptional: boolean;
   private _nodes: (Node | null)[];
   private _firstIndex: number;
 
+  get id(): string {
+    return this._id;
+  }
+
   get type(): string {
     return this._type;
   }
@@ -34,24 +40,20 @@ export class And implements Pattern {
     return this._children;
   }
 
-  get isOptional(): boolean {
-    return this._isOptional;
-  }
-
-  constructor(name: string, sequence: Pattern[], isOptional = false) {
+  constructor(name: string, sequence: Pattern[]) {
     if (sequence.length === 0) {
-      throw new Error("Need at least one pattern with an 'and' pattern.");
+      throw new Error("Need at least one pattern with a 'sequence' pattern.");
     }
 
     const children = clonePatterns(sequence);
-    this._assignChildrenToParent(children)
+    this._assignChildrenToParent(children);
 
-    this._type = "and";
+    this._id = `sequence-${idIndex++}`;
+    this._type = "sequence";
     this._name = name;
-    this._isOptional = isOptional;
     this._parent = null;
     this._children = children;
-    this._firstIndex = -1
+    this._firstIndex = -1;
     this._nodes = [];
   }
 
@@ -68,8 +70,10 @@ export class And implements Pattern {
     return ast?.value === text;
   }
 
-  exec(text: string) {
+  exec(text: string, record = false) {
     const cursor = new Cursor(text);
+    record && cursor.startRecording();
+
     const ast = this.parse(cursor);
 
     return {
@@ -79,6 +83,8 @@ export class And implements Pattern {
   }
 
   parse(cursor: Cursor): Node | null {
+    cursor.startParseWith(this);
+
     this._firstIndex = cursor.index;
     this._nodes = [];
 
@@ -91,13 +97,11 @@ export class And implements Pattern {
         cursor.recordMatch(this, node);
       }
 
+      cursor.endParse();
       return node;
     }
 
-    if (this._isOptional) {
-      cursor.resolveError();
-    }
-
+    cursor.endParse();
     return null;
   }
 
@@ -178,7 +182,7 @@ export class And implements Pattern {
 
     for (let i = startOnIndex; i < length; i++) {
       const pattern = this._children[i];
-      if (!pattern.isOptional) {
+      if (pattern.type !== "optional") {
         return false;
       }
     }
@@ -191,10 +195,10 @@ export class And implements Pattern {
 
     const lastIndex = children[children.length - 1].lastIndex;
 
-    cursor.moveTo(lastIndex)
+    cursor.moveTo(lastIndex);
 
     return new Node(
-      "and",
+      "sequence",
       this._name,
       this._firstIndex,
       lastIndex,
@@ -208,7 +212,7 @@ export class And implements Pattern {
     for (const child of this._children) {
       tokens.push(...child.getTokens());
 
-      if (!child.isOptional) {
+      if (child.type !== "optional") {
         break;
       }
     }
@@ -227,7 +231,7 @@ export class And implements Pattern {
 
   getNextTokens(): string[] {
     if (this.parent == null) {
-      return []
+      return [];
     }
 
     return this.parent.getTokensAfter(this);
@@ -236,10 +240,10 @@ export class And implements Pattern {
   getPatterns(): Pattern[] {
     const patterns: Pattern[] = [];
 
-    for (const pattern of this._children) {
-      patterns.push(...pattern.getPatterns());
+    for (const child of this._children) {
+      patterns.push(...child.getPatterns());
 
-      if (!pattern.isOptional) {
+      if (child.type !== "optional") {
         break;
       }
     }
@@ -276,7 +280,7 @@ export class And implements Pattern {
       const child = this._children[i];
       patterns.push(child);
 
-      if (!child.isOptional) {
+      if (child.type !== "optional") {
         break;
       }
 
@@ -294,14 +298,21 @@ export class And 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 = this._isOptional): Pattern {
-    return new And(name, this._children, isOptional)
+  clone(name = this._name): Pattern {
+    const clone = new Sequence(name, this._children);
+    clone._id = this._id;
+
+    return clone;
+  }
+
+  isEqual(pattern: Sequence): boolean {
+    return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
   }
 }

package/src/patterns/arePatternsEqual.ts

@@ -0,0 +1,12 @@
+import { Literal } from "./Literal";
+import { Pattern } from "./Pattern";
+
+export function arePatternsEqual(a?: Pattern | null, b?: Pattern | null): boolean {
+    if (a === b) {
+        return true;
+    } else if (a == null || b == null) {
+        return false;
+    }
+
+    return a.isEqual(b);
+}

package/src/patterns/clonePatterns.ts

@@ -1,5 +1,5 @@
 import { Pattern } from "./Pattern";
 
-export function clonePatterns(patterns: Pattern[], isOptional?: boolean): Pattern[] {
-    return patterns.map(p => p.clone(p.name, isOptional))
+export function clonePatterns(patterns: Pattern[]): Pattern[] {
+    return patterns.map(p => p.clone());
 }

package/src/grammar/patterns/andLiteral.ts

@@ -1,8 +0,0 @@
-import { Repeat } from "../../patterns/Repeat"
-import { Regex } from "../../patterns/Regex";
-import { pattern } from "./pattern";
-
-const divider = new Regex("and-divider", "\\s*[&]\\s*");
-divider.setTokens([" & "]);
-
-export const andLiteral = new Repeat("and-literal", pattern, { divider, min: 2, trimDivider: true });

package/src/grammar/patterns/orLiteral.ts

@@ -1,8 +0,0 @@
-import { Repeat } from "../../patterns/Repeat"
-import { name } from "./name"
-import { Regex } from "../../patterns/Regex";
-
-const divider = new Regex("or-divider", "\\s*[|]\\s*");
-divider.setTokens([" | "]);
-
-export const orLiteral = new Repeat("or-literal", name.clone("pattern-name"), { divider, min: 2, trimDivider: true });