clarity-pattern-parser 6.0.0 → 7.0.0

package/src/patterns/Regex.test.ts

@@ -86,7 +86,7 @@ describe("Regex", () => {
 
     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 aClone = parent.find(p => p.name === "a") as Pattern;
         const tokens = aClone.getNextTokens();
 
         expect(tokens).toEqual(["B"]);
@@ -99,6 +99,15 @@ describe("Regex", () => {
         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"));
@@ -108,15 +117,15 @@ describe("Regex", () => {
 
     test("Find Pattern", () => {
         const a = new Regex("a", "A")
-        const pattern = a.findPattern(p => p.name === "other");
+        const pattern = a.find(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 aClone = parent.find(p => p.name === "a") as Pattern;
+        const bClone = parent.find(p => p.name === "b") as Pattern;
         const patterns = aClone.getNextPatterns();
 
         expect(patterns.length).toBe(1);

package/src/patterns/Regex.ts

@@ -157,6 +157,10 @@ export class Regex implements Pattern {
     return this.parent.getTokensAfter(this);
   }
 
+  getPatterns(): Pattern[] {
+    return [this];
+  }
+
   getPatternsAfter(_childReference: Pattern): Pattern[] {
     return [];
   }
@@ -169,7 +173,7 @@ export class Regex implements Pattern {
     return this.parent.getPatternsAfter(this)
   }
 
-  findPattern(_predicate: (p: Pattern) => boolean): Pattern | null {
+  find(_predicate: (p: Pattern) => boolean): Pattern | null {
     return null;
   }
 

package/src/patterns/Repeat.test.ts

@@ -1,218 +1,222 @@
 import { Node } from "../ast/Node";
 import { And } from "./And";
 import { Cursor } from "./Cursor";
-import { findPattern } from "./findPattern";
+import { InfiniteRepeat } from "./InfiniteRepeat";
 import { Literal } from "./Literal";
 import { Pattern } from "./Pattern";
 import { Regex } from "./Regex";
 import { Repeat } from "./Repeat";
 
+// To Check all behavior look at FiniteRepeat and InfiniteRepeat.
 describe("Repeat", () => {
-    test("Successful Parse", () => {
-        const digit = new Regex("digit", "\\d");
-        const integer = new Repeat("number", digit);
-        const cursor = new Cursor("337");
-        const result = integer.parse(cursor);
-        const 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"),
+    test("Finite Repeat Without Min", () => {
+        const number = new Regex("number", "\\d");
+        const finiteRepeat = new Repeat("numbers", number, { max: 2 });
+
+        let cursor = new Cursor("f");
+        let result = finiteRepeat.parse(cursor);
+        let expected: Node | null = null;
+
+        expect(result).toBe(expected);
+        expect(cursor.hasError).toBeTruthy();
+
+        cursor = new Cursor("1");
+        result = finiteRepeat.parse(cursor);
+        expected = new Node("finite-repeat", "numbers", 0, 0, [
+            new Node("regex", "number", 0, 0, [], "1")
         ]);
 
-        expect(result).toEqual(expected)
-        expect(cursor.hasError).toBeFalsy()
-    });
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
 
-    test("Failed Parse", () => {
-        const digit = new Regex("digit", "\\d");
-        const integer = new Repeat("number", digit);
-        const cursor = new Cursor("John");
-        const result = integer.parse(cursor);
+        cursor = new Cursor("12");
+        result = finiteRepeat.parse(cursor);
+        expected = new Node("finite-repeat", "numbers", 0, 1, [
+            new Node("regex", "number", 0, 0, [], "1"),
+            new Node("regex", "number", 1, 1, [], "2")
+        ]);
 
-        expect(result).toBeNull()
-        expect(cursor.hasError).toBeTruthy()
-    });
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
 
-    test("Successful Parse With Divider", () => {
-        const digit = new Regex("digit", "\\d");
-        const divider = new Literal("divider", ",");
-        const integer = new Repeat("number", digit, divider);
-        const cursor = new Cursor("3,3,7");
-        const result = integer.parse(cursor);
-        const expected = new Node("repeat", "number", 0, 4, [
-            new Node("regex", "digit", 0, 0, [], "3"),
-            new Node("literal", "divider", 1, 1, [], ","),
-            new Node("regex", "digit", 2, 2, [], "3"),
-            new Node("literal", "divider", 3, 3, [], ","),
-            new Node("regex", "digit", 4, 4, [], "7"),
+        cursor = new Cursor("123");
+        result = finiteRepeat.parse(cursor);
+        expected = new Node("finite-repeat", "numbers", 0, 1, [
+            new Node("regex", "number", 0, 0, [], "1"),
+            new Node("regex", "number", 1, 1, [], "2")
         ]);
 
-        expect(result).toEqual(expected)
-        expect(cursor.hasError).toBeFalsy()
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
+        expect(cursor.index).toBe(1);
     });
 
-    test("Successful Parse Text Ends With Divider", () => {
-        const digit = new Regex("digit", "\\d");
-        const divider = new Literal("divider", ",");
-        const integer = new Repeat("number", digit, divider);
-        const cursor = new Cursor("3,3,7,");
-        const result = integer.parse(cursor);
-        const expected = new Node("repeat", "number", 0, 4, [
-            new Node("regex", "digit", 0, 0, [], "3"),
-            new Node("literal", "divider", 1, 1, [], ","),
-            new Node("regex", "digit", 2, 2, [], "3"),
-            new Node("literal", "divider", 3, 3, [], ","),
-            new Node("regex", "digit", 4, 4, [], "7"),
+    test("Finite Repeat With Min", () => {
+        const number = new Regex("number", "\\d");
+        const finiteRepeat = new Repeat("numbers", number, { max: 2, min: 2 });
+
+        let cursor = new Cursor("f");
+        let result = finiteRepeat.parse(cursor);
+        let expected: Node | null = null;
+
+        expect(result).toBe(expected);
+        expect(cursor.hasError).toBeTruthy();
+
+        cursor = new Cursor("1");
+        result = finiteRepeat.parse(cursor);
+        expected = null;
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeTruthy();
+
+        cursor = new Cursor("12");
+        result = finiteRepeat.parse(cursor);
+        expected = new Node("finite-repeat", "numbers", 0, 1, [
+            new Node("regex", "number", 0, 0, [], "1"),
+            new Node("regex", "number", 1, 1, [], "2")
         ]);
 
-        expect(result).toEqual(expected)
-        expect(cursor.hasError).toBeFalsy()
-    });
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
 
-    test("Successful Parse Trailing Comma", () => {
-        const digit = new Regex("digit", "\\d");
-        const divider = new Literal("divider", ",");
-        const integer = new Repeat("number", digit, divider);
-        const cursor = new Cursor("3,3,7,t");
-        const result = integer.parse(cursor);
-        const expected = new Node("repeat", "number", 0, 4, [
-            new Node("regex", "digit", 0, 0, [], "3"),
-            new Node("literal", "divider", 1, 1, [], ","),
-            new Node("regex", "digit", 2, 2, [], "3"),
-            new Node("literal", "divider", 3, 3, [], ","),
-            new Node("regex", "digit", 4, 4, [], "7"),
+        cursor = new Cursor("123");
+        result = finiteRepeat.parse(cursor);
+        expected = new Node("finite-repeat", "numbers", 0, 1, [
+            new Node("regex", "number", 0, 0, [], "1"),
+            new Node("regex", "number", 1, 1, [], "2")
         ]);
 
-        expect(result).toEqual(expected)
-        expect(cursor.hasError).toBeFalsy()
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
+        expect(cursor.index).toBe(1);
     });
 
-    test("Failed (Optional)", () => {
-        const digit = new Regex("digit", "\\d");
-        const integer = new Repeat("number", digit, undefined, true);
-        const cursor = new Cursor("John");
-        const result = integer.parse(cursor);
+    test("Finite Repeat Get Tokens", () => {
+        const number = new Literal("number", "1");
+        const repeat = new Repeat("numbers", number);
+        const numberClone = repeat.find(p => p.name === "number") as Pattern;
 
-        expect(result).toBeNull()
-        expect(cursor.hasError).toBeFalsy()
-    });
+        let tokens = repeat.getTokens();
+        let expected = ["1"];
 
-    test("Get Tokens", () => {
-        const a = new Literal("a", "A");
-        const manyA = new Repeat("number", a);
-        const tokens = manyA.getTokens();
-        const expected = ["A"];
+        expect(tokens).toEqual(expected);
 
-        expect(tokens).toEqual(expected)
-    });
+        tokens = repeat.getNextTokens();
+        expected = [];
+
+        expect(tokens).toEqual(expected);
 
-    test("Get Tokens After With Bogus Pattern", () => {
-        const a = new Literal("a", "A");
-        const manyA = new Repeat("many-a", a);
-        const tokens = manyA.getTokensAfter(new Literal("bogus", "bogus"));
-        const expected: string[] = [];
+        tokens = repeat.getTokensAfter(numberClone);
+        expected = [];
 
-        expect(tokens).toEqual(expected)
+        expect(tokens).toEqual(expected);
     });
 
-    test("Get Tokens After With Divider", () => {
-        const a = new Literal("a", "A");
-        const b = new Literal("b", "B");
-        const divider = new Literal("divider", ",");
-        const manyA = new Repeat("many-a", a, divider);
-        const parent = new And("parent", [manyA, b]);
+    test("Get Tokens After", () => {
+        const number = new Literal("number", "1");
+        const repeat = new Repeat("numbers", number);
+        const parent = new And("parent", [repeat, new Literal("b", "B")]);
+        const numberClone = parent.find(p => p.name === "number") as Pattern;
+        const repeatClone = parent.children[0];
 
-        const clonedManyA = findPattern(parent, p => p.name == "many-a");
-        let tokens = clonedManyA?.getTokensAfter(clonedManyA.children[0]);
-        let expected = [",", "B"];
+        let tokens = repeatClone.getTokensAfter(numberClone);
+        let expected = ["B"];
+
+        expect(tokens).toEqual(expected);
+    });
 
-        expect(tokens).toEqual(expected)
+    test("Get Next Tokens", () => {
+        const number = new Literal("number", "1");
+        const repeat = new Repeat("numbers", number);
+        const parent = new And("parent", [repeat, new Literal("b", "B")]);
+        const repeatClone = parent.children[0];
 
-        tokens = clonedManyA?.getTokensAfter(clonedManyA.children[1]);
-        expected = ["A"];
+        let tokens = repeatClone.getNextTokens();
+        let expected = ["B"];
 
-        expect(tokens).toEqual(expected)
+        expect(tokens).toEqual(expected);
     });
 
-    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]);
+    test("Get Next Patterns", () => {
+        const number = new Literal("number", "1");
+        const repeat = new Repeat("numbers", number);
+        const parent = new And("parent", [repeat, new Literal("b", "B")]);
+        const repeatClone = parent.children[0];
+        const bClone = parent.find(p => p.name === "b") as Pattern;
 
-        const clonedManyA = findPattern(parent, p => p.name == "many-a");
-        const tokens = clonedManyA?.getTokensAfter(clonedManyA.children[0]);
-        const expected = ["A", "B"];
+        let patterns = repeatClone.getNextPatterns();
+        let expected = [bClone];
 
-        expect(tokens).toEqual(expected)
+        expect(patterns).toEqual(expected);
     });
 
-    test("Properties", () => {
-        const integer = new Repeat("integer", new Regex("digit", "\\d"));
+    test("Repeat Get Patterns", () => {
+        const number = new Literal("number", "1");
+        const repeat = new Repeat("numbers", number);
+        const numberClone = repeat.find(p => p.name === "number") as Pattern;
 
-        expect(integer.type).toBe("repeat");
-        expect(integer.name).toBe("integer");
-        expect(integer.isOptional).toBeFalsy()
-        expect(integer.parent).toBeNull();
-        expect(integer.children[0].name).toBe("digit");
-    });
+        let patterns = repeat.getPatterns();
+        let expected = [numberClone];
 
-    test("Exec", () => {
-        const integer = new Repeat("integer", new Regex("digit", "\\d"));
-        const { ast: result } = integer.exec("B");
-        expect(result).toBeNull()
-    });
+        expect(patterns).toEqual(expected);
 
-    test("Test With Match", () => {
-        const integer = new Repeat("integer", new Regex("digit", "\\d"));
-        const result = integer.test("1");
-        expect(result).toBeTruthy()
-    });
+        patterns = repeat.getNextPatterns();
+        expected = [];
 
-    test("Test With No Match", () => {
-        const integer = new Repeat("integer", new Regex("digit", "\\d"));
-        const result = integer.test("b");
-        expect(result).toBeFalsy()
-    });
+        expect(patterns).toEqual(expected);
 
-    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();
+        patterns = repeat.getPatternsAfter(numberClone);
+        expected = [];
 
-        expect(tokens).toEqual(["!"])
+        expect(patterns).toEqual(expected);
     });
 
-    test("Get Next Tokens With Null Parents", () => {
-        const integer = new Repeat("integer", new Regex("digit", "\\d"));
-        const tokens = integer.getNextTokens();
+    test("Repeat Properties", () => {
+        const number = new Literal("number", "1");
+        const repeat = new Repeat("numbers", number);
 
-        expect(tokens.length).toBe(0);
+        expect(repeat.type).toBe("infinite-repeat");
+        expect(repeat.name).toBe("numbers");
+        expect(repeat.parent).toBeNull();
+        expect(repeat.isOptional).toBeFalsy();
     });
 
-    test("Find Pattern", () => {
-        const integer = new Repeat("integer", new Regex("digit", "\\d"));
-        const digitClone = integer.findPattern(p => p.name === "digit") as Pattern;
+    test("test", () => {
+        const number = new Literal("number", "1");
+        const repeat = new Repeat("numbers", number);
+        let result = repeat.test("1");
+        let expected = true;
 
-        expect(digitClone).not.toBeNull();
-    });
+        expect(result).toBe(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);
+        result = repeat.test("g");
+        expected = false;
+
+        expect(result).toBe(expected);
     });
 
-    test("Get Next Patterns With Null Parents", () => {
-        const integer = new Repeat("integer", new Regex("digit", "\\d"));
-        const patterns = integer.getNextPatterns();
+    test("Repeat Clone", () => {
+        const number = new Literal("number", "1");
+        const repeat = new Repeat("numbers", number);
+
+        let repeatClone = repeat.clone();
+        let expected = new Repeat("numbers", number);
+
+        expect(repeatClone).toEqual(expected);
+
+        repeatClone = repeat.clone("new-name");
+        expected = new Repeat("new-name", number);
+
+        expect(repeatClone).toEqual(expected);
+
+        repeatClone = repeat.clone("new-name", false);
+        expected = new Repeat("new-name", number);
+
+        expect(repeatClone).toEqual(expected);
+
+        repeatClone = repeat.clone("new-name", true);
+        expected = new Repeat("new-name", number, { min: 0 });
 
-        expect(patterns.length).toBe(0);
+        expect(repeatClone).toEqual(expected);
     });
 });