clarity-pattern-parser 5.0.0 → 6.0.2

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,77 @@ 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", () => {
+        const a = new Regex("a", "A");
+
+        const tokens = a.getPatterns();
+        const expectedTokens = [a];
+
+        expect(tokens).toEqual(expectedTokens);
+    });
+
+    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,48 @@ 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;
+
+  getPatterns(): Pattern[] {
+    return [this];
   }
 
-  setTokens(tokens: string[]) {
-    this._tokens = tokens;
+  getPatternsAfter(_childReference: Pattern): Pattern[] {
+    return [];
+  }
+
+  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;
   }
 
 }

package/src/patterns/Repeat.test.ts

@@ -3,6 +3,7 @@ import { And } from "./And";
 import { Cursor } from "./Cursor";
 import { findPattern } from "./findPattern";
 import { Literal } from "./Literal";
+import { Pattern } from "./Pattern";
 import { Regex } from "./Regex";
 import { Repeat } from "./Repeat";
 
@@ -96,31 +97,6 @@ describe("Repeat", () => {
         expect(cursor.hasError).toBeFalsy()
     });
 
-    test("Ast Reduction", () => {
-        const digit = new Regex("digit", "\\d");
-        const integer = new Repeat("number", digit);
-        const cursor = new Cursor("337");
-
-        integer.enableAstReduction();
-
-        let result = integer.parse(cursor);
-        let expected = new Node("repeat", "number", 0, 2, [], "337");
-
-        expect(result).toEqual(expected)
-
-        integer.disableAstReduction()
-        cursor.moveTo(0)
-
-        result = integer.parse(cursor);
-        expected = new Node("repeat", "number", 0, 2, [
-            new Node("regex", "digit", 0, 0, [], "3"),
-            new Node("regex", "digit", 1, 1, [], "3"),
-            new Node("regex", "digit", 2, 2, [], "7"),
-        ]);
-
-        expect(result).toEqual(expected)
-    });
-
     test("Get Tokens", () => {
         const a = new Literal("a", "A");
         const manyA = new Repeat("number", a);
@@ -130,16 +106,16 @@ describe("Repeat", () => {
         expect(tokens).toEqual(expected)
     });
 
-    test("Get Next Tokens With Bogus Pattern", () => {
+    test("Get Tokens After With Bogus Pattern", () => {
         const a = new Literal("a", "A");
         const manyA = new Repeat("many-a", a);
-        const tokens = manyA.getNextTokens(new Literal("bogus", "bogus"));
+        const tokens = manyA.getTokensAfter(new Literal("bogus", "bogus"));
         const expected: string[] = [];
 
         expect(tokens).toEqual(expected)
     });
 
-    test("Get Next Tokens With Divider", () => {
+    test("Get Tokens After With Divider", () => {
         const a = new Literal("a", "A");
         const b = new Literal("b", "B");
         const divider = new Literal("divider", ",");
@@ -147,37 +123,30 @@ describe("Repeat", () => {
         const parent = new And("parent", [manyA, b]);
 
         const clonedManyA = findPattern(parent, p => p.name == "many-a");
-        let tokens = clonedManyA?.getNextTokens(clonedManyA.children[0]);
+        let tokens = clonedManyA?.getTokensAfter(clonedManyA.children[0]);
         let expected = [",", "B"];
 
         expect(tokens).toEqual(expected)
 
-        tokens = clonedManyA?.getNextTokens(clonedManyA.children[1]);
+        tokens = clonedManyA?.getTokensAfter(clonedManyA.children[1]);
         expected = ["A"];
 
         expect(tokens).toEqual(expected)
     });
 
-    test("Get Next Tokens Without Divider", () => {
+    test("Get Tokens After Without Divider", () => {
         const a = new Literal("a", "A");
         const b = new Literal("b", "B");
         const manyA = new Repeat("many-a", a);
         const parent = new And("parent", [manyA, b]);
 
         const clonedManyA = findPattern(parent, p => p.name == "many-a");
-        const tokens = clonedManyA?.getNextTokens(clonedManyA.children[0]);
+        const tokens = clonedManyA?.getTokensAfter(clonedManyA.children[0]);
         const expected = ["A", "B"];
 
         expect(tokens).toEqual(expected)
     });
 
-    test("Get Next Pattern", () => {
-        const repeat = new Repeat("many-a", new Literal("a", "A"));
-        const nextPattern = repeat.getNextPattern();
-
-        expect(nextPattern).toBeNull()
-    });
-
     test("Properties", () => {
         const integer = new Repeat("integer", new Regex("digit", "\\d"));
 
@@ -188,9 +157,71 @@ describe("Repeat", () => {
         expect(integer.children[0].name).toBe("digit");
     });
 
-    test("Parse Text", () => {
+    test("Exec", () => {
         const integer = new Repeat("integer", new Regex("digit", "\\d"));
-        const { ast: result } = integer.parseText("B");
+        const { ast: result } = integer.exec("B");
         expect(result).toBeNull()
     });
+
+    test("Test With Match", () => {
+        const integer = new Repeat("integer", new Regex("digit", "\\d"));
+        const result = integer.test("1");
+        expect(result).toBeTruthy()
+    });
+
+    test("Test With No Match", () => {
+        const integer = new Repeat("integer", new Regex("digit", "\\d"));
+        const result = integer.test("b");
+        expect(result).toBeFalsy()
+    });
+
+    test("Get Next Tokens", () => {
+        const integer = new Repeat("integer", new Regex("digit", "\\d"));
+        const parent = new And("parent", [integer, new Literal("pow", "!")]);
+        const integerClone = parent.findPattern(p => p.name === "integer") as Pattern;
+        const tokens = integerClone.getNextTokens();
+
+        expect(tokens).toEqual(["!"])
+    });
+
+    test("Get Next Tokens With Null Parents", () => {
+        const integer = new Repeat("integer", new Regex("digit", "\\d"));
+        const tokens = integer.getNextTokens();
+
+        expect(tokens.length).toBe(0);
+    });
+
+    test("Find Pattern", () => {
+        const integer = new Repeat("integer", new Regex("digit", "\\d"));
+        const digitClone = integer.findPattern(p => p.name === "digit") as Pattern;
+
+        expect(digitClone).not.toBeNull();
+    });
+
+    test("Get Patterns", () => {
+        const a = new Literal("a", "A");
+        const manyA = new Repeat("number", a);
+        const patterns = manyA.getPatterns();
+        const expected = [manyA.findPattern(p => p.name === "a")];
+
+        expect(patterns).toEqual(expected)
+    });
+
+    test("Get Next Patterns", () => {
+        const integer = new Repeat("integer", new Regex("digit", "\\d"));
+        const parent = new And("parent", [integer, new Literal("pow", "!")]);
+        const integerClone = parent.findPattern(p => p.name === "integer") as Pattern;
+        const powClone = parent.findPattern(p => p.name === "pow") as Pattern;
+        const patterns = integerClone.getNextPatterns();
+
+        expect(patterns.length).toBe(1);
+        expect(patterns[0]).toBe(powClone);
+    });
+
+    test("Get Next Patterns With Null Parents", () => {
+        const integer = new Repeat("integer", new Regex("digit", "\\d"));
+        const patterns = integer.getNextPatterns();
+
+        expect(patterns.length).toBe(0);
+    });
 });

package/src/patterns/Repeat.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 Repeat implements Pattern {
@@ -15,7 +14,6 @@ export class Repeat implements Pattern {
   private _isOptional: boolean;
   private _nodes: Node[];
   private _firstIndex: number;
-  private _shouldReduceAst: boolean;
 
   get type(): string {
     return this._type;
@@ -54,7 +52,6 @@ export class Repeat implements Pattern {
     this._pattern = children[0];
     this._divider = children[1];
     this._firstIndex = -1
-    this._shouldReduceAst = false
     this._nodes = [];
   }
 
@@ -64,12 +61,19 @@ export class Repeat 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
     };
   }
@@ -84,7 +88,7 @@ export class Repeat implements Pattern {
       cursor.resolveError();
       const node = this.createNode(cursor);
 
-      if (node) {
+      if (node != null) {
         cursor.recordMatch(this, node);
       }
 
@@ -110,7 +114,7 @@ export class Repeat implements Pattern {
       if (cursor.hasError) {
         const lastValidNode = this.getLastValidNode();
 
-        if (lastValidNode) {
+        if (lastValidNode != null) {
           passed = true;
         } else {
           cursor.moveTo(runningCursorIndex);
@@ -129,13 +133,13 @@ export class Repeat implements Pattern {
 
         cursor.next();
 
-        if (this._divider) {
+        if (this._divider != null) {
           const dividerNode = this._divider.parse(cursor);
 
           if (cursor.hasError) {
             passed = true;
             break;
-          } else if (dividerNode) {
+          } else if (dividerNode != null) {
             this._nodes.push(dividerNode);
 
             if (!cursor.hasNext()) {
@@ -171,17 +175,13 @@ export class Repeat implements Pattern {
     const value = cursor.getChars(this._firstIndex, lastIndex);
     cursor.moveTo(lastIndex);
 
-    if (this._shouldReduceAst) {
-      children = [];
-    }
-
     return new Node(
       "repeat",
       this._name,
       this._firstIndex,
       lastIndex,
       children,
-      this._shouldReduceAst ? value : undefined
+      undefined
     );
   }
 
@@ -195,65 +195,82 @@ export class Repeat implements Pattern {
     return nodes[nodes.length - 1];
   }
 
-  enableAstReduction(): void {
-    this._shouldReduceAst = true;
+  getTokens(): string[] {
+    return this._pattern.getTokens();
+  }
+
+  getTokensAfter(childReference: Pattern): string[] {
+    const patterns = this.getPatternsAfter(childReference);
+    const tokens: string[] = [];
+
+    patterns.forEach(p => tokens.push(...p.getTokens()));
+
+    return tokens;
   }
 
-  disableAstReduction(): void {
-    this._shouldReduceAst = false;
+  getNextTokens(): string[] {
+    if (this.parent == null) {
+      return []
+    }
+
+    return this.parent.getTokensAfter(this);
   }
 
-  getTokens(): string[] {
-    return this._pattern.getTokens();
+  getPatterns(): Pattern[] {
+    return this._pattern.getPatterns();
   }
 
-  getNextTokens(lastMatched: Pattern): string[] {
+  getPatternsAfter(childReference: Pattern): Pattern[] {
     let index = -1;
-    const tokens: string[] = [];
+    const patterns: Pattern[] = [];
 
     for (let i = 0; i < this._children.length; i++) {
-      if (this._children[i] === lastMatched) {
+      if (this._children[i] === childReference) {
         index = i;
       }
     }
 
+    // If the last match isn't a child of this pattern.
     if (index === -1) {
       return [];
     }
 
+    // If the last match was the repeated patterns, then suggest the divider.
     if (index === 0 && this._divider) {
-      tokens.push(...this._children[1].getTokens());
+      patterns.push(this._children[1]);
 
       if (this._parent) {
-        tokens.push(...this._parent.getNextTokens(this));
+        patterns.push(...this._parent.getPatternsAfter(this));
       }
     }
 
+    // Suggest the pattern because the divider was the last match.
     if (index === 1) {
-      tokens.push(...this._children[0].getTokens());
+      patterns.push(this._children[0]);
     }
 
     if (index === 0 && !this._divider && this._parent) {
-      tokens.push(...this._children[0].getTokens());
-      tokens.push(...this._parent.getNextTokens(this));
+      patterns.push(this._children[0]);
+      patterns.push(...this._parent.getPatternsAfter(this));
     }
 
-    return tokens;
+    return patterns;
   }
 
-  getNextPattern(): Pattern | null {
-    return getNextPattern(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 {
-    const repeat = new Repeat(name, this._pattern, this._divider, isOptional);
-    repeat._shouldReduceAst = this._shouldReduceAst;
-
-    return repeat;
+    return new Repeat(name, this._pattern, this._divider, isOptional);
   }
 }
 

package/src/patterns/getNextPattern.test.ts

@@ -1,39 +0,0 @@
-import { And } from "./And";
-import { findPattern } from "./findPattern";
-import { Literal } from "./Literal";
-
-describe("getNextPatter", ()=>{
-    test("No Parent", ()=>{
-        const a = new Literal("a", "A");
-        const nextPattern = a.getNextPattern();
-
-        expect(nextPattern).toBe(null);
-    });
-
-    test("No Next Sibling", ()=>{
-        const a = new Literal("a", "A");
-        const parent = new And("parent", [a]);
-        const nextPattern = parent.children[0].getNextPattern();
-
-        expect(nextPattern).toBe(null);
-    });
-
-    test("Get Parents Sibling", ()=>{
-        const a = new Literal("a", "A");
-        const parent = new And("parent", [a]);
-        const grandParent = new And("grand-parent", [parent]);
-        const clonedA = findPattern(grandParent, p=>p.name === "a");
-        const nextPattern = clonedA?.getNextPattern();
-
-        expect(nextPattern).toBe(null);
-    });
-
-    test("Get Sibling", ()=>{
-        const a = new Literal("a", "A");
-        const b = new Literal("b", "B");
-        const parent = new And("parent", [a, b]);
-
-        const nextPattern = parent.children[0].getNextPattern();
-        expect(nextPattern?.name).toBe("b");
-    });
-});