clarity-pattern-parser 8.4.14 → 9.0.0

package/src/patterns/{Or.test.ts → Options.test.ts}

@@ -1,19 +1,20 @@
 import { Cursor } from "./Cursor";
 import { Node } from "../ast/Node";
 import { Literal } from "./Literal";
-import { Or } from "./Or";
-import { And } from "./And";
+import { Options } from "./Options";
+import { Sequence } from "./Sequence";
 import { Pattern } from "./Pattern";
+import { Optional } from "./Optional";
 
-describe("Or", () => {
+describe("Options", () => {
     test("Empty Options", () => {
         expect(() => {
-            new Or("bad", []);
+            new Options("bad", []);
         }).toThrowError();
     });
 
     test("One Option Successful", () => {
-        const a = new Or("a", [new Literal("a", "A")]);
+        const a = new Options("a", [new Literal("a", "A")]);
         const cursor = new Cursor("A");
         const result = a.parse(cursor);
         const expected = new Node("literal", "a", 0, 0, [], "A")
@@ -22,7 +23,7 @@ describe("Or", () => {
     });
 
     test("One Option Failed", () => {
-        const a = new Or("a", [new Literal("a", "A")]);
+        const a = new Options("a", [new Literal("a", "A")]);
         const cursor = new Cursor("B");
         const result = a.parse(cursor);
 
@@ -32,7 +33,7 @@ describe("Or", () => {
     });
 
     test("Two Option", () => {
-        const a = new Or("a-b", [new Literal("a", "A"), new Literal("b", "B")]);
+        const a = new Options("a-b", [new Literal("a", "A"), new Literal("b", "B")]);
         const cursor = new Cursor("AB");
         let result = a.parse(cursor);
         let expected = new Node("literal", "a", 0, 0, [], "A")
@@ -47,17 +48,8 @@ describe("Or", () => {
         ], "B");
     });
 
-    test("Failed (Optional)", () => {
-        const a = new Or("a", [new Literal("a", "A")], true);
-        const cursor = new Cursor("B");
-        const result = a.parse(cursor);
-
-        expect(result).toBeNull();
-        expect(cursor.hasError).toBeFalsy();
-    });
-
     test("Get Tokens", () => {
-        const aOrB = new Or("a-b", [new Literal("a", "A"), new Literal("b", "B")]);
+        const aOrB = new Options("a-b", [new Literal("a", "A"), new Literal("b", "B")]);
         const tokens = aOrB.getTokens();
         const expected = ["A", "B"];
 
@@ -65,8 +57,8 @@ describe("Or", () => {
     });
 
     test("Get Tokens After", () => {
-        const a = new Or("a", [new Literal("a", "A")]);
-        const parent = new And("parent", [a, new Literal("b", "B")]);
+        const a = new Options("a", [new Literal("a", "A")]);
+        const parent = new Sequence("parent", [a, new Literal("b", "B")]);
         const tokens = parent.children[0].getTokensAfter(parent.children[0].children[0]);
         const expected = ["B"];
 
@@ -74,7 +66,7 @@ describe("Or", () => {
     });
 
     test("Get Tokens After Without A Parent", () => {
-        const a = new Or("a", [new Literal("a", "A")]);
+        const a = new Options("a", [new Literal("a", "A")]);
         const tokens = a.getTokensAfter(a.children[0]);
         const expected: string[] = [];
 
@@ -82,36 +74,35 @@ describe("Or", () => {
     });
 
     test("Properties", () => {
-        const a = new Or("a", [new Literal("a", "A")]);
+        const a = new Options("a", [new Literal("a", "A")]);
 
         expect(a.type).toBe("or");
         expect(a.name).toBe("a");
-        expect(a.isOptional).toBeFalsy();
         expect(a.parent).toBeNull();
         expect(a.children[0].name).toBe("a");
     });
 
     test("Exec", () => {
-        const a = new Or("a", [new Literal("a", "A")]);
+        const a = new Options("a", [new Literal("a", "A")]);
         const { ast: result } = a.exec("B");
         expect(result).toBeNull();
     });
 
     test("Test No Match", () => {
-        const a = new Or("a", [new Literal("a", "A")]);
+        const a = new Options("a", [new Literal("a", "A")]);
         const result = a.test("B");
         expect(result).toBeFalsy();
     });
 
     test("Test With Match", () => {
-        const a = new Or("a", [new Literal("a", "A")]);
+        const a = new Options("a", [new Literal("a", "A")]);
         const result = a.test("A");
         expect(result).toBeTruthy();
     });
 
     test("Get Next Tokens", () => {
-        const sequence = new And("sequence", [
-            new Or("a-or-b", [
+        const sequence = new Sequence("sequence", [
+            new Options("a-or-b", [
                 new Literal("a", "A"),
                 new Literal("b", "B")
             ]),
@@ -126,7 +117,7 @@ describe("Or", () => {
     });
 
     test("Get Next Tokens With Null Parent", () => {
-        const or = new Or("a-or-b", [
+        const or = new Options("a-or-b", [
             new Literal("a", "A"),
             new Literal("b", "B")
         ])
@@ -137,8 +128,8 @@ describe("Or", () => {
 
 
     test("Get Tokens After", () => {
-        const sequence = new And("sequence", [
-            new Or("a-or-b", [
+        const sequence = new Sequence("sequence", [
+            new Options("a-or-b", [
                 new Literal("a", "A"),
                 new Literal("b", "B")
             ]),
@@ -154,7 +145,7 @@ describe("Or", () => {
     });
 
     test("Get Patterns", () => {
-        const aOrB = new Or("a-b", [new Literal("a", "A"), new Literal("b", "B")]);
+        const aOrB = new Options("a-b", [new Literal("a", "A"), new Literal("b", "B")]);
         const patterns = aOrB.getPatterns();
         const expected = [
             aOrB.find(p => p.name === "a"),
@@ -165,8 +156,8 @@ describe("Or", () => {
     });
 
     test("Get Patterns After", () => {
-        const sequence = new And("sequence", [
-            new Or("a-or-b", [
+        const sequence = new Sequence("sequence", [
+            new Options("a-or-b", [
                 new Literal("a", "A"),
                 new Literal("b", "B")
             ]),
@@ -182,7 +173,7 @@ describe("Or", () => {
     });
 
     test("Get Patterns After With Null Parent", () => {
-        const or = new Or("a-or-b", [
+        const or = new Options("a-or-b", [
             new Literal("a", "A"),
             new Literal("b", "B")
         ])
@@ -193,8 +184,8 @@ describe("Or", () => {
     });
 
     test("Get Next Patterns", () => {
-        const sequence = new And("sequence", [
-            new Or("a-or-b", [
+        const sequence = new Sequence("sequence", [
+            new Options("a-or-b", [
                 new Literal("a", "A"),
                 new Literal("b", "B")
             ]),
@@ -209,7 +200,7 @@ describe("Or", () => {
     });
 
     test("Get Next Patterns With Null Parent", () => {
-        const or = new Or("a-or-b", [
+        const or = new Options("a-or-b", [
             new Literal("a", "A"),
             new Literal("b", "B")
         ])
@@ -225,11 +216,11 @@ describe("Or", () => {
         const smith = new Literal("smith", "Smith");
         const space = new Literal("space", " ");
 
-        const firstName = new Or("first-name", [john, jane], false, true);
-        const lastName = new Or("last-name", [doe, smith], false, true);
+        const firstName = new Options("first-name", [john, jane], true);
+        const lastName = new Options("last-name", [doe, smith], true);
         const johnJohnson = new Literal("john-johnson", "John Johnson");
-        const fullName = new And("full-name", [firstName, space, lastName]);
-        const names = new Or("names", [fullName, johnJohnson], false, true);
+        const fullName = new Sequence("full-name", [firstName, space, lastName]);
+        const names = new Options("names", [fullName, johnJohnson], true);
 
         const result = names.exec("John Johnson");
         expect(result.ast?.value).toBe("John Johnson");
@@ -242,11 +233,11 @@ describe("Or", () => {
         const smith = new Literal("smith", "Smith");
         const space = new Literal("space", " ");
 
-        const firstName = new Or("first-name", [john, jane], false, true);
-        const lastName = new Or("last-name", [doe, smith], false, true);
+        const firstName = new Options("first-name", [john, jane], true);
+        const lastName = new Options("last-name", [doe, smith], true);
         const johnJohnson = new Literal("john-johnson", "John Johnson");
-        const fullName = new And("full-name", [firstName, space, lastName]);
-        const names = new Or("names", [johnJohnson, fullName], false, true);
+        const fullName = new Sequence("full-name", [firstName, space, lastName]);
+        const names = new Options("names", [johnJohnson, fullName], true);
 
         const result = names.exec("John Johnson");
         expect(result.ast?.value).toBe("John Johnson");
@@ -259,14 +250,25 @@ describe("Or", () => {
         const smith = new Literal("smith", "Smith");
         const space = new Literal("space", " ");
 
-        const firstName = new Or("first-name", [john, jane], false, true);
-        const lastName = new Or("last-name", [doe, smith], false, true);
+        const firstName = new Options("first-name", [john, jane], true);
+        const lastName = new Options("last-name", [doe, smith], true);
         const johnJohnson = new Literal("john-johnson", "John Johnson");
         const johnStockton = new Literal("john-stockton", "John Stockton");
-        const fullName = new And("full-name", [firstName, space, lastName]);
-        const names = new Or("names", [johnStockton, johnJohnson, fullName], false, true);
+        const fullName = new Sequence("full-name", [firstName, space, lastName]);
+        const names = new Options("names", [johnStockton, johnJohnson, fullName], true);
 
         const result = names.exec("John Johnson");
         expect(result.ast?.value).toBe("John Johnson");
     });
+
+    // This doesn't make sense, but every pattern needs to handle a null result with no error.
+    test("Optional option", () => {
+        const john = new Optional("optional-john", new Literal("john", "John"));
+        const jane = new Literal("jane", "Jane");
+
+        const firstName = new Options("first-name", [john, jane], true);
+
+        const result = firstName.exec("Jane");
+        expect(result.ast?.value).toBe("Jane");
+    });
 });

package/src/patterns/{Or.ts → Options.ts}

@@ -3,16 +3,23 @@ import { Cursor } from "./Cursor";
 import { Pattern } from "./Pattern";
 import { clonePatterns } from "./clonePatterns";
 import { findPattern } from "./findPattern";
+import { ParseResult } from "./ParseResult";
 
-export class Or implements Pattern {
+let idIndex = 0;
+
+export class Options implements Pattern {
+  private _id: string;
   private _type: string;
   private _name: string;
   private _parent: Pattern | null;
   private _children: Pattern[];
-  private _isOptional: boolean;
   private _isGreedy: boolean;
   private _firstIndex: number;
 
+  get id(): string {
+    return this._id;
+  }
+
   get type(): string {
     return this._type;
   }
@@ -33,23 +40,19 @@ export class Or implements Pattern {
     return this._children;
   }
 
-  get isOptional(): boolean {
-    return this._isOptional;
-  }
-
-  constructor(name: string, options: Pattern[], isOptional = false, isGreedy = false) {
+  constructor(name: string, options: Pattern[], isGreedy = false) {
     if (options.length === 0) {
       throw new Error("Need at least one pattern with an 'or' pattern.");
     }
 
-    const children = clonePatterns(options, false);
+    const children = clonePatterns(options);
     this._assignChildrenToParent(children);
 
+    this._id = `or-${idIndex++}`;
     this._type = "or";
     this._name = name;
     this._parent = null;
     this._children = children;
-    this._isOptional = isOptional;
     this._firstIndex = 0;
     this._isGreedy = isGreedy;
   }
@@ -67,8 +70,10 @@ export class Or 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 {
@@ -78,6 +83,7 @@ export class Or implements Pattern {
   }
 
   parse(cursor: Cursor): Node | null {
+    cursor.startParseWith(this);
     this._firstIndex = cursor.index;
 
     const node = this._tryToParse(cursor);
@@ -85,16 +91,13 @@ export class Or implements Pattern {
     if (node != null) {
       cursor.moveTo(node.lastIndex);
       cursor.resolveError();
-      return node
-    }
 
-    if (!this._isOptional) {
-      cursor.recordErrorAt(this._firstIndex, this._firstIndex, this)
-      return null;
+      cursor.endParse();
+      return node;
     }
 
-    cursor.resolveError();
-    cursor.moveTo(this._firstIndex);
+    cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
+    cursor.endParse();
     return null;
   }
 
@@ -104,11 +107,12 @@ export class Or implements Pattern {
     for (const pattern of this._children) {
       cursor.moveTo(this._firstIndex);
       const result = pattern.parse(cursor);
+
       if (this._isGreedy) {
         results.push(result);
       }
 
-      if (!cursor.hasError && !this._isGreedy) {
+      if (result != null && !this._isGreedy) {
         return result;
       }
 
@@ -141,7 +145,7 @@ export class Or implements Pattern {
 
   getNextTokens(): string[] {
     if (this._parent == null) {
-      return []
+      return [];
     }
 
     return this._parent.getTokensAfter(this);
@@ -162,7 +166,7 @@ export class Or implements Pattern {
       return [];
     }
 
-    return this._parent.getPatternsAfter(this)
+    return this._parent.getPatternsAfter(this);
   }
 
   getNextPatterns(): Pattern[] {
@@ -170,15 +174,20 @@ export class Or 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 {
-    const or = new Or(name, this._children, isOptional, this._isGreedy);
+  clone(name = this._name): Pattern {
+    const or = new Options(name, this._children, this._isGreedy);
+    or._id = this._id;
     return or;
   }
+
+  isEqual(pattern: Options): boolean {
+    return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+  }
 }

package/src/patterns/Pattern.ts

@@ -1,18 +1,18 @@
 import { Cursor } from "./Cursor";
 import { Node } from "../ast/Node";
-import { ParseResult } from "./ParseResult"
+import { ParseResult } from "./ParseResult";
 
 export interface Pattern {
+  id: string;
   type: string;
   name: string;
   parent: Pattern | null;
   children: Pattern[];
-  isOptional: boolean;
 
   parse(cursor: Cursor): Node | null;
-  exec(text: string): ParseResult;
-  test(text: string): boolean;
-  clone(name?: string, isOptional?: boolean): Pattern;
+  exec(text: string, record?: boolean): ParseResult;
+  test(text: string, record?: boolean): boolean;
+  clone(name?: string): Pattern;
   getTokens(): string[];
   getTokensAfter(childReference: Pattern): string[];
   getNextTokens(): string[];
@@ -20,4 +20,5 @@ export interface Pattern {
   getPatternsAfter(childReference: Pattern): Pattern[];
   getNextPatterns(): Pattern[];
   find(predicate: (p: Pattern) => boolean): Pattern | null;
+  isEqual(pattern: Pattern): boolean;
 }

package/src/patterns/Reference.test.ts

@@ -1,9 +1,9 @@
 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 { Or } from "./Or";
+import { Options } from "./Options";
 import { Pattern } from "./Pattern";
 import { Reference } from "./Reference";
 import { Regex } from "./Regex";
@@ -20,8 +20,8 @@ function createValuePattern() {
 
     const valueRef = new Reference("value");
     const values = new Repeat("values", valueRef, { divider });
-    const array = new And("array", [openBracket, values, closeBracket]);
-    const value = new Or("value", [number, array]);
+    const array = new Sequence("array", [openBracket, values, closeBracket]);
+    const value = new Options("value", [number, array]);
 
     return value;
 }
@@ -32,7 +32,7 @@ describe("Reference", () => {
         const cursor = new Cursor("[1, 2]");
         const result = value.parse(cursor);
 
-        const expected = new Node("and", "array", 0, 5, [
+        const expected = new Node("sequence", "array", 0, 5, [
             new Node("literal", "open-bracket", 0, 0, [], "["),
             new Node("infinite-repeat", "values", 1, 4, [
                 new Node("regex", "number", 1, 1, [], "1"),
@@ -40,7 +40,7 @@ describe("Reference", () => {
                 new Node("regex", "number", 4, 4, [], "2")
             ]),
             new Node("literal", "close-bracket", 5, 5, [], "]"),
-        ])
+        ]);
 
         expect(result).toEqual(expected);
     });
@@ -49,8 +49,8 @@ describe("Reference", () => {
         const ref = new Reference("bad-reference");
 
         expect(() => {
-            ref.parse(new Cursor("text"))
-        }).toThrowError()
+            ref.parse(new Cursor("text"));
+        }).toThrowError();
     });
 
     test("Get Tokens", () => {
@@ -76,7 +76,7 @@ describe("Reference", () => {
 
     test("Get Tokens After With No Parent", () => {
         const ref = new Reference("bad-reference");
-        const tokens = ref.getTokensAfter(new Literal("bogus", "bogus"))
+        const tokens = ref.getTokensAfter(new Literal("bogus", "bogus"));
 
         expect(tokens).toEqual([]);
     });
@@ -86,30 +86,29 @@ describe("Reference", () => {
 
         expect(ref.type).toBe("reference");
         expect(ref.name).toBe("ref");
-        expect(ref.isOptional).toBeFalsy();
-        expect(ref.parent).toBe(null)
-        expect(ref.children).toEqual([])
+        expect(ref.parent).toBe(null);
+        expect(ref.children).toEqual([]);
     });
 
     test("Exec", () => {
         const value = createValuePattern();
-        const reference = findPattern(value, p => p.type === "reference") as Reference
+        const reference = findPattern(value, p => p.type === "reference") as Reference;
         const { ast: result } = reference.exec("B");
-        expect(result).toBeNull()
+        expect(result).toBeNull();
     });
 
     test("Test With Match", () => {
         const value = createValuePattern();
-        const reference = findPattern(value, p => p.type === "reference") as Reference
+        const reference = findPattern(value, p => p.type === "reference") as Reference;
         const result = reference.test("[1]");
-        expect(result).toBeTruthy()
+        expect(result).toBeTruthy();
     });
 
     test("Test No Match", () => {
         const value = createValuePattern();
-        const reference = findPattern(value, p => p.type === "reference") as Reference
+        const reference = findPattern(value, p => p.type === "reference") as Reference;
         const result = reference.test("B");
-        expect(result).toBeFalsy()
+        expect(result).toBeFalsy();
     });
 
     test("Find Pattern", () => {
@@ -134,7 +133,7 @@ describe("Reference", () => {
         const reference = new Reference("ref-name");
         const tokens = reference.getNextTokens();
 
-        expect(tokens).toEqual([])
+        expect(tokens).toEqual([]);
     });
 
     test("Get Tokens After", () => {
@@ -149,7 +148,7 @@ describe("Reference", () => {
         const reference = new Reference("ref-name");
         const tokens = reference.getTokensAfter(new Literal("bogus", "Bogus"));
 
-        expect(tokens).toEqual([])
+        expect(tokens).toEqual([]);
     });
 
     test("Get Patterns", () => {
@@ -178,7 +177,7 @@ describe("Reference", () => {
         const reference = new Reference("ref-name");
         const patterns = reference.getPatternsAfter(new Literal("bogus", "Bogus"));
 
-        expect(patterns).toEqual([])
+        expect(patterns).toEqual([]);
     });
 
     test("Get Next Patterns", () => {
@@ -197,7 +196,7 @@ describe("Reference", () => {
         const reference = new Reference("ref-name");
         const patterns = reference.getNextPatterns();
 
-        expect(patterns).toEqual([])
+        expect(patterns).toEqual([]);
     });
 
 });

package/src/patterns/Reference.ts

@@ -2,15 +2,22 @@ import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
 import { Pattern } from "./Pattern";
 import { findPattern } from "./findPattern";
+import { ParseResult } from "./ParseResult";
+
+let idIndex = 0;
 
 export class Reference implements Pattern {
+  private _id: string;
   private _type: string;
   private _name: string;
   private _parent: Pattern | null;
-  private _isOptional: boolean;
   private _pattern: Pattern | null;
   private _children: Pattern[];
 
+  get id(): string {
+    return this._id;
+  }
+
   get type(): string {
     return this._type;
   }
@@ -28,18 +35,14 @@ export class Reference implements Pattern {
   }
 
   get children(): Pattern[] {
-    return this._children
-  }
-
-  get isOptional(): boolean {
-    return this._isOptional;
+    return this._children;
   }
 
-  constructor(name: string, isOptional = false) {
+  constructor(name: string) {
+    this._id = `reference-${idIndex++}`;
     this._type = "reference";
     this._name = name;
     this._parent = null;
-    this._isOptional = isOptional;
     this._pattern = null;
     this._children = [];
   }
@@ -51,8 +54,10 @@ export class Reference 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 {
@@ -73,7 +78,7 @@ export class Reference implements Pattern {
         throw new Error(`Couldn't find '${this._name}' pattern within tree.`);
       }
 
-      const clonedPattern = pattern.clone(this._name, this._isOptional);
+      const clonedPattern = pattern.clone();
       clonedPattern.parent = this;
 
       this._pattern = clonedPattern;
@@ -100,7 +105,7 @@ export class Reference implements Pattern {
       if (parent == null) {
         break;
       } else {
-        node = parent
+        node = parent;
       }
     }
 
@@ -121,7 +126,7 @@ export class Reference implements Pattern {
 
   getNextTokens(): string[] {
     if (this.parent == null) {
-      return []
+      return [];
     }
 
     return this.parent.getTokensAfter(this);
@@ -144,14 +149,20 @@ export class Reference implements Pattern {
       return [];
     }
 
-    return this.parent.getPatternsAfter(this)
+    return this.parent.getPatternsAfter(this);
   }
 
   find(_predicate: (p: Pattern) => boolean): Pattern | null {
     return null;
   }
 
-  clone(name = this._name, isOptional = this._isOptional): Pattern {
-    return new Reference(name, isOptional);
+  clone(name = this._name): Pattern {
+    const clone = new Reference(name);
+    clone._id = this._id;
+    return clone;
+  }
+
+  isEqual(pattern: Reference): boolean {
+    return pattern.type === this.type && pattern.name === this.name;
   }
 }