clarity-pattern-parser 6.0.2 → 7.0.1

package/src/patterns/Repeat.test.ts

@@ -1,227 +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);
+    });
 
-        tokens = clonedManyA?.getTokensAfter(clonedManyA.children[1]);
-        expected = ["A"];
+    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];
 
-        expect(tokens).toEqual(expected)
+        let tokens = repeatClone.getNextTokens();
+        let expected = ["B"];
+
+        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 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")];
+        result = repeat.test("g");
+        expected = false;
 
-        expect(patterns).toEqual(expected)
+        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);
-    });
+    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);
 
-    test("Get Next Patterns With Null Parents", () => {
-        const integer = new Repeat("integer", new Regex("digit", "\\d"));
-        const patterns = integer.getNextPatterns();
+        repeatClone = repeat.clone("new-name", true);
+        expected = new Repeat("new-name", number, { min: 0 });
 
-        expect(patterns.length).toBe(0);
+        expect(repeatClone).toEqual(expected);
     });
 });