clarity-pattern-parser 5.0.0 → 6.0.2

package/src/patterns/Literal.test.ts

@@ -70,53 +70,22 @@ describe("Literal", () => {
     });
 
     test("Get Tokens", () => {
-        const parent = new And("parent", [
-            new Literal("a", "A"),
-            new Literal("b", "B")
-        ]);
+        const a = new Literal("a", "A");
 
-        const a = parent.children[0] as Literal;
-        const b = parent.children[1];
-
-        let tokens = a.getTokens();
-        let expectedTokens = ["A"];
-
-        expect(tokens).toEqual(expectedTokens);
-
-        a.enableContextualTokenAggregation();
-
-        tokens = a.getTokens();
-        expectedTokens = ["AB"];
-
-        expect(tokens).toEqual(expectedTokens);
-
-        a.disableContextualTokenAggregation();
-
-        tokens = a.getTokens();
-        expectedTokens = ["A"];
+        const tokens = a.getTokens();
+        const expectedTokens = ["A"];
 
         expect(tokens).toEqual(expectedTokens);
     });
 
-    test("Get Next Tokens", () => {
+    test("Get Tokens After", () => {
         const literal = new Literal("a", "A");
-        const tokens = literal.getNextTokens(new Literal("bogus", "bogus"));
+        const tokens = literal.getTokensAfter(new Literal("bogus", "bogus"));
         const expected: string[] = [];
 
         expect(tokens).toEqual(expected)
     });
 
-    test("Get Next Pattern", () => {
-        const parent = new And("parent", [
-            new Literal("a", "A"),
-            new Literal("b", "B")
-        ]);
-
-        const nextPattern = parent.children[0].getNextPattern();
-
-        expect(nextPattern?.name).toBe("b")
-    });
-
     test("Properties", () => {
         const literal = new Literal("a", "A");
 
@@ -126,9 +95,81 @@ describe("Literal", () => {
         expect(literal.children).toEqual([]);
     });
 
-    test("Parse Text", () => {
+    test("Exec", () => {
         const literal = new Literal("a", "A");
-        const { ast: result } = literal.parseText("B");
+        const { ast: result } = literal.exec("B");
         expect(result).toBeNull()
     });
+
+    test("Test With No Match", () => {
+        const literal = new Literal("a", "A");
+        const isMatch = literal.test("B");
+
+        expect(isMatch).toBeFalsy();
+    });
+
+    test("Test With Match", () => {
+        const literal = new Literal("a", "A");
+        const isMatch = literal.test("A");
+
+        expect(isMatch).toBeTruthy();
+    });
+
+    test("Get Next Tokens", () => {
+        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const parent = new And("parent", [sequence, new Literal("b", "B")]);
+
+        const a = parent.findPattern(p => p.name === "a");
+        const tokens = a?.getNextTokens() || [];
+
+        expect(tokens[0]).toBe("B");
+    });
+
+    test("Get Next Tokens With Null Parent", () => {
+        const a = new Literal("a", "A");
+        const tokens = a.getNextTokens();
+
+        expect(tokens.length).toBe(0);
+    });
+
+    test("Get Patterns", () => {
+        const a = new Literal("a", "A");
+
+        const tokens = a.getPatterns();
+        const expectedTokens = [a];
+
+        expect(tokens).toEqual(expectedTokens);
+    });
+
+    test("Get Next Patterns", () => {
+        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const parent = new And("parent", [sequence, new Literal("b", "B")]);
+
+        const a = parent.findPattern(p => p.name === "a");
+        const nextPatterns = a?.getNextPatterns() || [];
+        const b = parent.findPattern(p => p.name === "b")
+
+        expect(nextPatterns[0]).toBe(b);
+    });
+
+    test("Get Next Patterns With Null Parent", () => {
+        const a = new Literal("a", "A");
+        const nextPatterns = a.getNextPatterns();
+
+        expect(nextPatterns.length).toBe(0);
+    });
+
+    test("Get Patterns After", () => {
+        const a = new Literal("a", "A");
+        const patterns = a.getPatternsAfter();
+
+        expect(patterns.length).toBe(0);
+    });
+
+    test("Find Pattern", () => {
+        const a = new Literal("a", "A");
+        const pattern = a.findPattern(p => p.name === "nada");
+
+        expect(pattern).toBeNull();
+    });
 });

package/src/patterns/Literal.ts

@@ -1,6 +1,5 @@
 import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
-import { getNextPattern } from "./getNextPattern";
 import { Pattern } from "./Pattern";
 
 export class Literal implements Pattern {
@@ -12,8 +11,6 @@ export class Literal implements Pattern {
   private _runes: string[];
   private _firstIndex: number;
   private _lastIndex: number;
-  private _hasContextualTokenAggregation: boolean;
-  private _isRetrievingContextualTokens: boolean;
 
   get type(): string {
     return this._type;
@@ -40,10 +37,10 @@ export class Literal implements Pattern {
   }
 
   constructor(name: string, value: string, isOptional = false) {
-    if (value.length === 0){
+    if (value.length === 0) {
       throw new Error("Value Cannot be empty.");
     }
-    
+
     this._type = "literal";
     this._name = name;
     this._literal = value;
@@ -52,16 +49,21 @@ export class Literal implements Pattern {
     this._parent = null;
     this._firstIndex = 0;
     this._lastIndex = 0;
-    this._hasContextualTokenAggregation = false;
-    this._isRetrievingContextualTokens = false;
   }
 
-  parseText(text: string) {
+  test(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor);
+
+    return ast?.value === text;
+  }
+
+  exec(text: string) {
     const cursor = new Cursor(text);
-    const ast = this.parse(cursor)
+    const ast = this.parse(cursor);
 
     return {
-      ast,
+      ast: ast?.value === text ? ast : null,
       cursor
     };
   }
@@ -123,59 +125,50 @@ export class Literal implements Pattern {
       this._name,
       this._firstIndex,
       this._lastIndex,
-      [],
+      undefined,
       this._literal
     );
   }
 
   clone(name = this._name, isOptional = this._isOptional): Pattern {
     const clone = new Literal(name, this._literal, isOptional);
-    clone._hasContextualTokenAggregation = this._hasContextualTokenAggregation;
     return clone;
   }
 
   getTokens(): string[] {
-    const parent = this._parent;
-
-    if (
-      this._hasContextualTokenAggregation &&
-      parent != null &&
-      !this._isRetrievingContextualTokens
-    ) {
-      this._isRetrievingContextualTokens = true;
-
-      const aggregateTokens: string[] = [];
-      const nextTokens = parent.getNextTokens(this);
+    return [this._literal];
+  }
 
-      for (const nextToken of nextTokens) {
-        aggregateTokens.push(this._literal + nextToken);
-      }
+  getTokensAfter(_lastMatched: Pattern): string[] {
+    return [];
+  }
 
-      this._isRetrievingContextualTokens = false;
-      return aggregateTokens;
-    } else {
-      return [this._literal];
+  getNextTokens(): string[] {
+    if (this.parent == null) {
+      return []
     }
-  }
 
-  getNextTokens(_lastMatched: Pattern): string[] {
-    return [];
+    return this.parent.getTokensAfter(this);
   }
 
-  getNextPattern(): Pattern | null {
-    return getNextPattern(this)
+  getPatterns(): Pattern[] {
+    return [this];
   }
 
-  findPattern(_isMatch: (p: Pattern) => boolean): Pattern | null {
-    return null;
+  getPatternsAfter(): Pattern[] {
+    return []
   }
 
-  enableContextualTokenAggregation(): void {
-    this._hasContextualTokenAggregation = true;
+  getNextPatterns(): Pattern[] {
+    if (this.parent == null) {
+      return [];
+    }
+
+    return this.parent.getPatternsAfter(this)
   }
 
-  disableContextualTokenAggregation(): void {
-    this._hasContextualTokenAggregation = false;
+  findPattern(_predicate: (p: Pattern) => boolean): Pattern | null {
+    return null;
   }
 
 }

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,112 @@ 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");
+    });
+
+    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 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 nextPatterns = cloneNotAboutUs.getPatterns();
+        const expected = [sequence.findPattern(p=>p.name === "about-them")];
 
-        expect(nextPattern?.name).toBe("b");
+        expect(nextPatterns).toEqual(expected);
     });
+
+    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);
+    this.parse(cursor);
+
+    return !cursor.hasError;
+  }
+
+  exec(text: string) {
     const cursor = new Cursor(text);
-    const ast = this.parse(cursor)
+    const ast = this.parse(cursor);
 
     return {
       ast,
@@ -72,20 +78,58 @@ 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);
+  }
+
+  getPatterns(): Pattern[] {
+    return [...this.getNextPatterns().map(p => p.getPatterns()).flat()];
+  }
+
+  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;
   }
 
 }