clarity-pattern-parser 5.0.0 → 6.0.2

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,130 @@ 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", () => {
+        const aOrB = new Or("a-b", [new Literal("a", "A"), new Literal("b", "B")]);
+        const patterns = aOrB.getPatterns();
+        const expected = [
+            aOrB.findPattern(p => p.name === "a"),
+            aOrB.findPattern(p => p.name === "b")
+        ];
+
+        expect(patterns).toEqual(expected);
+    });
+
+    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,50 @@ 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);
+  }
+
+  getNextTokens(): string[] {
+    if (this._parent == null) {
+      return []
+    }
+
+    return this._parent.getTokensAfter(this);
   }
 
-  getNextPattern(): Pattern | null {
-    return getNextPattern(this)
+  getPatterns(): Pattern[] {
+    const patterns: Pattern[] = [];
+
+    for (const pattern of this._children) {
+      patterns.push(...pattern.getPatterns());
+    }
+
+    return patterns;
+  }
+
+  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,14 @@ 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[];
+  getNextTokens(): string[];
+  getPatterns(): Pattern[];
+  getPatternsAfter(childReference: Pattern): Pattern[];
+  getNextPatterns(): Pattern[];
+  findPattern(predicate: (p: Pattern) => boolean): Pattern | null;
 }

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 = ["["];
-
-        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 = ["]"];
+        const expected = [
+            "1",
+            "2",
+            "3",
+            "4",
+            "5",
+            "6",
+            "7",
+            "8",
+            "9",
+            "0",
+            "["
+        ];
 
         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,113 @@ 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", () => {
+        const value = createValuePattern();
+        const ref = findPattern(value, (p) => p.type === "reference");
+        const patterns = ref?.getPatterns() || [];
+
+        expect(patterns.length).toBe(2);
+        expect(patterns[0].name).toBe("number");
+        expect(patterns[1].name).toBe("open-bracket");
+    });
+
+    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,52 @@ 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);
+  }
+
+  getPatterns(): Pattern[] {
+    return this._getPatternSafely().getPatterns();
+  }
+
+  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);
+  }
 }