clarity-pattern-parser 8.4.10 → 8.4.11

package/src/grammar/Grammar.test.ts

@@ -271,9 +271,9 @@ describe("Grammar", () => {
     test("Bad Grammar At Beginning", () => {
 
         expect(() => {
-            const expression = `Just Junk`;
+            const expression = `//`;
             Grammar.parseString(expression);
-        }).toThrowError("[Parse Error] Found: 'Just Junk', expected: ' ='.");
+        }).toThrow();
 
     });
 
@@ -339,18 +339,18 @@ describe("Grammar", () => {
         use params { custom-space }
         space = custom-space
         `
-
-        const pathMap: Record<string, string> = {
-            "space.cpat": spaceExpression,
-            "first-name.cpat": importExpression
-        };
-
         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
         `
+
+        const pathMap: Record<string, string> = {
+            "space.cpat": spaceExpression,
+            "first-name.cpat": importExpression
+        };
+
         function resolveImport(resource: string) {
             return Promise.resolve({ expression: pathMap[resource], resource });
         }
@@ -361,9 +361,65 @@ describe("Grammar", () => {
         expect(result?.ast?.value).toBe("John  Doe");
     });
 
-    test("Use Params", () => {
+    test("Export Name", async () => {
         const expression = `
-        use Params { first-name }
+        import { use-this } from "resource1"
+        import {name} from "resource2" with params {
+           use-this   
+        }
+
+        name
         `
+
+        const resource1 = `
+        use-this = "Use This"
+        `;
+
+        const resource2 = `
+        use params {
+            use-this
+        }
+        name = use-this
+        `;
+
+        const pathMap: Record<string, string> = {
+            "resource1": resource1,
+            "resource2": resource2
+        };
+
+        function resolveImport(resource: string) {
+            return Promise.resolve({ expression: pathMap[resource], resource });
+        }
+        const patterns = await Grammar.parse(expression, { resolveImport });
+        const pattern = patterns.get("name") as Literal;
+
+        const result = pattern.exec("Use This");
+
+        expect(result.ast?.value).toBe("Use This");
+    });
+
+    test("Import Alias", async () => {
+        const expression = `
+        import { value as alias } from "resource1"
+        name = alias
+        `
+
+        const resource1 = `
+        value = "Value"
+        `;
+
+
+        const pathMap: Record<string, string> = {
+            "resource1": resource1,
+        };
+
+        function resolveImport(resource: string) {
+            return Promise.resolve({ expression: pathMap[resource], resource });
+        }
+        const patterns = await Grammar.parse(expression, { resolveImport });
+        const pattern = patterns.get("name") as Literal;
+
+        const result = pattern.exec("Value");
+        expect(result.ast?.value).toBe("Value");
     });
 });

package/src/grammar/Grammar.ts

@@ -119,9 +119,15 @@ export class Grammar {
     }
 
     private _buildPatterns(ast: Node) {
-        ast.findAll(n => n.name === "statement").forEach((n) => {
+        const body = ast.find(n => n.name === "body");
+
+        if (body == null) {
+            return;
+        }
+
+        body.findAll(n => n.name === "assign-statement" || n.name === "export-name").forEach((n) => {
             const typeNode = n.find(n => n.name.includes("literal"));
-            const type = typeNode?.name || "unknown";
+            const type = n.name === "export-name" ? "export-name" : typeNode?.name || "unknown";
 
             switch (type) {
                 case "literal": {
@@ -148,6 +154,11 @@ export class Grammar {
                     this._buildAlias(n)
                     break;
                 }
+                case "export-name": {
+                    const pattern = this._getPattern(n.value);
+                    this._parseContext.patternsByName.set(n.value, pattern);
+                    break;
+                }
                 default: {
                     break;
                 }
@@ -172,20 +183,42 @@ export class Grammar {
 
             try {
                 const patterns = await grammar.parse(grammarFile.expression);
-                const importNames = importStatement.findAll(n => n.name === "import-name").map(n => n.value);
-
-                importNames.forEach((importName) => {
-                    if (parseContext.importedPatternsByName.has(importName)) {
-                        throw new Error(`'${importName}' was already used within another import.`);
+                const importStatements = importStatement.findAll(n => n.name === "import-name" || n.name === "import-alias");
+
+                importStatements.forEach((node) => {
+                    if (node.name === "import-name") {
+                        const importName = node.value;
+
+                        if (parseContext.importedPatternsByName.has(importName)) {
+                            throw new Error(`'${importName}' was already used within another import.`);
+                        }
+
+                        const pattern = patterns.get(importName);
+                        if (pattern == null) {
+                            throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
+                        }
+
+                        parseContext.importedPatternsByName.set(importName, pattern);
+                    } else {
+                        const importNameNode = node.find(n => n.name === "import-name") as Node;
+                        const importName = importNameNode.value;
+                        const aliasNode = node.find(n => n.name === "import-name-alias") as Node;
+                        const alias = aliasNode.value;
+
+                        if (parseContext.importedPatternsByName.has(alias)) {
+                            throw new Error(`'${alias}' was already used within another import.`);
+                        }
+
+                        const pattern = patterns.get(importName);
+                        if (pattern == null) {
+                            throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
+                        }
+
+                        parseContext.importedPatternsByName.set(alias, pattern);
                     }
+                });
 
-                    const pattern = patterns.get(importName);
-                    if (pattern == null) {
-                        throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
-                    }
 
-                    parseContext.importedPatternsByName.set(importName, pattern);
-                })
 
             } catch (e: any) {
                 throw new Error(`Failed loading expression from: "${resource}". Error details: "${e.message}"`);
@@ -199,7 +232,7 @@ export class Grammar {
         const paramsStatement = importStatement.find(n => n.name === "with-params-statement");
 
         if (paramsStatement != null) {
-            const statements = paramsStatement.find(n => n.name === "body");
+            const statements = paramsStatement.find(n => n.name === "with-params-body");
 
             if (statements != null) {
                 const expression = statements.toString();

package/src/grammar/patterns/import.ts

@@ -7,18 +7,22 @@ import { Or } from "../../patterns/Or";
 import { body } from "./body";
 import { allSpaces, lineSpaces } from "./spaces";
 
+const optionalSpaces = allSpaces.clone("optional-spaces", true);
+const optionalLineSpaces = lineSpaces.clone("options-line-spaces", true);
+
 const importNameDivider = new Regex("import-name-divider", "(\\s+)?,(\\s+)?");
 const importKeyword = new Literal("import", "import");
 const useParamsKeyword = new Literal("use-params", "use params");
+const asKeyword = new Literal("as", "as");
 const fromKeyword = new Literal("from", "from");
 const openBracket = new Literal("open-bracket", "{");
 const closeBracket = new Literal("close-bracket", "}");
 const name = new Regex("import-name", "[^}\\s,]+");
-const importedNames = new Repeat("imported-names", name, { divider: importNameDivider });
+const importNameAlias = name.clone("import-name-alias");
+const importAlias = new And("import-alias", [name, lineSpaces, asKeyword, lineSpaces, importNameAlias]);
+const importedNames = new Repeat("imported-names", new Or("import-names", [importAlias, name]), { divider: importNameDivider });
 const paramName = name.clone("param-name");
 const paramNames = new Repeat("param-names", paramName, { divider: importNameDivider });
-const optionalSpaces = allSpaces.clone("optional-spaces", true);
-const optionalLineSpaces = lineSpaces.clone("options-line-spaces", true);
 const resource = literal.clone("resource");
 
 const useParams = new And("import-params", [
@@ -37,7 +41,7 @@ const withParamsStatement = new And("with-params-statement", [
     optionalLineSpaces,
     openBracket,
     optionalSpaces,
-    body,
+    body.clone("with-params-body"),
     optionalSpaces,
     closeBracket
 ], true);

package/src/grammar/patterns/statement.ts

@@ -21,11 +21,13 @@ const statements = new Or("statements", [
     name.clone("alias-literal"),
 ]);
 
-export const statement = new And("statement", [
+const assignStatement = new And("assign-statement", [
     optionalSpaces,
     name,
     optionalSpaces,
     assignOperator,
     optionalSpaces,
     statements
-]);
+]);
+
+export const statement = new Or("statement", [assignStatement, name.clone("export-name")]);