clarity-pattern-parser 8.4.9 → 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();
 
     });
 
@@ -296,9 +296,9 @@ describe("Grammar", () => {
         space = " "
         full-name = first-name & space & last-name
         `
-        function resolveImport(path: string) {
-            expect(path).toBe("some/path/to/file.cpat");
-            return Promise.resolve({ expression: importExpression, path });
+        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 });
@@ -323,8 +323,8 @@ describe("Grammar", () => {
         last-name = "Doe"
         full-name = first-name & space & last-name
         `
-        function resolveImport(path: string) {
-            return Promise.resolve({ expression: pathMap[path], path });
+        function resolveImport(resource: string) {
+            return Promise.resolve({ expression: pathMap[resource], resource });
         }
 
         const patterns = await Grammar.parse(expression, { resolveImport });
@@ -333,4 +333,93 @@ describe("Grammar", () => {
         expect(result?.ast?.value).toBe("John Doe");
     });
 
+    test("Imports with Params", async () => {
+        const importExpression = `first-name = "John"`;
+        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
+        `
+
+        const pathMap: Record<string, string> = {
+            "space.cpat": spaceExpression,
+            "first-name.cpat": importExpression
+        };
+
+        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 result = fullname.exec("John  Doe");
+        expect(result?.ast?.value).toBe("John  Doe");
+    });
+
+    test("Export Name", async () => {
+        const expression = `
+        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

@@ -11,38 +11,41 @@ import { Repeat, RepeatOptions } from "../patterns/Repeat";
 import { AutoComplete } from "../intellisense/AutoComplete";
 
 class ParseContext {
+    constructor(params: Pattern[]) {
+        params.forEach(p => this.paramsByName.set(p.name, p));
+    }
     patternsByName = new Map<string, Pattern>();
     importedPatternsByName = new Map<string, Pattern>();
+    paramsByName = new Map<string, Pattern>();
 }
 
 function defaultImportResolver(_path: string, _basePath: string | null): Promise<GrammarFile> {
     throw new Error("No import resolver supplied.");
 }
 
-export interface GrammarMeta {
-    originPath?: string;
-}
-
 export interface GrammarFile {
-    path: string;
+    resource: string;
     expression: string;
 }
 
 export interface GrammarOptions {
-    resolveImport?: (path: string, originPath: string | null) => Promise<GrammarFile>;
-    meta?: GrammarMeta | null;
+    resolveImport?: (resource: string, originResource: string | null) => Promise<GrammarFile>;
+    originResource?: string | null;
+    params?: Pattern[];
 }
 
 export class Grammar {
-    private _meta: GrammarMeta | null;
-    private _resolveImport: (path: string, basePath: string | null) => Promise<GrammarFile>;
+    private _params: Pattern[];
+    private _originResource?: string | null;
+    private _resolveImport: (resource: string, originResource: string | null) => Promise<GrammarFile>;
     private _parseContext: ParseContext;
     private _autoComplete: AutoComplete;
 
     constructor(options: GrammarOptions = {}) {
-        this._meta = options.meta == null ? null : options.meta;
+        this._params = options?.params == null ? [] : options.params;
+        this._originResource = options?.originResource == null ? null : options.originResource;
         this._resolveImport = options.resolveImport == null ? defaultImportResolver : options.resolveImport;
-        this._parseContext = new ParseContext();
+        this._parseContext = new ParseContext(this._params);
         this._autoComplete = new AutoComplete(grammar, {
             greedyPatternNames: ["spaces", "optional-spaces", "whitespace", "new-line"],
             customTokens: {
@@ -56,13 +59,17 @@ export class Grammar {
 
     async import(path: string) {
         const grammarFile = await this._resolveImport(path, null);
-        const grammar = new Grammar({ resolveImport: this._resolveImport, meta: { originPath: grammarFile.path } });
+        const grammar = new Grammar({
+            resolveImport: this._resolveImport,
+            originResource: grammarFile.resource,
+            params: this._params
+        });
 
         return grammar.parse(grammarFile.expression);
     }
 
     async parse(expression: string) {
-        this._parseContext = new ParseContext();
+        this._parseContext = new ParseContext(this._params);
         const ast = this._tryToParse(expression);
 
         await this._resolveImports(ast);
@@ -72,7 +79,7 @@ export class Grammar {
     }
 
     parseString(expression: string) {
-        this._parseContext = new ParseContext();
+        this._parseContext = new ParseContext(this._params);
         const ast = this._tryToParse(expression);
 
         if (this._hasImports(ast)) {
@@ -112,9 +119,15 @@ export class Grammar {
     }
 
     private _buildPatterns(ast: Node) {
-        ast.children.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": {
@@ -141,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;
                 }
@@ -150,39 +168,94 @@ export class Grammar {
 
     private async _resolveImports(ast: Node) {
         const parseContext = this._parseContext;
-        const importStatements = ast.findAll(n => n.name === "import-statement");
+        const importStatements = ast.findAll(n => n.name === "import-from");
 
         for (const importStatement of importStatements) {
-            const urlNode = importStatement.find(n => n.name === "url") as Node;
-
-            const url = urlNode.value.slice(1, -1);
-            const grammarFile = await this._resolveImport(url, this._meta?.originPath || null);
-            const grammar = new Grammar({ resolveImport: this._resolveImport, meta: { originPath: grammarFile.path } });
+            const resourceNode = importStatement.find(n => n.name === "resource") as Node;
+            const params = this._getParams(importStatement);
+            const resource = resourceNode.value.slice(1, -1);
+            const grammarFile = await this._resolveImport(resource, this._originResource || null);
+            const grammar = new Grammar({
+                resolveImport: this._resolveImport,
+                originResource: grammarFile.resource,
+                params
+            });
 
             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: ${url}.`);
-                    }
 
-                    parseContext.importedPatternsByName.set(importName, pattern);
-                })
 
             } catch (e: any) {
-                throw new Error(`Failed loading expression from: "${url}". Error details: "${e.message}"`);
+                throw new Error(`Failed loading expression from: "${resource}". Error details: "${e.message}"`);
             }
 
         }
     }
 
+    private _getParams(importStatement: Node) {
+        let params: Pattern[] = [];
+        const paramsStatement = importStatement.find(n => n.name === "with-params-statement");
+
+        if (paramsStatement != null) {
+            const statements = paramsStatement.find(n => n.name === "with-params-body");
+
+            if (statements != null) {
+                const expression = statements.toString();
+                const importedValues = Array.from(this
+                    ._parseContext
+                    .importedPatternsByName
+                    .values()
+                )
+
+                const grammar = new Grammar({
+                    params: importedValues,
+                    originResource: this._originResource,
+                    resolveImport: this._resolveImport
+                });
+
+                const patterns = grammar.parseString(expression);
+                params = Array.from(patterns.values());
+            }
+        }
+
+        return params;
+    }
+
     private _buildLiteral(statementNode: Node) {
         const nameNode = statementNode.find(n => n.name === "name") as Node;
         const literalNode = statementNode.find(n => n.name === "literal") as Node;
@@ -223,6 +296,10 @@ export class Grammar {
             pattern = this._parseContext.importedPatternsByName.get(name);
         }
 
+        if (pattern == null) {
+            pattern = this._parseContext.paramsByName.get(name);
+        }
+
         if (pattern == null) {
             return new Reference(name);
         }
@@ -334,8 +411,8 @@ export class Grammar {
         return grammar.import(path);
     }
 
-    static parseString(expression: string) {
-        const grammar = new Grammar();
+    static parseString(expression: string, options?: GrammarOptions) {
+        const grammar = new Grammar(options);
         return grammar.parseString(expression);
     }
 

package/src/grammar/patterns/body.ts

@@ -0,0 +1,19 @@
+import { And } from "../../patterns/And";
+import { Or } from "../../patterns/Or";
+import { Repeat } from "../../patterns/Repeat";
+import { comment } from "./comment";
+import { lineSpaces, newLine } from "./spaces";
+import { statement } from "./statement";
+
+const bodyLineContent = new Or("body-line-content", [
+    comment,
+    statement
+]);
+
+const bodyLine = new And("body-line", [
+    lineSpaces.clone("line-spaces", true),
+    bodyLineContent,
+    lineSpaces.clone("line-spaces", true),
+]);
+
+export const body = new Repeat("body", bodyLine, {divider: newLine, min: 0});

package/src/grammar/patterns/grammar.ts

@@ -2,21 +2,38 @@ import { Or } from "../../patterns/Or";
 import { Regex } from "../../patterns/Regex";
 import { Repeat } from "../../patterns/Repeat";
 import { comment } from "./comment";
-import { statement } from "./statement";
 import { importStatement } from './import';
+import { And } from "../../patterns/And";
+import { allSpaces } from "./spaces";
+import { body } from "./body";
 
-const whitespace = new Regex("whitespace", "[ \\t]+((\\r?\\n)+)?");
+const tabs = new Regex("tabs", "\\t+");
+const spaces = new Regex("spaces", "[ ]+");
 const newLine = new Regex("new-line", "(\\r?\\n)+");
 
-whitespace.setTokens([" "]);
+spaces.setTokens([" "]);
+tabs.setTokens(["\t"]);
 newLine.setTokens(["\n"]);
 
-const line = new Or("line", [
-    newLine,
-    whitespace,
+const lineSpaces = new Repeat("line-spaces", new Or("line-space", [tabs, spaces]));
+
+const headLineContent = new Or("head-line-content", [
     comment,
-    importStatement,
-    statement
+    importStatement
+]);
+
+const headLine = new And("head-line-content", [
+    lineSpaces.clone("line-spaces", true),
+    headLineContent,
+    lineSpaces.clone("line-spaces", true),
 ]);
 
-export const grammar = new Repeat("grammer", line);
+const head = new Repeat("head", headLine, { divider: newLine, min: 0 });
+
+export const grammar = new And("grammar", [
+    allSpaces,
+    head,
+    allSpaces,
+    body,
+    allSpaces
+]);

package/src/grammar/patterns/import.ts

@@ -3,27 +3,68 @@ import { Repeat } from "../../patterns/Repeat";
 import { Literal } from "../../patterns/Literal";
 import { Regex } from "../../patterns/Regex";
 import { literal } from "./literal";
+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 spaces = new Regex("spaces", "\\s+", 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 optionalSpaces = spaces.clone("optional-spaces", true);
+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 resource = literal.clone("resource");
 
-export const importStatement = new And("import-statement", [
-    importKeyword,
+const useParams = new And("import-params", [
+    useParamsKeyword,
+    optionalLineSpaces,
+    openBracket,
+    optionalSpaces,
+    paramNames,
+    optionalSpaces,
+    closeBracket
+]);
+
+const withParamsKeyword = new Literal("with-params", "with params");
+const withParamsStatement = new And("with-params-statement", [
+    withParamsKeyword,
+    optionalLineSpaces,
+    openBracket,
     optionalSpaces,
+    body.clone("with-params-body"),
+    optionalSpaces,
+    closeBracket
+], true);
+
+const importFromStatement = new And("import-from", [
+    importKeyword,
+    optionalLineSpaces,
     openBracket,
     optionalSpaces,
     importedNames,
     optionalSpaces,
     closeBracket,
-    optionalSpaces,
+    optionalLineSpaces,
     fromKeyword,
-    spaces,
-    literal.clone("url"),
+    optionalLineSpaces,
+    resource,
+    optionalLineSpaces,
+    withParamsStatement
 ]);
+
+export const importStatement = new Or("import-statement", [
+    useParams,
+    importFromStatement
+]);
+
+

package/src/grammar/patterns/spaces.ts

@@ -1,4 +1,14 @@
+import { Or } from "../../patterns/Or";
 import { Regex } from "../../patterns/Regex";
+import { Repeat } from "../../patterns/Repeat";
 
-export const spaces = new Regex("spaces", "[ \\t]+");
-spaces.setTokens([" "]);
+export const tabs = new Regex("tabs", "\\t+");
+export const spaces = new Regex("spaces", "[ ]+");
+export const newLine = new Regex("new-line", "(\\r?\\n)+");
+
+spaces.setTokens([" "]);
+tabs.setTokens(["\t"]);
+newLine.setTokens(["\n"]);
+
+export const lineSpaces = new Repeat("line-spaces", new Or("line-space", [tabs, spaces]));
+export const allSpaces = new Regex("all-spaces", "\\s+", true);

package/src/grammar/patterns/statement.ts

@@ -8,11 +8,9 @@ import { regexLiteral } from "./regexLiteral";
 import { repeatLiteral } from "./repeatLiteral";
 import { spaces } from "./spaces";
 import { literal } from "./literal";
-import { comment } from "./comment";
 
 const optionalSpaces = spaces.clone("optional-spaces", true);
 const assignOperator = new Literal("assign-operator", "=");
-const optionalComment = comment.clone("inline-comment", true);
 
 const statements = new Or("statements", [
     literal,
@@ -23,14 +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,
-    optionalSpaces,
-    optionalComment,
-    optionalSpaces,
-]);
+    statements
+]);
+
+export const statement = new Or("statement", [assignStatement, name.clone("export-name")]);

package/src/grammar/spec.md

@@ -164,3 +164,27 @@ import { last-name } from "https://some.cdn.com/some/last-name.cpat"
 
 full-name = first-name & spaces & last-name
 ```
+
+### Import Params
+This allows you to inject patterns within another pattern.
+```ts
+const firstName = new Literal("first-name", "Jared");
+const grammar = Grammar.import('file.cpat', {params: [firstName, LastName]})
+```
+file.cpat
+```
+import params { first-names, last-names } 
+
+full-name = first-names & spaces & last-names
+```
+
+### Imports with Params
+```
+import params { other-pattern }
+import { first-names, last-names } from "some-file.cpat" with params {
+    some-pattern = "Some Pattern"
+    some-pattern2 = other-pattern
+}
+
+full-name = first-names & spaces & last-names
+```