clarity-pattern-parser 5.0.0 → 6.0.0

package/src/patterns/Not.test.ts

@@ -2,6 +2,7 @@ import { And } from "./And";
 import { Cursor } from "./Cursor";
 import { Literal } from "./Literal";
 import { Not } from "./Not";
+import { Pattern } from "./Pattern";
 
 describe("Not", () => {
     test("Parse Successfully", () => {
@@ -37,7 +38,7 @@ describe("Not", () => {
         const a = new Literal("a", "A");
         const notA = new Not("not-a", a);
         const tokens = notA.getTokens();
-        const nextTokens = notA.getNextTokens(new Literal("bogus", "bogus"))
+        const nextTokens = notA.getTokensAfter(new Literal("bogus", "bogus"))
         const emptyArray: string[] = [];
 
         expect(tokens).toEqual(emptyArray);
@@ -67,22 +68,101 @@ describe("Not", () => {
         expect(cursor.hasError).toBeFalsy();
     });
 
-    test("Parse Text", () => {
+    test("Exec", () => {
         const a = new Literal("a", "A");
         const notA = new Not("not-a", a);
-        const { ast: result } = notA.parseText("A");
+        const { ast: result } = notA.exec("A");
 
         expect(result).toBeNull();
     });
 
-    test("Get Next Pattern", () => {
+    test("Test", () => {
         const a = new Literal("a", "A");
-        const b = new Literal("b", "B");
         const notA = new Not("not-a", a);
+        const result = notA.test("A");
 
-        const parent = new And("parent", [notA, b]);
-        const nextPattern = parent.children[0].getNextPattern();
+        expect(result).toBeFalsy();
+    });
+
+    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 cloneNotAboutUs = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
+        const nextTokens = cloneNotAboutUs.getNextTokens() || [];
+
+        expect(nextTokens[0]).toBe("About Them");
+    });
+
+    test("Get Next Tokens With No Parent", () => {
+        const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
+        const nextTokens = notAboutUs.getNextTokens() || [];
+
+        expect(nextTokens.length).toBe(0);
+    });
+
+    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 cloneNotAboutUs = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
+        const nextTokens = cloneNotAboutUs.getTokens() || [];
+
+        expect(nextTokens[0]).toBe("About Them");
+    });
+
+    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 notAboutUsClone = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
+        const aboutUsClone = sequence.findPattern(p => p.name === "about-us") as Pattern;
+        const nextTokens = notAboutUsClone.getTokensAfter(aboutUsClone) || [];
+
+        expect(nextTokens[0]).toBe("About Them");
+    });
 
-        expect(nextPattern?.name).toBe("b");
+    test("Find Pattern", () => {
+        const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
+        const child = notAboutUs.findPattern(p => p.name === "about-us")
+
+        expect(child).not.toBeNull();
+    });
+
+    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 cloneNotAboutUs = sequence.findPattern(p => p.name === "not-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 notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
+        const patterns = notAboutUs.getNextPatterns() || [];
+
+        expect(patterns.length).toBe(0);
     });
+
+    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 notAboutUsClone = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
+        const aboutUsClone = sequence.findPattern(p => p.name === "about-us") as Pattern;
+        const patterns = notAboutUsClone.getPatternsAfter(aboutUsClone) || [];
+
+        expect(patterns.length).toBe(1);
+        expect(patterns[0].name).toBe("about-them");
+    });
+
+    test("Get Patterns After With Null Parent", () => {
+        const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
+        const aboutUsClone = notAboutUs.findPattern(p => p.name === "about-us") as Pattern;
+        const patterns = notAboutUs.getPatternsAfter(aboutUsClone) || [];
+
+        expect(patterns.length).toBe(0);
+    });
+
 });

package/src/patterns/Not.ts

@@ -1,6 +1,5 @@
 import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
