clarity-pattern-parser 8.4.9 → 8.4.10

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,7 +119,7 @@ export class Grammar {
     }
 
     private _buildPatterns(ast: Node) {
-        ast.children.forEach((n) => {
+        ast.findAll(n => n.name === "statement").forEach((n) => {
             const typeNode = n.find(n => n.name.includes("literal"));
             const type = typeNode?.name || "unknown";
 
@@ -150,14 +157,18 @@ 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);
@@ -170,19 +181,48 @@ export class Grammar {
 
                     const pattern = patterns.get(importName);
                     if (pattern == null) {
-                        throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${url}.`);
+                        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: "${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 === "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 +263,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 +378,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,64 @@ 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 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 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 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");
 
-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,
+    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,
@@ -29,8 +27,5 @@ export const statement = new And("statement", [
     optionalSpaces,
     assignOperator,
     optionalSpaces,
-    statements,
-    optionalSpaces,
-    optionalComment,
-    optionalSpaces,
+    statements
 ]);

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
+```