clarity-pattern-parser 8.4.14 → 9.0.0

package/src/grammar/Grammar.test.ts

@@ -1,11 +1,14 @@
-import { And } from "../patterns/And";
+import { Sequence } from "../patterns/Sequence";
+import { arePatternsEqual } from "../patterns/arePatternsEqual";
 import { Literal } from "../patterns/Literal";
 import { Not } from "../patterns/Not";
-import { Or } from "../patterns/Or";
+import { Options } from "../patterns/Options";
 import { Pattern } from "../patterns/Pattern";
+import { Reference } from "../patterns/Reference";
 import { Regex } from "../patterns/Regex";
 import { Repeat } from "../patterns/Repeat";
 import { Grammar } from "./Grammar";
+import { Optional } from "../patterns/Optional";
 
 describe("Grammar", () => {
     test("Literal", () => {
@@ -14,10 +17,10 @@ describe("Grammar", () => {
         `;
 
         const patterns = Grammar.parseString(expression);
-        const namePattern = patterns.get("name");
+        const namePattern = patterns["name"];
         const expected = new Literal("name", "John");
 
-        expect(namePattern).toEqual(expected);
+        expect(arePatternsEqual(namePattern, expected)).toBeTruthy();
     });
 
     test("Literal With Escaped Characters", () => {
@@ -25,10 +28,21 @@ describe("Grammar", () => {
             chars = "\\n\\r\\t\\b\\f\\v\\0\\x00\\u0000\\"\\\\"
         `;
         const patterns = Grammar.parseString(expression);
-        const namePattern = patterns.get("chars");
+        const namePattern = patterns["chars"];
         const expected = new Literal("chars", "\n\r\t\b\f\v\0\x00\u0000\"\\");
 
-        expect(namePattern).toEqual(expected);
+        expect(arePatternsEqual(namePattern, expected)).toBeTruthy();
+    });
+
+    test("Literal With Escaped Quotes", () => {
+        const expression = `
+            content = "With Con\\"tent"
+        `;
+        const patterns = Grammar.parseString(expression);
+        const namePattern = patterns["content"];
+        const expected = new Literal("content", "With Con\"tent");
+
+        expect(arePatternsEqual(namePattern, expected)).toBeTruthy();
     });
 
     test("Regex", () => {
@@ -37,10 +51,10 @@ describe("Grammar", () => {
         `;
 
         const patterns = Grammar.parseString(expression);
-        const pattern = patterns.get("name");
+        const pattern = patterns["name"];
         const name = new Regex("name", "\\w");
 
-        expect(pattern).toEqual(name);
+        expect(arePatternsEqual(pattern, name)).toBeTruthy();
     });
 
     test("Or", () => {
@@ -51,12 +65,12 @@ describe("Grammar", () => {
         `;
 
         const patterns = Grammar.parseString(expression);
-        const pattern = patterns.get("names");
+        const pattern = patterns["names"];
         const john = new Literal("john", "John");
         const jane = new Literal("jane", "Jane");
-        const names = new Or("names", [john, jane], false, true);
+        const names = new Options("names", [john, jane], true);
 
-        expect(pattern).toEqual(names);
+        expect(arePatternsEqual(pattern, names)).toBeTruthy();
     });
 
     test("And", () => {
@@ -64,17 +78,17 @@ describe("Grammar", () => {
             space = " "
             first-name = /\\w/
             last-name = /\\w/
-            full-name = first-name & space & last-name
+            full-name = first-name + space + last-name
         `;
 
         const patterns = Grammar.parseString(expression);
-        const pattern = patterns.get("full-name");
+        const pattern = patterns["full-name"];
         const space = new Literal("space", " ");
         const firstName = new Regex("first-name", "\\w");
         const lastName = new Regex("last-name", "\\w");
-        const fullName = new And("full-name", [firstName, space, lastName]);
+        const fullName = new Sequence("full-name", [firstName, space, lastName]);
 
-        expect(pattern).toEqual(fullName);
+        expect(arePatternsEqual(pattern, fullName)).toBeTruthy();
     });
 
     test("And With Optional Pattern", () => {
@@ -83,20 +97,20 @@ describe("Grammar", () => {
             first-name = /\\w/
             last-name = /\\w/
             middle-name = /\\w/
-            middle-name-with-space = middle-name & space
-            full-name = first-name & space & middle-name-with-space? & last-name
+            middle-name-with-space = middle-name + space
+            full-name = first-name + space + middle-name-with-space? + last-name
         `;
 
         const patterns = Grammar.parseString(expression);
-        const pattern = patterns.get("full-name");
+        const pattern = patterns["full-name"];
         const space = new Literal("space", " ");
         const firstName = new Regex("first-name", "\\w");
         const lastName = new Regex("last-name", "\\w");
         const middleName = new Regex("middle-name", "\\w");
-        const middleNameWithSpace = new And("middle-name-with-space", [middleName, space], true);
-        const fullName = new And("full-name", [firstName, space, middleNameWithSpace, lastName]);
+        const middleNameWithSpace = new Optional("optional-middle-name-with-space", new Sequence("middle-name-with-space", [middleName, space]));
+        const fullName = new Sequence("full-name", [firstName, space, middleNameWithSpace, lastName]);
 
-        expect(pattern).toEqual(fullName);
+        expect(arePatternsEqual(pattern, fullName)).toBeTruthy();
     });
 
     test("And With Not Pattern", () => {
@@ -106,22 +120,21 @@ describe("Grammar", () => {
             last-name = /\\w/
             middle-name = /\\w/
             jack = "Jack"
-            middle-name-with-space = middle-name & space
-            full-name = !jack & first-name & space & middle-name-with-space? & last-name
+            middle-name-with-space = middle-name + space
+            full-name = !jack + first-name + space + middle-name-with-space? + last-name
         `;
 
         const patterns = Grammar.parseString(expression);
-        const pattern = patterns.get("full-name");
+        const pattern = patterns["full-name"];
         const space = new Literal("space", " ");
         const firstName = new Regex("first-name", "\\w");
         const lastName = new Regex("last-name", "\\w");
         const middleName = new Regex("middle-name", "\\w");
         const jack = new Literal("jack", "Jack");
         const notJack = new Not("not-jack", jack);
-        const middleNameWithSpace = new And("middle-name-with-space", [middleName, space], true);
-        const fullName = new And("full-name", [notJack, firstName, space, middleNameWithSpace, lastName]);
-
-        expect(pattern).toEqual(fullName);
+        const middleNameWithSpace = new Optional("optional-middle-name-with-space", new Sequence("middle-name-with-space", [middleName, space]));
+        const fullName = new Sequence("full-name", [notJack, firstName, space, middleNameWithSpace, lastName]);
+        expect(arePatternsEqual(pattern, fullName)).toBeTruthy();
     });
 
     test("Repeat", () => {
@@ -131,11 +144,11 @@ describe("Grammar", () => {
         `;
 
         const patterns = Grammar.parseString(expression);
-        const pattern = patterns.get("digits");
+        const pattern = patterns["digits"];
         const digit = new Regex("digit", "\\d");
         const digits = new Repeat("digits", digit);
 
-        expect(pattern).toEqual(digits);
+        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
     });
 
     test("Repeat Zero Or More", () => {
@@ -145,11 +158,11 @@ describe("Grammar", () => {
         `;
 
         const patterns = Grammar.parseString(expression);
-        const pattern = patterns.get("digits");
+        const pattern = patterns["digits"];
         const digit = new Regex("digit", "\\d");
-        const digits = new Repeat("digits", digit, { min: 0 });
+        const digits = new Optional("digits", new Repeat("digits", digit, { min: 0 }));
 
-        expect(pattern).toEqual(digits);
+        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
     });
 
     test("Repeat Lower Limit", () => {
@@ -159,11 +172,11 @@ describe("Grammar", () => {
         `;
 
         const patterns = Grammar.parseString(expression);
-        const pattern = patterns.get("digits");
+        const pattern = patterns["digits"];
         const digit = new Regex("digit", "\\d+");
         const digits = new Repeat("digits", digit, { min: 1 });
 
-        expect(pattern).toEqual(digits);
+        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
     });
 
     test("Repeat Bounded", () => {
@@ -173,11 +186,10 @@ describe("Grammar", () => {
         `;
 
         const patterns = Grammar.parseString(expression);
-        const pattern = patterns.get("digits");
+        const pattern = patterns["digits"];
         const digit = new Regex("digit", "\\d+");
         const digits = new Repeat("digits", digit, { min: 1, max: 3 });
-
-        expect(pattern).toEqual(digits);
+        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
     });
 
     test("Repeat Upper Limit", () => {
@@ -187,11 +199,11 @@ describe("Grammar", () => {
         `;
 
         const patterns = Grammar.parseString(expression);
-        const pattern = patterns.get("digits");
+        const pattern = patterns["digits"];
         const digit = new Regex("digit", "\\d+");
         const digits = new Repeat("digits", digit, { min: 0, max: 3 });
 
-        expect(pattern).toEqual(digits);
+        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
     });
 
     test("Repeat Exact", () => {
@@ -201,11 +213,11 @@ describe("Grammar", () => {
         `;
 
         const patterns = Grammar.parseString(expression);
-        const pattern = patterns.get("digits");
+        const pattern = patterns["digits"];
         const digit = new Regex("digit", "\\d+");
         const digits = new Repeat("digits", digit, { min: 3, max: 3 });
 
-        expect(pattern).toEqual(digits);
+        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
     });
 
     test("Repeat Divider", () => {
@@ -216,28 +228,44 @@ describe("Grammar", () => {
         `;
 
         const patterns = Grammar.parseString(expression);
-        const pattern = patterns.get("digits");
+        const pattern = patterns["digits"];
         const digit = new Regex("digit", "\\d+");
         const divider = new Literal("comma", ",");
         const digits = new Repeat("digits", digit, { divider, min: 3, max: 3 });
 
-        expect(pattern).toEqual(digits);
+        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
     });
 
     test("Repeat Divider With Trim Divider", () => {
         const expression = `
             digit = /\\d+/
             comma = ","
-            digits = (digit, comma){3} -t
+            digits = (digit, comma trim)+
+        `;
+
+        const patterns = Grammar.parseString(expression);
+        const pattern = patterns["digits"];
+        const digit = new Regex("digit", "\\d+");
+        const divider = new Literal("comma", ",");
+        const digits = new Repeat("digits", digit, { divider, min: 1, trimDivider: true });
+        debugger;
+        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
+    });
+
+    test("Repeat Divider With Trim Divider And Bounds", () => {
+        const expression = `
+            digit = /\\d+/
+            comma = ","
+            digits = (digit, comma trim){3, 3}
         `;
 
         const patterns = Grammar.parseString(expression);
-        const pattern = patterns.get("digits");
+        const pattern = patterns["digits"];
         const digit = new Regex("digit", "\\d+");
         const divider = new Literal("comma", ",");
         const digits = new Repeat("digits", digit, { divider, min: 3, max: 3, trimDivider: true });
 
-        expect(pattern).toEqual(digits);
+        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
     });
 
     test("Reference", () => {
@@ -248,15 +276,15 @@ describe("Grammar", () => {
             close-bracket = "]"
             spaces = /\\s+/
             items = digit | array
-            array-items = (items, divider)* -t
-            array = open-bracket & spaces? & array-items? & spaces? & close-bracket
+            array-items = (items, divider trim)*
+            array = open-bracket + spaces? + array-items + spaces? + close-bracket
         `;
 
         const patterns = Grammar.parseString(expression);
-        const pattern = patterns.get("array") as Pattern;
+        const pattern = patterns["array"] as Pattern;
 
         let text = "[1, []]";
-        let result = pattern.exec(text);
+        let result = pattern.exec(text, true);
 
         expect(result.ast?.value).toEqual("[1, []]");
     });
@@ -269,14 +297,14 @@ describe("Grammar", () => {
 
         const patterns = Grammar.parseString(expression);
 
-        const name = patterns.get("name");
+        const name = patterns["name"];
         const expectedName = new Regex("name", "regex");
 
-        const alias = patterns.get("alias");
+        const alias = patterns["alias"];
         const expectedAlias = new Regex("alias", "regex");
 
-        expect(name).toEqual(expectedName);
-        expect(alias).toEqual(expectedAlias);
+        expect(arePatternsEqual(name, expectedName)).toBeTruthy();
+        expect(arePatternsEqual(alias, expectedAlias)).toBeTruthy();
     });
 
     test("Bad Grammar At Beginning", () => {
@@ -295,7 +323,7 @@ describe("Grammar", () => {
                 age = /()
             `;
             Grammar.parseString(expression);
-        }).toThrowError("[Parse Error] Found: '    age = /()\n      ', expected: '    age = !' or '    age = (' or '    age = [Pattern Name]' or '    age = [Regular Expression]' or '    age = [String]'.")
+        }).toThrow();
 
     });
 
@@ -305,15 +333,15 @@ describe("Grammar", () => {
         import { first-name } from "some/path/to/file.cpat"
         last-name = "Doe"
         space = " "
-        full-name = first-name & space & last-name
-        `
+        full-name = first-name + space + last-name
+        `;
         function resolveImport(resource: string) {
             expect(resource).toBe("some/path/to/file.cpat");
             return Promise.resolve({ expression: importExpression, resource });
         }
 
         const patterns = await Grammar.parse(expression, { resolveImport });
-        const fullname = patterns.get("full-name") as Pattern;
+        const fullname = patterns["full-name"] as Pattern;
         const result = fullname.exec("John Doe");
 
         expect(result?.ast?.value).toBe("John Doe");
@@ -321,7 +349,7 @@ describe("Grammar", () => {
 
     test("Imports", async () => {
         const importExpression = `first-name = "John"`;
-        const spaceExpression = `space = " "`
+        const spaceExpression = `space = " "`;
 
         const pathMap: Record<string, string> = {
             "space.cpat": spaceExpression,
@@ -332,14 +360,14 @@ describe("Grammar", () => {
         import { first-name } from "first-name.cpat"
         import { space } from "space.cpat"
         last-name = "Doe"
-        full-name = first-name & space & last-name
-        `
+        full-name = first-name + space + last-name
+        `;
         function resolveImport(resource: string) {
             return Promise.resolve({ expression: pathMap[resource], resource });
         }
 
         const patterns = await Grammar.parse(expression, { resolveImport });
-        const fullname = patterns.get("full-name") as Pattern;
+        const fullname = patterns["full-name"] as Pattern;
         const result = fullname.exec("John Doe");
         expect(result?.ast?.value).toBe("John Doe");
     });
@@ -349,13 +377,13 @@ describe("Grammar", () => {
         const spaceExpression = `
         use params { custom-space }
         space = custom-space
-        `
+        `;
         const expression = `
         import { first-name } from "first-name.cpat"
         import { space } from "space.cpat" with params { custom-space = "  " }
         last-name = "Doe"
-        full-name = first-name & space & last-name
-        `
+        full-name = first-name + space + last-name
+        `;
 
         const pathMap: Record<string, string> = {
             "space.cpat": spaceExpression,
@@ -367,7 +395,7 @@ describe("Grammar", () => {
         }
 
         const patterns = await Grammar.parse(expression, { resolveImport });
-        const fullname = patterns.get("full-name") as Pattern;
+        const fullname = patterns["full-name"] as Pattern;
         const result = fullname.exec("John  Doe");
         expect(result?.ast?.value).toBe("John  Doe");
     });
@@ -380,7 +408,7 @@ describe("Grammar", () => {
         }
 
         name
-        `
+        `;
 
         const resource1 = `
         use-this = "Use This"
@@ -402,7 +430,7 @@ describe("Grammar", () => {
             return Promise.resolve({ expression: pathMap[resource], resource });
         }
         const patterns = await Grammar.parse(expression, { resolveImport });
-        const pattern = patterns.get("name") as Literal;
+        const pattern = patterns["name"] as Literal;
 
         const result = pattern.exec("Use This");
 
@@ -416,7 +444,7 @@ describe("Grammar", () => {
             param = alias
         }
         name = export-value
-        `
+        `;
 
         const resource1 = `
         value = "Value"
@@ -427,7 +455,7 @@ describe("Grammar", () => {
             param
         }
         export-value = param
-        `
+        `;
 
         const pathMap: Record<string, string> = {
             "resource1": resource1,
@@ -438,9 +466,35 @@ describe("Grammar", () => {
             return Promise.resolve({ expression: pathMap[resource], resource });
         }
         const patterns = await Grammar.parse(expression, { resolveImport });
-        const pattern = patterns.get("name") as Literal;
+        const pattern = patterns["name"] as Literal;
 
         const result = pattern.exec("Value");
         expect(result.ast?.value).toBe("Value");
     });
+
+    test("Anonymous Patterns", () => {
+        const expression = `
+            complex-expression = !"NOT_THIS" + "Text"? + /regex/ + ("Text" <|> /regex/ <|> (pattern)+) + (pattern | pattern)
+        `;
+
+        const patterns = Grammar.parseString(expression);
+        const expected = new Sequence("complex-expression", [
+            new Not("not-NOT_THIS", new Literal("NOT_THIS", "NOT_THIS")),
+            new Optional("Text", new Literal("Text", "Text")),
+            new Regex("regex", "regex"),
+            new Options("anonymous", [
+                new Literal("Text", "Text"),
+                new Regex("regex", "regex"),
+                new Repeat("anonymous", new Reference("pattern")),
+            ],
+                true
+            ),
+            new Options("anonymous", [
+                new Reference("pattern"),
+                new Reference("pattern")
+            ])
+        ]);
+
+        expect(arePatternsEqual(patterns["complex-expression"], expected)).toBeTruthy();
+    });
 });