-import { getNextPattern } from "./getNextPattern";
 import { Pattern } from "./Pattern";
 
 export class Not implements Pattern {
@@ -17,10 +16,6 @@ export class Not implements Pattern {
     return this._name;
   }
 
-  get isOptional(): boolean {
-    return false;
-  }
-
   get parent(): Pattern | null {
     return this._parent;
   }
@@ -33,6 +28,10 @@ export class Not implements Pattern {
     return this._children;
   }
 
+  get isOptional(): boolean {
+    return false;
+  }
+
   constructor(name: string, pattern: Pattern) {
     this._type = "not";
     this._name = name;
@@ -41,9 +40,16 @@ export class Not implements Pattern {
     this._children[0].parent = this;
   }
 
-  parseText(text: string) {
+  test(text: string) {
     const cursor = new Cursor(text);
-    const ast = this.parse(cursor)
+    this.parse(cursor);
+
+    return !cursor.hasError;
+  }
+
+  exec(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor);
 
     return {
       ast,
@@ -72,20 +78,54 @@ export class Not implements Pattern {
     return not;
   }
 
-  getNextPattern(): Pattern | null {
-    return getNextPattern(this)
-  }
-
   getTokens(): string[] {
+    const parent = this._parent;
+
+    if (parent != null) {
+      return parent.getTokensAfter(this);
+    }
+
     return [];
   }
 
-  getNextTokens(_lastMatched: Pattern): string[] {
+  getTokensAfter(_childReference: Pattern): string[] {
+    const parent = this._parent;
+
+    if (parent != null) {
+      return parent.getTokensAfter(this);
+    }
+
     return [];
   }
 
-  findPattern(isMatch: (p: Pattern) => boolean): Pattern | null {
-    return isMatch(this._children[0]) ? this._children[0] : null;
+  getNextTokens(): string[] {
+    if (this.parent == null) {
+      return []
+    }
+
+    return this.parent.getTokensAfter(this);
+  }
+
+  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)
+  }
+
+  findPattern(predicate: (p: Pattern) => boolean): Pattern | null {
+    return predicate(this._children[0]) ? this._children[0] : null;
   }
 
 }

package/src/patterns/Or.test.ts

@@ -3,6 +3,7 @@ import { Node } from "../ast/Node";
 import { Literal } from "./Literal";
 import { Or } from "./Or";
 import { And } from "./And";
+import { Pattern } from "./Pattern";
 
 describe("Or", () => {
     test("Empty Options", () => {
@@ -63,30 +64,23 @@ describe("Or", () => {
         expect(tokens).toEqual(expected);
     });
 
-    test("Get Next Tokens", () => {
+    test("Get Tokens After", () => {
         const a = new Or("a", [new Literal("a", "A")]);
         const parent = new And("parent", [a, new Literal("b", "B")]);
-        const tokens = parent.children[0].getNextTokens(parent.children[0].children[0]);
+        const tokens = parent.children[0].getTokensAfter(parent.children[0].children[0]);
         const expected = ["B"];
 
         expect(tokens).toEqual(expected);
     });
 
-    test("Get Next Tokens Without A Parent", () => {
+    test("Get Tokens After Without A Parent", () => {
         const a = new Or("a", [new Literal("a", "A")]);
-        const tokens = a.getNextTokens(a.children[0]);
+        const tokens = a.getTokensAfter(a.children[0]);
         const expected: string[] = [];
 
         expect(tokens).toEqual(expected);
     });
 
-    test("Get Next Pattern", () => {
-        const a = new Or("a", [new Literal("a", "A")]);
-        const nextToken = a.getNextPattern();
-
-        expect(nextToken).toBeNull();
-    });
-
     test("Properties", () => {
         const a = new Or("a", [new Literal("a", "A")]);
 
@@ -97,9 +91,119 @@ describe("Or", () => {
         expect(a.children[0].name).toBe("a");
     });
 
-    test("Parse Text", () => {
+    test("Exec", () => {
         const a = new Or("a", [new Literal("a", "A")]);
-        const { ast: result } = a.parseText("B");
+        const { ast: result } = a.exec("B");
         expect(result).toBeNull();
     });
+
+    test("Test No Match", () => {
+        const a = new Or("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 result = a.test("A");
+        expect(result).toBeTruthy();
+    });
+
+    test("Get Next Tokens", () => {
+        const sequence = new And("sequence", [
+            new Or("a-or-b", [
+                new Literal("a", "A"),
+                new Literal("b", "B")
+            ]),
+            new Literal("c", "C")
+        ]);
+
+        const orClone = sequence.findPattern(p => p.name === "a-or-b") as Pattern;
+        const tokens = orClone.getNextTokens();
+
+        expect(tokens.length).toBe(1);
+        expect(tokens[0]).toBe("C");
+    });
+
+    test("Get Next Tokens With Null Parent", () => {
+        const or = new Or("a-or-b", [
+            new Literal("a", "A"),
+            new Literal("b", "B")
+        ])
+
+        const tokens = or.getNextTokens();
+        expect(tokens.length).toBe(0);
+    });
+
+
+    test("Get Tokens After", () => {
+        const sequence = new And("sequence", [
+            new Or("a-or-b", [
+                new Literal("a", "A"),
+                new Literal("b", "B")
+            ]),
+            new Literal("c", "C")
+        ]);
+
+        const aClone = sequence.findPattern(p => p.name === "a") as Pattern;
+        const orClone = sequence.findPattern(p => p.name === "a-or-b") as Pattern;
+        const tokens = orClone.getTokensAfter(aClone);
+
+        expect(tokens.length).toBe(1);
+        expect(tokens[0]).toBe("C");
+    });
+
+    test("Get Patterns After", () => {
+        const sequence = new And("sequence", [
+            new Or("a-or-b", [
+                new Literal("a", "A"),
+                new Literal("b", "B")
+            ]),
+            new Literal("c", "C")
+        ]);
+
+        const aClone = sequence.findPattern(p => p.name === "a") as Pattern;
+        const orClone = sequence.findPattern(p => p.name === "a-or-b") as Pattern;
+        const patterns = orClone.getPatternsAfter(aClone);
+
+        expect(patterns.length).toBe(1);
+        expect(patterns[0].name).toBe("c");
+    });
+
+    test("Get Patterns After With Null Parent", () => {
+        const or = new Or("a-or-b", [
+            new Literal("a", "A"),
+            new Literal("b", "B")
+        ])
+        const aClone = or.findPattern(p => p.name === "a") as Pattern;
+        const patterns = or.getPatternsAfter(aClone);
+
+        expect(patterns.length).toBe(0);
+    });
+
+    test("Get Next Patterns", () => {
+        const sequence = new And("sequence", [
+            new Or("a-or-b", [
+                new Literal("a", "A"),
+                new Literal("b", "B")
+            ]),
+            new Literal("c", "C")
+        ]);
+
+        const orClone = sequence.findPattern(p => p.name === "a-or-b") as Pattern;
+        const patterns = orClone.getNextPatterns();
+
+        expect(patterns.length).toBe(1);
+        expect(patterns[0].name).toBe("c");
+    });
+
+    test("Get Next Patterns With Null Parent", () => {
+        const or = new Or("a-or-b", [
+            new Literal("a", "A"),
+            new Literal("b", "B")
+        ])
+        const patterns = or.getNextPatterns();
+
+        expect(patterns.length).toBe(0);
+    });
 });

package/src/patterns/Or.ts

@@ -2,7 +2,6 @@ import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
 import { Pattern } from "./Pattern";
 import { clonePatterns } from "./clonePatterns";
-import { getNextPattern } from "./getNextPattern";
 import { findPattern } from "./findPattern";
 
 export class Or implements Pattern {
@@ -11,7 +10,6 @@ export class Or implements Pattern {
   private _parent: Pattern | null;
   private _children: Pattern[];
   private _isOptional: boolean;
-  private _node: Node | null;
   private _firstIndex: number;
 
   get type(): string {
@@ -51,7 +49,6 @@ export class Or implements Pattern {
     this._parent = null;
     this._children = children;
     this._isOptional = isOptional;
-    this._node = null;
     this._firstIndex = 0;
   }
 
@@ -61,19 +58,25 @@ export class Or implements Pattern {
     }
   }
 
-  parseText(text: string) {
+  test(text: string) {
     const cursor = new Cursor(text);
-    const ast = this.parse(cursor)
+    const ast = this.parse(cursor);
+
+    return ast?.value === text;
+  }
+
+  exec(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor);
 
     return {
-      ast,
+      ast: ast?.value === text ? ast : null,
       cursor
     };
   }
 
   parse(cursor: Cursor): Node | null {
     this._firstIndex = cursor.index;
-    this._node = null;
 
     const node = this._tryToParse(cursor);
 
@@ -117,20 +120,40 @@ export class Or implements Pattern {
     return tokens;
   }
 
-  getNextTokens(_lastMatched: Pattern): string[] {
+  getTokensAfter(_childReference: Pattern): string[] {
     if (this._parent === null) {
       return [];
     }
 
-    return this._parent.getNextTokens(this);
+    return this._parent.getTokensAfter(this);
   }
 
-  getNextPattern(): Pattern | null {
-    return getNextPattern(this)
+  getNextTokens(): string[] {
+    if (this._parent == null) {
+      return []
+    }
+
+    return this._parent.getTokensAfter(this);
+  }
+
+  getPatternsAfter(_childReference: Pattern): Pattern[] {
+    if (this._parent === null) {
+      return [];
+    }
+
+    return this._parent.getPatternsAfter(this)
+  }
+
+  getNextPatterns(): Pattern[] {
+    if (this.parent == null) {
+      return [];
+    }
+
+    return this.parent.getPatternsAfter(this)
   }
 
-  findPattern(isMatch: (p: Pattern)=>boolean): Pattern | null{
-    return findPattern(this, isMatch);
+  findPattern(predicate: (p: Pattern) => boolean): Pattern | null {
+    return findPattern(this, predicate);
   }
 
   clone(name = this._name, isOptional = this._isOptional): Pattern {

package/src/patterns/Pattern.ts

@@ -10,10 +10,13 @@ export interface Pattern {
   isOptional: boolean;
 
   parse(cursor: Cursor): Node | null;
-  parseText(text: string): ParseResult;
+  exec(text: string): ParseResult;
+  test(text: string): boolean;
   clone(name?: string, isOptional?: boolean): Pattern;
   getTokens(): string[];
-  getNextTokens(lastMatched: Pattern): string[];
-  getNextPattern(): Pattern | null;
-  findPattern(isMatch:(p: Pattern)=>boolean): Pattern | null;
+  getTokensAfter(childReference: Pattern): string[];
+  getPatternsAfter(childReference: Pattern): Pattern[];
+  getNextPatterns(): Pattern[];
+  getNextTokens(): string[];
+  findPattern(predicate: (p: Pattern) => boolean): Pattern | null;
 }