clarity-pattern-parser 5.0.0 → 6.0.0

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,62 @@ 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 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,78 @@ export class Repeat implements Pattern {
     return nodes[nodes.length - 1];
   }
 
-  enableAstReduction(): void {
-    this._shouldReduceAst = true;
+  getTokens(): string[] {
+    return this._pattern.getTokens();
   }
 
-  disableAstReduction(): void {
-    this._shouldReduceAst = false;
+  getTokensAfter(childReference: Pattern): string[] {
+    const patterns = this.getPatternsAfter(childReference);
+    const tokens: string[] = [];
+
+    patterns.forEach(p => tokens.push(...p.getTokens()));
+
+    return tokens;
   }
 
-  getTokens(): string[] {
-    return this._pattern.getTokens();
+  getNextTokens(): string[] {
+    if (this.parent == null) {
+      return []
+    }
+
+    return this.parent.getTokensAfter(this);
   }
 
-  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");
-    });
-});

package/src/patterns/getNextPattern.ts

@@ -1,18 +0,0 @@
-import { Pattern } from "./Pattern";
-
-export function getNextPattern(pattern: Pattern): Pattern | null {
-    const parent = pattern.parent;
-
-    if (parent == null) {
-        return null;
-    }
-
-    const patternIndex = parent.children.indexOf(pattern);
-    const nextPattern = parent.children[patternIndex + 1] || null;
-
-    if (nextPattern == null) {
-        return parent.getNextPattern();
-    }
-
-    return nextPattern;
-}