clarity-pattern-parser 5.0.0 → 6.0.0

package/src/patterns/Reference.test.ts

@@ -1,25 +1,28 @@
-import { Cursor, Repeat } from "..";
 import { Node } from "../ast/Node";
 import { And } from "./And";
+import { Cursor } from "./Cursor";
 import { findPattern } from "./findPattern";
 import { Literal } from "./Literal";
 import { Or } from "./Or";
+import { Pattern } from "./Pattern";
 import { Reference } from "./Reference";
 import { Regex } from "./Regex";
+import { Repeat } from "./Repeat";
 
 function createValuePattern() {
     const number = new Regex("number", "\\d+");
+    number.setTokens(["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]);
+
     const openBracket = new Literal("open-bracket", "[");
     const closeBracket = new Literal("close-bracket", "]");
     const divider = new Regex("divider", "\\s*,\\s+");
+    divider.setTokens([", "]);
+
     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]);
 
-    number.setTokens(["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]);
-    divider.setTokens([", "])
-
     return value;
 }
 
@@ -54,37 +57,30 @@ describe("Reference", () => {
         const value = createValuePattern();
         const ref = findPattern(value, (p) => p.type === "reference");
         const tokens = ref?.getTokens();
-        const expected = ["["];
+        const expected = [
+            "1",
+            "2",
+            "3",
+            "4",
+            "5",
+            "6",
+            "7",
+            "8",
+            "9",
+            "0",
+            "["
+        ];
 
         expect(tokens).toEqual(expected);
     });
 
-    test("Get Next Tokens", () => {
-        const value = createValuePattern();
-        const ref = findPattern(value, (p) => p.type === "reference");
-
-        // The value passed to getNextTokens doesn't matter.
-        // I just needed it to be a pattern.
-        const tokens = ref?.getNextTokens(value);
-        const expected = ["]"];
-
-        expect(tokens).toEqual(expected);
-    });
-
-    test("Get Next Tokens With No Parent", () => {
+    test("Get Tokens After With No Parent", () => {
         const ref = new Reference("bad-reference");
-        const tokens = ref.getNextTokens(new Literal("bogus", "bogus"))
+        const tokens = ref.getTokensAfter(new Literal("bogus", "bogus"))
 
         expect(tokens).toEqual([]);
     });
 
-    test("Get Next Pattern", () => {
-        const ref = new Reference("ref");
-        const nextPattern = ref.getNextPattern();
-
-        expect(nextPattern).toBeNull()
-    });
-
     test("Properties", () => {
         const ref = new Reference("ref");
 
@@ -95,10 +91,103 @@ describe("Reference", () => {
         expect(ref.children).toEqual([])
     });
 
-    test("Parse Text", () => {
+    test("Exec", () => {
         const value = createValuePattern();
         const reference = findPattern(value, p => p.type === "reference") as Reference
-        const { ast: result } = reference.parseText("B");
+        const { ast: result } = reference.exec("B");
         expect(result).toBeNull()
     });
+
+    test("Test With Match", () => {
+        const value = createValuePattern();
+        const reference = findPattern(value, p => p.type === "reference") as Reference
+        const result = reference.test("[1]");
+        expect(result).toBeTruthy()
+    });
+
+    test("Test No Match", () => {
+        const value = createValuePattern();
+        const reference = findPattern(value, p => p.type === "reference") as Reference
+        const result = reference.test("B");
+        expect(result).toBeFalsy()
+    });
+
+    test("Find Pattern", () => {
+        const value = createValuePattern();
+        const reference = value.findPattern(p => p.type === "reference") as Pattern;
+
+        const pattern = reference?.findPattern(p => p.name === "Nada");
+
+        expect(pattern).toBe(null);
+    });
+
+
+    test("Get Next Tokens", () => {
+        const value = createValuePattern();
+        const reference = value.findPattern(p => p.type === "reference") as Pattern;
+        const tokens = reference.getNextTokens();
+
+        expect(tokens).toEqual([", ", "]"]);
+    });
+
+    test("Get Next Tokens With Null Parent", () => {
+        const reference = new Reference("ref-name");
+        const tokens = reference.getNextTokens();
+
+        expect(tokens).toEqual([])
+    });
+
+    test("Get Tokens After", () => {
+        const value = createValuePattern();
+        const reference = value.findPattern(p => p.type === "reference") as Pattern;
+        const tokens = reference.getTokensAfter(new Literal("bogus", "Bogus"));
+
+        expect(tokens).toEqual([", ", "]"]);
+    });
+
+    test("Get Tokens After With Null Parent", () => {
+        const reference = new Reference("ref-name");
+        const tokens = reference.getTokensAfter(new Literal("bogus", "Bogus"));
+
+        expect(tokens).toEqual([])
+    });
+
+    test("Get Patterns After", () => {
+        const value = createValuePattern();
+        const reference = value.findPattern(p => p.type === "reference") as Pattern;
+        const patterns = reference.getPatternsAfter(new Literal("bogus", "Bogus"));
+
+        expect(patterns.length).toEqual(2);
+        expect(patterns[0].type).toEqual("regex");
+        expect(patterns[0].name).toEqual("divider");
+        expect(patterns[1].type).toEqual("literal");
+        expect(patterns[1].name).toEqual("close-bracket");
+    });
+
+    test("Get Patterns After With Null Parent", () => {
+        const reference = new Reference("ref-name");
+        const patterns = reference.getPatternsAfter(new Literal("bogus", "Bogus"));
+
+        expect(patterns).toEqual([])
+    });
+
+    test("Get Next Patterns", () => {
+        const value = createValuePattern();
+        const reference = value.findPattern(p => p.type === "reference") as Pattern;
+        const patterns = reference.getNextPatterns();
+
+        expect(patterns.length).toEqual(2);
+        expect(patterns[0].type).toEqual("regex");
+        expect(patterns[0].name).toEqual("divider");
+        expect(patterns[1].type).toEqual("literal");
+        expect(patterns[1].name).toEqual("close-bracket");
+    });
+
+    test("Get Next Patterns With Null Parent", () => {
+        const reference = new Reference("ref-name");
+        const patterns = reference.getNextPatterns();
+
+        expect(patterns).toEqual([])
+    });
+
 });

package/src/patterns/Reference.ts

@@ -2,7 +2,6 @@ import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
 import { Pattern } from "./Pattern";
 import { findPattern } from "./findPattern";
-import { getNextPattern } from "./getNextPattern";
 
 export class Reference implements Pattern {
   private _type: string;
@@ -20,10 +19,6 @@ export class Reference implements Pattern {
     return this._name;
   }
 
-  get isOptional(): boolean {
-    return this._isOptional;
-  }
-
   get parent(): Pattern | null {
     return this._parent;
   }
@@ -36,6 +31,10 @@ export class Reference implements Pattern {
     return this._children
   }
 
+  get isOptional(): boolean {
+    return this._isOptional;
+  }
+
   constructor(name: string, isOptional: boolean = false) {
     this._type = "reference";
     this._name = name;
@@ -45,12 +44,19 @@ export class Reference implements Pattern {
     this._children = [];
   }
 
-  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
     };
   }
@@ -59,30 +65,6 @@ export class Reference implements Pattern {
     return this._getPatternSafely().parse(cursor);
   }
 
-  clone(name = this._name, isOptional = this._isOptional): Pattern {
-    return new Reference(name, isOptional);
-  }
-
-  getTokens(): string[] {
-    return this._getPatternSafely().getTokens();
-  }
-
-  getNextTokens(_lastMatched: Pattern): string[] {
-    if (this.parent == null) {
-      return [];
-    }
-
-    return this.parent.getNextTokens(this);
-  }
-
-  getNextPattern(): Pattern | null {
-    return getNextPattern(this)
-  }
-
-  findPattern(_isMatch: (p: Pattern)=>boolean): Pattern | null{
-    return null;
-  }
-
   private _getPatternSafely(): Pattern {
     if (this._pattern === null) {
       const pattern = this._findPattern();
@@ -124,4 +106,48 @@ export class Reference implements Pattern {
 
     return node;
   }
+
+  getTokens(): string[] {
+    return this._getPatternSafely().getTokens();
+  }
+
+  getTokensAfter(_lastMatched: Pattern): string[] {
+    if (this._parent == null) {
+      return [];
+    }
+
+    return this._parent.getTokensAfter(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(_predicate: (p: Pattern) => boolean): Pattern | null {
+    return null;
+  }
+
+  clone(name = this._name, isOptional = this._isOptional): Pattern {
+    return new Reference(name, isOptional);
+  }
 }

package/src/patterns/Regex.test.ts

@@ -3,6 +3,7 @@ import { Regex } from "./Regex";
 import { Node } from "../ast/Node"
 import { And } from "./And";
 import { Literal } from "./Literal";
+import { Pattern } from "./Pattern";
 
 describe("Regex", () => {
     test("Empty String", () => {
@@ -38,52 +39,24 @@ describe("Regex", () => {
 
 
     test("Get Tokens", () => {
-        const parent = new And("parent", [
-            new Regex("a", "A"),
-            new Regex("b", "B")
-        ]);
-
-        const a = parent.children[0] as Regex;
-        const b = parent.children[1] as Regex;
+        const a = new Regex("a", "A");
 
         a.setTokens(["A"]);
-        b.setTokens(["B"]);
-
-        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 regex = new Regex("a", "A");
-        const tokens = regex.getNextTokens(new Literal("bogus", "bogus"));
+        const tokens = regex.getTokensAfter(new Literal("bogus", "bogus"));
         const expected: string[] = [];
 
         expect(tokens).toEqual(expected)
     });
 
-    test("Get Next Pattern", () => {
-        const regex = new Regex("a", "A");
-        const nextPattern = regex.getNextPattern();
-
-        expect(nextPattern).toBeNull()
-    });
-
     test("Properties", () => {
         const regex = new Regex("a", "A");
 
@@ -93,9 +66,68 @@ describe("Regex", () => {
         expect(regex.children).toEqual([]);
     });
 
-    test("Parse Text", () => {
+    test("Exec", () => {
         const regex = new Regex("a", "A");
-        const { ast: result } = regex.parseText("B");
+        const { ast: result } = regex.exec("B");
         expect(result).toBeNull();
     });
+
+    test("Test With Match", () => {
+        const regex = new Regex("a", "A");
+        const result = regex.test("A");
+        expect(result).toBeTruthy();
+    });
+
+    test("Test With No Match", () => {
+        const regex = new Regex("a", "A");
+        const result = regex.test("B");
+        expect(result).toBeFalsy();
+    });
+
+    test("Get Next Tokens", () => {
+        const parent = new And("parent", [new Regex("a", "A"), new Literal("b", "B")]);
+        const aClone = parent.findPattern(p => p.name === "a") as Pattern;
+        const tokens = aClone.getNextTokens();
+
+        expect(tokens).toEqual(["B"]);
+    });
+
+    test("Get Next Tokens With Null Parent", () => {
+        const a = new Regex("a", "A")
+        const tokens = a.getNextTokens();
+
+        expect(tokens).toEqual([]);
+    });
+
+    test("Get Patterns After", () => {
+        const a = new Regex("a", "A")
+        const patterns = a.getPatternsAfter(new Literal("bogus", "bogus"));
+
+        expect(patterns).toEqual([]);
+    });
+
+    test("Find Pattern", () => {
+        const a = new Regex("a", "A")
+        const pattern = a.findPattern(p => p.name === "other");
+
+        expect(pattern).toBeNull();
+    });
+
+    test("Get Next Patterns", () => {
+        const parent = new And("parent", [new Regex("a", "A"), new Literal("b", "B")]);
+        const aClone = parent.findPattern(p => p.name === "a") as Pattern;
+        const bClone = parent.findPattern(p => p.name === "b") as Pattern;
+        const patterns = aClone.getNextPatterns();
+
+        expect(patterns.length).toBe(1);
+        expect(patterns[0]).toBe(bClone);
+    });
+
+    test("Get Next Patterns With Null Parent", () => {
+        const a = new Regex("a", "A")
+        const patterns = a.getNextPatterns();
+
+        expect(patterns).toEqual([])
+    });
+
 });

package/src/patterns/Regex.ts

@@ -1,7 +1,6 @@
 import { Node } from "../ast/Node";
 import { Pattern } from "./Pattern";
 import { Cursor } from "./Cursor";
-import { getNextPattern } from "./getNextPattern";
 
 export class Regex implements Pattern {
   private _type: string;
@@ -14,8 +13,6 @@ export class Regex implements Pattern {
   private _cursor: Cursor | null = null;
   private _substring: string = "";
   private _tokens: string[] = [];
-  private _hasContextualTokenAggregation = false;
-  private _isRetrievingContextualTokens: boolean = false;
 
   get type(): string {
     return this._type;
@@ -71,12 +68,19 @@ export class Regex 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
     };
   }
@@ -114,7 +118,7 @@ export class Regex implements Pattern {
       this._name,
       currentIndex,
       newIndex,
-      [],
+      undefined,
       result[0]
     );
 
@@ -133,60 +137,44 @@ export class Regex implements Pattern {
   clone(name = this._name, isOptional = this._isOptional) {
     const pattern = new Regex(name, this._originalRegexString, isOptional);
     pattern._tokens = this._tokens.slice();
-    pattern._hasContextualTokenAggregation =
-      this._hasContextualTokenAggregation;
 
     return pattern;
   }
 
   getTokens() {
-    const parent = this._parent;
-
-    if (this._hasContextualTokenAggregation &&
-      parent != null &&
-      !this._isRetrievingContextualTokens
-    ) {
-      this._isRetrievingContextualTokens = true;
-
-      const tokens = this._tokens;
-      const aggregateTokens: string[] = [];
-      const nextTokens = parent.getNextTokens(this);
-
-      for (let nextToken of nextTokens) {
-        for (let token of tokens) {
-          aggregateTokens.push(token + nextToken);
-        }
-      }
-
-      this._isRetrievingContextualTokens = false
-      return aggregateTokens;
-    }
-
     return this._tokens;
   }
 
-  getNextTokens(_reference: Pattern): string[] {
+  getTokensAfter(_childReference: Pattern): string[] {
     return [];
   }
 
-  getNextPattern(): Pattern | null {
-    return getNextPattern(this)
+  getNextTokens(): string[] {
+    if (this.parent == null) {
+      return []
+    }
+
+    return this.parent.getTokensAfter(this);
   }
-  
-  findPattern(_isMatch: (p: Pattern)=>boolean): Pattern | null{
-    return null;
+
+  getPatternsAfter(_childReference: Pattern): Pattern[] {
+    return [];
   }
 
-  setTokens(tokens: string[]) {
-    this._tokens = tokens;
+  getNextPatterns(): Pattern[] {
+    if (this.parent == null) {
+      return [];
+    }
+
+    return this.parent.getPatternsAfter(this)
   }
 
-  enableContextualTokenAggregation() {
-    this._hasContextualTokenAggregation = true;
+  findPattern(_predicate: (p: Pattern) => boolean): Pattern | null {
+    return null;
   }
 
-  disableContextualTokenAggregation() {
-    this._hasContextualTokenAggregation = false;
+  setTokens(tokens: string[]) {
+    this._tokens = tokens;
   }
 
 }