clarity-pattern-parser 8.4.15 → 9.1.0

package/src/patterns/Literal.ts

@@ -1,18 +1,25 @@
 import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
 import { Pattern } from "./Pattern";
 
+let idIndex = 0;
+
 export class Literal implements Pattern {
+  private _id: string;
   private _type: string;
   private _name: string;
   private _parent: Pattern | null;
-  private _isOptional: boolean;
-  private _literal: string;
+  private _text: string;
   private _runes: string[];
   private _firstIndex: number;
   private _lastIndex: number;
   private _endIndex: number;
 
+  get id(): string {
+    return this._id;
+  }
+
   get type(): string {
     return this._type;
   }
@@ -21,6 +28,10 @@ export class Literal implements Pattern {
     return this._name;
   }
 
+  get value(): string {
+    return this._text;
+  }
+
   get parent(): Pattern | null {
     return this._parent;
   }
@@ -33,20 +44,16 @@ export class Literal implements Pattern {
     return [];
   }
 
-  get isOptional(): boolean {
-    return this._isOptional;
-  }
-
-  constructor(name: string, value: string, isOptional = false) {
+  constructor(name: string, value: string) {
     if (value.length === 0) {
       throw new Error("Value Cannot be empty.");
     }
 
+    this._id = `literal-${idIndex++}`;
     this._type = "literal";
     this._name = name;
-    this._literal = value;
+    this._text = value;
     this._runes = Array.from(value);
-    this._isOptional = isOptional;
     this._parent = null;
     this._firstIndex = 0;
     this._lastIndex = 0;
@@ -60,8 +67,10 @@ export class Literal 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 {
@@ -71,6 +80,8 @@ export class Literal implements Pattern {
   }
 
   parse(cursor: Cursor): Node | null {
+    cursor.startParseWith(this);
+
     this._firstIndex = cursor.index;
 
     const passed = this._tryToParse(cursor);
@@ -80,16 +91,12 @@ export class Literal implements Pattern {
       const node = this._createNode();
       cursor.recordMatch(this, node);
 
+      cursor.endParse();
       return node;
     }
 
-    if (!this._isOptional) {
-      cursor.recordErrorAt(this._firstIndex, this._endIndex, this)
-      return null;
-    }
-
-    cursor.resolveError();
-    cursor.moveTo(this._firstIndex);
+    cursor.recordErrorAt(this._firstIndex, this._endIndex, this);
+    cursor.endParse();
     return null;
   }
 
@@ -103,11 +110,11 @@ export class Literal implements Pattern {
 
       if (literalRune !== cursorRune) {
         this._endIndex = cursor.index;
-        break
+        break;
       }
 
       if (i + 1 === literalRuneLength) {
-        this._lastIndex = this._firstIndex + this._literal.length - 1;
+        this._lastIndex = this._firstIndex + this._text.length - 1;
         passed = true;
         break;
       }
@@ -120,7 +127,7 @@ export class Literal implements Pattern {
       cursor.next();
     }
 
-    return passed
+    return passed;
   }
 
   private _createNode(): Node {
@@ -130,17 +137,18 @@ export class Literal implements Pattern {
       this._firstIndex,
       this._lastIndex,
       undefined,
-      this._literal
+      this._text
     );
   }
 
-  clone(name = this._name, isOptional = this._isOptional): Pattern {
-    const clone = new Literal(name, this._literal, isOptional);
+  clone(name = this._name): Pattern {
+    const clone = new Literal(name, this._text);
+    clone._id = this._id;
     return clone;
   }
 
   getTokens(): string[] {
-    return [this._literal];
+    return [this._text];
   }
 
   getTokensAfter(_lastMatched: Pattern): string[] {
@@ -149,7 +157,7 @@ export class Literal implements Pattern {
 
   getNextTokens(): string[] {
     if (this.parent == null) {
-      return []
+      return [];
     }
 
     return this.parent.getTokensAfter(this);
@@ -160,7 +168,7 @@ export class Literal implements Pattern {
   }
 
   getPatternsAfter(): Pattern[] {
-    return []
+    return [];
   }
 
   getNextPatterns(): Pattern[] {
@@ -168,11 +176,14 @@ export class Literal implements Pattern {
       return [];
     }
 
-    return this.parent.getPatternsAfter(this)
+    return this.parent.getPatternsAfter(this);
   }
 
   find(_predicate: (p: Pattern) => boolean): Pattern | null {
     return null;
   }
 
+  isEqual(pattern: Literal) {
+    return pattern.type === this.type && pattern._text === this._text;
+  }
 }

package/src/patterns/Not.test.ts

@@ -1,4 +1,4 @@
-import { And } from "./And";
+import { Sequence } from "./Sequence";
 import { Cursor } from "./Cursor";
 import { Literal } from "./Literal";
 import { Not } from "./Not";
@@ -86,7 +86,7 @@ describe("Not", () => {
 
     test("Get Next Tokens", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
-        const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
+        const sequence = new Sequence("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
 
         const cloneNotAboutUs = sequence.find(p => p.name === "not-about-us") as Pattern;
         const nextTokens = cloneNotAboutUs.getNextTokens() || [];
@@ -103,7 +103,7 @@ describe("Not", () => {
 
     test("Get Tokens", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
-        const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
+        const sequence = new Sequence("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
 
         const cloneNotAboutUs = sequence.find(p => p.name === "not-about-us") as Pattern;
         const nextTokens = cloneNotAboutUs.getTokens() || [];
@@ -113,7 +113,7 @@ describe("Not", () => {
 
     test("Get Tokens After", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
-        const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
+        const sequence = new Sequence("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
         const notAboutUsClone = sequence.find(p => p.name === "not-about-us") as Pattern;
         const aboutUsClone = sequence.find(p => p.name === "about-us") as Pattern;
         const nextTokens = notAboutUsClone.getTokensAfter(aboutUsClone) || [];
@@ -130,7 +130,7 @@ describe("Not", () => {
 
     test("Get Patterns", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
-        const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
+        const sequence = new Sequence("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
 
         const cloneNotAboutUs = sequence.find(p => p.name === "not-about-us") as Pattern;
         const nextPatterns = cloneNotAboutUs.getPatterns();
@@ -141,7 +141,7 @@ describe("Not", () => {
 
     test("Get Next Patterns", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
-        const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
+        const sequence = new Sequence("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
 
         const cloneNotAboutUs = sequence.find(p => p.name === "not-about-us") as Pattern;
         const patterns = cloneNotAboutUs.getNextPatterns() || [];
@@ -159,7 +159,7 @@ describe("Not", () => {
 
     test("Get Patterns After", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
-        const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
+        const sequence = new Sequence("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
         const notAboutUsClone = sequence.find(p => p.name === "not-about-us") as Pattern;
         const aboutUsClone = sequence.find(p => p.name === "about-us") as Pattern;
         const patterns = notAboutUsClone.getPatternsAfter(aboutUsClone) || [];

package/src/patterns/Not.ts

@@ -1,13 +1,21 @@
 import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
 import { Pattern } from "./Pattern";
 
+let idIndex = 0;
+
 export class Not implements Pattern {
+  private _id: string;
   private _type: string;
   private _name: string;
   private _parent: Pattern | null;
   private _children: Pattern[];
 
+  get id(): string {
+    return this._id;
+  }
+
   get type(): string {
     return this._type;
   }
@@ -33,10 +41,11 @@ export class Not implements Pattern {
   }
 
   constructor(name: string, pattern: Pattern) {
+    this._id = `not-${idIndex++}`;
     this._type = "not";
     this._name = name;
     this._parent = null;
-    this._children = [pattern.clone(pattern.name, false)];
+    this._children = [pattern.clone()];
     this._children[0].parent = this;
   }
 
@@ -47,17 +56,21 @@ export class Not implements Pattern {
     return !cursor.hasError;
   }
 
-  exec(text: string) {
+  exec(text: string, record = false): ParseResult {
     const cursor = new Cursor(text);
+    record && cursor.startRecording();
+
     const ast = this.parse(cursor);
 
     return {
-      ast,
+      ast: ast?.value === text ? ast : null,
       cursor
     };
   }
 
   parse(cursor: Cursor): Node | null {
+    cursor.startParseWith(this);
+
     const firstIndex = cursor.index;
     this._children[0].parse(cursor);
 
@@ -70,11 +83,13 @@ export class Not implements Pattern {
       cursor.recordErrorAt(firstIndex, firstIndex, this);
     }
 
+    cursor.endParse();
     return null;
   }
 
   clone(name = this._name): Pattern {
     const not = new Not(name, this._children[0]);
+    not._id = this._id;
     return not;
   }
 
@@ -100,7 +115,7 @@ export class Not implements Pattern {
 
   getNextTokens(): string[] {
     if (this.parent == null) {
-      return []
+      return [];
     }
 
     return this.parent.getTokensAfter(this);
@@ -117,7 +132,7 @@ export class Not implements Pattern {
       return parent.getPatternsAfter(this);
     }
 
-    return []
+    return [];
   }
 
   getNextPatterns(): Pattern[] {
@@ -125,11 +140,14 @@ export class Not implements Pattern {
       return [];
     }
 
-    return this.parent.getPatternsAfter(this)
+    return this.parent.getPatternsAfter(this);
   }
 
   find(predicate: (p: Pattern) => boolean): Pattern | null {
     return predicate(this._children[0]) ? this._children[0] : null;
   }
 
+  isEqual(pattern: Not): boolean {
+    return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+  }
 }

package/src/patterns/Optional.test.ts

@@ -0,0 +1,164 @@
+import { Literal } from "./Literal";
+import { Not } from "./Not";
+import { Optional } from "./Optional";
+import { Pattern } from "./Pattern";
+import { Sequence } from "./Sequence";
+
+describe("Optional", () => {
+    test("Match", () => {
+        const text = new Literal("text", "Text");
+        const optional = new Optional("optional-text", text);
+        const result = optional.exec("Text");
+
+        expect(result?.ast?.value).toBe("Text");
+        expect(result.cursor.index).toBe(3);
+    });
+
+    test("No Match", () => {
+        const text = new Literal("text", "Text");
+        const optional = new Optional("optional-text", text);
+        const result = optional.exec("Bad Text");
+
+        expect(result.ast).toBe(null);
+        expect(result.cursor.index).toBe(0);
+    });
+
+    test("Test Match", () => {
+        const text = new Literal("text", "Text");
+        const optional = new Optional("optional-text", text);
+        const result = optional.test("Text");
+
+        expect(result).toBeTruthy();
+    });
+
+    test("Test No Match", () => {
+        const text = new Literal("text", "Text");
+        const optional = new Optional("optional-text", text);
+        const result = optional.test("Bad Text");
+
+        expect(result).toBeTruthy();
+    });
+
+    test("Clone", () => {
+        const a = new Literal("a", "A");
+        const optionalA = new Optional("optional-a", a);
+        const clone = optionalA.clone();
+
+        expect(clone.name).toBe("optional-a");
+        expect(clone).not.toBe(optionalA);
+    });
+
+    test("Tokens", () => {
+        const a = new Literal("a", "A");
+        const optionalA = new Optional("optional-a", a);
+        const tokens = optionalA.getTokens();
+        const nextTokens = optionalA.getTokensAfter(new Literal("bogus", "bogus"));
+        const emptyArray: string[] = [];
+
+        expect(tokens).toEqual(["A"]);
+        expect(nextTokens).toEqual(emptyArray);
+    });
+
+    test("Properties", () => {
+        const a = new Literal("a", "A");
+        const optionalA = new Optional("optional-a", a);
+
+        expect(optionalA.type).toBe("optional");
+        expect(optionalA.name).toBe("optional-a");
+        expect(optionalA.parent).toBeNull();
+        expect(optionalA.children[0].name).toBe("a");
+    });
+
+    test("Get Next Tokens", () => {
+        const optionalAboutUs = new Optional("optional-about-us", new Literal("about-us", "About Us"));
+        const sequence = new Sequence("sequence", [optionalAboutUs, new Literal("about-them", "About Them")]);
+
+        const cloneOptionalAboutUs = sequence.find(p => p.name === "optional-about-us") as Pattern;
+        const nextTokens = cloneOptionalAboutUs.getNextTokens() || [];
+
+        expect(nextTokens[0]).toBe("About Them");
+    });
+
+    test("Get Next Tokens With No Parent", () => {
+        const optionalAboutUs = new Optional("optional-about-us", new Literal("about-us", "About Us"));
+        const nextTokens = optionalAboutUs.getNextTokens() || [];
+
+        expect(nextTokens.length).toBe(0);
+    });
+
+    test("Get Tokens", () => {
+        const optionalAboutUs = new Optional("optional-about-us", new Literal("about-us", "About Us"));
+        const sequence = new Sequence("sequence", [optionalAboutUs, new Literal("about-them", "About Them")]);
+
+        const cloneAboutUs = sequence.find(p => p.name === "optional-about-us") as Pattern;
+        const nextTokens = cloneAboutUs.getTokens() || [];
+
+        expect(nextTokens[0]).toBe("About Us");
+    });
+
+    test("Get Tokens After", () => {
+        const optionalAboutUs = new Optional("optional-about-us", new Literal("about-us", "About Us"));
+        const sequence = new Sequence("sequence", [optionalAboutUs, new Literal("about-them", "About Them")]);
+        const optionalAboutUsClone = sequence.find(p => p.name === "optional-about-us") as Pattern;
+        const aboutUsClone = sequence.find(p => p.name === "about-us") as Pattern;
+        const nextTokens = optionalAboutUsClone.getTokensAfter(aboutUsClone) || [];
+
+        expect(nextTokens[0]).toBe("About Them");
+    });
+
+    test("Find Pattern", () => {
+        const optionalAboutUs = new Optional("optional-about-us", new Literal("about-us", "About Us"));
+        const child = optionalAboutUs.find(p => p.name === "about-us");
+
+        expect(child).not.toBeNull();
+    });
+
+    test("Get Patterns", () => {
+        const optionalAboutUs = new Optional("optional-about-us", new Literal("about-us", "About Us"));
+        const sequence = new Sequence("sequence", [optionalAboutUs, new Literal("about-them", "About Them")]);
+
+        const cloneNotAboutUs = sequence.find(p => p.name === "optional-about-us") as Pattern;
+        const nextPatterns = cloneNotAboutUs.getPatterns();
+        const expected = [sequence.find(p => p.name === "about-us")];
+
+        expect(nextPatterns).toEqual(expected);
+    });
+
+    test("Get Next Patterns", () => {
+        const optionalAboutUs = new Optional("optional-about-us", new Literal("about-us", "About Us"));
+        const sequence = new Sequence("sequence", [optionalAboutUs, new Literal("about-them", "About Them")]);
+
+        const cloneNotAboutUs = sequence.find(p => p.name === "optional-about-us") as Pattern;
+        const patterns = cloneNotAboutUs.getNextPatterns() || [];
+
+        expect(patterns.length).toBe(1);
+        expect(patterns[0].name).toBe("about-them");
+    });
+
+    test("Get Next Patterns With No Parent", () => {
+        const optionalAboutUs = new Optional("optional-about-us", new Literal("about-us", "About Us"));
+        const patterns = optionalAboutUs.getNextPatterns() || [];
+
+        expect(patterns.length).toBe(0);
+    });
+
+    test("Get Patterns After", () => {
+        const optionalAboutUs = new Optional("optional-about-us", new Literal("about-us", "About Us"));
+        const sequence = new Sequence("sequence", [optionalAboutUs, new Literal("about-them", "About Them")]);
+        const optionalAboutUsClone = sequence.find(p => p.name === "optional-about-us") as Pattern;
+        const aboutUsClone = sequence.find(p => p.name === "about-us") as Pattern;
+        const patterns = optionalAboutUsClone.getPatternsAfter(aboutUsClone) || [];
+
+        expect(patterns.length).toBe(1);
+        expect(patterns[0].name).toBe("about-them");
+    });
+
+    test("Get Patterns After With Null Parent", () => {
+        const optionalAboutUs = new Optional("optional-about-us", new Literal("about-us", "About Us"));
+        const aboutUsClone = optionalAboutUs.find(p => p.name === "about-us") as Pattern;
+        const patterns = optionalAboutUs.getPatternsAfter(aboutUsClone) || [];
+
+        expect(patterns.length).toBe(0);
+    });
+
+});

package/src/patterns/Optional.ts

@@ -0,0 +1,143 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
+import { Pattern } from "./Pattern";
+
+let idIndex = 0;
+
+export class Optional implements Pattern {
+  private _id: string;
+  private _type: string;
+  private _name: string;
+  private _parent: Pattern | null;
+  private _children: Pattern[];
+
+  get id(): string {
+    return this._id;
+  }
+
+  get type(): string {
+    return this._type;
+  }
+
+  get name(): string {
+    return this._name;
+  }
+
+  get parent(): Pattern | null {
+    return this._parent;
+  }
+
+  set parent(pattern: Pattern | null) {
+    this._parent = pattern;
+  }
+
+  get children(): Pattern[] {
+    return this._children;
+  }
+
+  constructor(name: string, pattern: Pattern) {
+    this._id = `optional-${idIndex++}`;
+    this._type = "optional";
+    this._name = name;
+    this._parent = null;
+    this._children = [pattern.clone()];
+    this._children[0].parent = this;
+  }
+
+  test(text: string) {
+    const cursor = new Cursor(text);
+    this.parse(cursor);
+
+    return !cursor.hasError;
+  }
+
+  exec(text: string, record = false): ParseResult {
+    const cursor = new Cursor(text);
+    record && cursor.startRecording();
+
+    const ast = this.parse(cursor);
+
+    return {
+      ast: ast?.value === text ? ast : null,
+      cursor
+    };
+  }
+
+  parse(cursor: Cursor): Node | null {
+    cursor.startParseWith(this);
+
+    const firstIndex = cursor.index;
+    const node = this._children[0].parse(cursor);
+
+    if (cursor.hasError) {
+      cursor.resolveError();
+      cursor.moveTo(firstIndex);
+
+      cursor.endParse();
+      return null;
+    } else {
+      cursor.endParse();
+      return node;
+    }
+
+  }
+
+  clone(name = this._name): Pattern {
+    const optional = new Optional(name, this._children[0]);
+    optional._id = this._id;
+    return optional;
+  }
+
+  getTokens(): string[] {
+    return this._children[0].getTokens();
+  }
+
+  getTokensAfter(_childReference: Pattern): string[] {
+    const parent = this._parent;
+
+    if (parent != null) {
+      return parent.getTokensAfter(this);
+    }
+
+    return [];
+  }
+
+  getNextTokens(): string[] {
+    if (this.parent == null) {
+      return [];
+    }
+
+    return this.parent.getTokensAfter(this);
+  }
+
+  getPatterns(): Pattern[] {
+    return this._children[0].getPatterns();
+  }
+
+  getPatternsAfter(_childReference: Pattern): Pattern[] {
+    const parent = this._parent;
+
+    if (parent != null) {
+      return parent.getPatternsAfter(this);
+    }
+
+    return [];
+  }
+
+  getNextPatterns(): Pattern[] {
+    if (this.parent == null) {
+      return [];
+    }
+
+    return this.parent.getPatternsAfter(this);
+  }
+
+  find(predicate: (p: Pattern) => boolean): Pattern | null {
+    return predicate(this._children[0]) ? this._children[0] : null;
+  }
+
+  isEqual(pattern: Optional): boolean {
+    return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+  }
+}