clarity-pattern-parser 11.1.4 → 11.2.0

package/dist/patterns/Context.d.ts

@@ -6,6 +6,7 @@ export declare class Context implements Pattern {
     private _id;
     private _type;
     private _name;
+    private _referencePatternName;
     private _parent;
     private _children;
     private _pattern;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "11.1.4",
+  "version": "11.2.0",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",

package/src/grammar/Grammar.test.ts

@@ -11,6 +11,7 @@ import { Optional } from "../patterns/Optional";
 import { Context } from "../patterns/Context";
 import { createPatternsTemplate, patterns } from "./patterns";
 import { Expression } from "../patterns/Expression";
+import { Cursor } from "../patterns/Cursor";
 
 describe("Grammar", () => {
     test("Literal", () => {
@@ -496,11 +497,83 @@ describe("Grammar", () => {
         }
         const patterns = await Grammar.parse(expression, { resolveImport });
         const pattern = patterns["name"] as Literal;
+        const result = pattern.exec("Value");
+        expect(result.ast?.value).toBe("Value");
+    });
+
+    test("Default Params Resolves to Default Value", async () => {
+        const expression = `
+        use params {
+            value = default-value
+        }
+
+        default-value = "DefaultValue"
+        alias = value
+        `;
+
+        function resolveImport(_: string) {
+            return Promise.reject(new Error("No Import"));
+        }
+
+        const patterns = await Grammar.parse(expression, { resolveImport });
+        const pattern = patterns["alias"] as Literal;
+
+        const result = pattern.exec("DefaultValue");
+        expect(result.ast?.value).toBe("DefaultValue");
+    });
+
+    test("Default Params Resolves to params imported", async () => {
+        const expression = `
+        use params {
+            value = default-value
+        }
+
+        default-value = "DefaultValue"
+        alias = value
+        `;
+
+        function resolveImport(_: string) {
+            return Promise.reject(new Error("No Import"));
+        }
+
+        const patterns = await Grammar.parse(expression, { resolveImport, params: [new Literal("value", "Value")] });
+        const pattern = patterns["alias"] as Literal;
 
         const result = pattern.exec("Value");
         expect(result.ast?.value).toBe("Value");
     });
 
+    test("Default Params Resolves to imported default value", async () => {
+        const expression = `
+        import { my-value as default-value } from "resource1"
+        use params {
+            value = default-value
+        }
+
+        default-value = "DefaultValue"
+        alias = value
+        `;
+
+        const resource1 = `
+            my-value = "MyValue"
+        `;
+
+
+        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["alias"] as Literal;
+
+        const result = pattern.exec("MyValue");
+        expect(result.ast?.value).toBe("MyValue");
+    });
+
     test("Anonymous Patterns", () => {
         const expression = `
             complex-expression = !"NOT_THIS" + "Text"? + /regex/ + ("Text" <|> /regex/ <|> (pattern)+) + (pattern | pattern)
@@ -696,4 +769,13 @@ describe("Grammar", () => {
         `;
     });
 
+    test("Take Until", () => {
+        const { scriptText } = patterns`
+            script-text = ?->| "</script"
+        `;
+        const result = scriptText.parse(new Cursor("function(){}</script"));
+
+        expect(result?.value).toBe("function(){}");
+    });
+
 });

package/src/grammar/Grammar.ts

@@ -11,6 +11,7 @@ import { Repeat, RepeatOptions } from "../patterns/Repeat";
 import { Optional } from "../patterns/Optional";
 import { Context } from "../patterns/Context";
 import { Expression } from "../patterns/Expression";
+import { TakeUntil } from "../patterns/TakeUntil";
 import { RightAssociated } from "../patterns/RightAssociated";
 import { generateErrorMessage } from "../patterns/generate_error_message";
 import { tokens } from "./decorators/tokens";
@@ -30,6 +31,7 @@ const patternNodes: Record<string, boolean> = {
     "sequence-literal": true,
     "repeat-literal": true,
     "alias-literal": true,
+    "take-until-literal": true,
     "configurable-anonymous-pattern": true
 };
 
@@ -180,6 +182,10 @@ export class Grammar {
                     this._saveAlias(n);
                     break;
                 }
+                case "take-until-literal": {
+                    this._saveTakeUntil(n);
+                    break;
+                }
                 case "configurable-anonymous-pattern": {
                     this._saveConfigurableAnonymous(n);
                     break;
@@ -196,6 +202,7 @@ export class Grammar {
         });
     }
 
+
     private _saveLiteral(statementNode: Node) {
         const nameNode = statementNode.find(n => n.name === "name") as Node;
         const literalNode = statementNode.find(n => n.name === "literal") as Node;
@@ -322,6 +329,9 @@ export class Grammar {
             case "sequence-literal": {
                 return this._buildSequence(name, node);
             }
+            case "take-until-literal": {
+                return this._buildTakeUntil(name, node);
+            }
             case "complex-anonymous-pattern": {
                 return this._buildComplexAnonymousPattern(node);
             }
@@ -422,6 +432,24 @@ export class Grammar {
         return isOptional ? new Optional(name, new Repeat(`inner-optional-${name}`, pattern, options)) : new Repeat(name, pattern, options);
     }
 
+    private _saveTakeUntil(statementNode: Node) {
+        const nameNode = statementNode.find(n => n.name === "name") as Node;
+        const name = nameNode.value;
+        const takeUntilNode = statementNode.find(n => n.name === "take-until-literal") as Node;
+        const takeUntil = this._buildTakeUntil(name, takeUntilNode);
+
+        this._applyDecorators(statementNode, takeUntil);
+        this._parseContext.patternsByName.set(name, takeUntil);
+    }
+
+
+    private _buildTakeUntil(name: string, takeUntilNode: Node) {
+        const patternNode = takeUntilNode.children[takeUntilNode.children.length - 1];
+        const untilPattern = this._buildPattern(patternNode);
+
+        return new TakeUntil(name, untilPattern);
+    }
+
     private _saveConfigurableAnonymous(node: Node) {
         const nameNode = node.find(n => n.name === "name") as Node;
         const name = nameNode.value;
@@ -440,69 +468,106 @@ export class Grammar {
     }
 
     private async _resolveImports(ast: Node) {
+        const importStatements = ast.findAll(n => {
+            return n.name === "import-from" || n.name === "param-name-with-default-value";
+        });
+
+        for (const statement of importStatements) {
+            if (statement.name === "import-from") {
+                await this.processImport(statement);
+            } else {
+                this.processUseParams(statement);
+            }
+        }
+    }
+
+    private async processImport(importStatement: Node) {
         const parseContext = this._parseContext;
-        const importStatements = ast.findAll(n => n.name === "import-from");
-
-        for (const importStatement of importStatements) {
-            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,
-                decorators: this._parseContext.decorators
-            });
+        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,
+            decorators: this._parseContext.decorators
+        });
 
-            try {
-                const patterns = await grammar.parse(grammarFile.expression);
-                const importStatements = importStatement.findAll(n => n.name === "import-name" || n.name === "import-alias");
+        try {
+            const patterns = await grammar.parse(grammarFile.expression);
+            const importStatements = importStatement.findAll(n => n.name === "import-name" || n.name === "import-alias");
+
+            importStatements.forEach((node) => {
+                if (node.name === "import-name" && node.parent?.name === "import-alias") {
+                    return;
+                }
+
+                if (node.name === "import-name" && node.parent?.name !== "import-alias") {
+                    const importName = node.value;
 
-                importStatements.forEach((node) => {
-                    if (node.name === "import-name" && node.parent?.name === "import-alias") {
-                        return;
+                    if (parseContext.importedPatternsByName.has(importName)) {
+                        throw new Error(`'${importName}' was already used within another import.`);
                     }
 
-                    if (node.name === "import-name" && node.parent?.name !== "import-alias") {
-                        const importName = node.value;
+                    const pattern = patterns[importName];
+                    if (pattern == null) {
+                        throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
+                    }
 
-                        if (parseContext.importedPatternsByName.has(importName)) {
-                            throw new Error(`'${importName}' was already used within another import.`);
-                        }
+                    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;
 
-                        const pattern = patterns[importName];
-                        if (pattern == null) {
-                            throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
-                        }
+                    if (parseContext.importedPatternsByName.has(alias)) {
+                        throw new Error(`'${alias}' was already used within another import.`);
+                    }
 
-                        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;
+                    const pattern = patterns[importName];
+                    if (pattern == null) {
+                        throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
+                    }
 
-                        if (parseContext.importedPatternsByName.has(alias)) {
-                            throw new Error(`'${alias}' was already used within another import.`);
-                        }
+                    parseContext.importedPatternsByName.set(alias, pattern.clone(alias));
+                }
+            });
 
-                        const pattern = patterns[importName];
-                        if (pattern == null) {
-                            throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
-                        }
+        } catch (e: any) {
+            throw new Error(`Failed loading expression from: "${resource}". Error details: "${e.message}"`);
+        }
 
-                        parseContext.importedPatternsByName.set(alias, pattern.clone(alias));
-                    }
-                });
+    }
 
+    private processUseParams(paramName: Node) {
+        const defaultValueNode = paramName.find(n => n.name === "param-default");
+        if (defaultValueNode === null) {
+            return;
+        }
 
+        const nameNode = paramName.find(n => n.name === "param-name");
+        const defaultNameNode = defaultValueNode.find(n => n.name === "default-param-name");
 
-            } catch (e: any) {
-                throw new Error(`Failed loading expression from: "${resource}". Error details: "${e.message}"`);
-            }
+        if (nameNode == null || defaultNameNode == null) {
+            return;
+        }
+
+        const name = nameNode.value;
+        const defaultName = defaultNameNode.value;
 
+        if (this._parseContext.paramsByName.has(name)) {
+            return;
+        }
+
+        let pattern = this._parseContext.importedPatternsByName.get(defaultName);
+
+        if (pattern == null) {
+            pattern = new Reference(defaultName);
         }
+
+        this._parseContext.importedPatternsByName.set(name, pattern);
     }
 
     private _applyDecorators(statementNode: Node, pattern: Pattern) {
@@ -615,7 +680,7 @@ export class Grammar {
 
         // This solves the problem for an alias pointing to a reference.
         if (aliasPattern.type === "reference") {
-            const reference = new Reference(name, aliasName);
+            const reference = aliasPattern.clone(name);
             this._applyDecorators(statementNode, reference);
             this._parseContext.patternsByName.set(name, reference);
         } else {

package/src/grammar/patterns/import.ts

@@ -23,12 +23,24 @@ 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 equal = new Literal("equal", "=");
 
 const importNameAlias = name.clone("import-name-alias");
 const importAlias = new Sequence("import-alias", [name, lineSpaces, asKeyword, lineSpaces, importNameAlias]);
 const importedNames = new Repeat("imported-names", new Options("import-names", [importAlias, name]), { divider: importNameDivider });
 const paramName = name.clone("param-name");
-const paramNames = new Repeat("param-names", paramName, { divider: importNameDivider });
+const defaultParamName = name.clone("default-param-name");
+
+const paramNameWithDefault = new Sequence("param-name-with-default-value", [
+    paramName,
+    new Optional("optional-param-default", new Sequence("param-default", [
+        optionalLineSpaces,
+        equal,
+        optionalLineSpaces,
+        defaultParamName,
+    ])),
+]);
+const paramNames = new Repeat("param-names", paramNameWithDefault, { divider: importNameDivider });
 const resource = literal.clone("resource");
 
 const useParams = new Sequence("import-params", [

package/src/grammar/patterns/literals.ts

@@ -14,6 +14,7 @@ export const anonymousLiterals = new Options("anonymous-literals", [
 ]);
 
 export const anonymousWrappedLiterals = new Options("anonymous-wrapped-literals", [
+    new Reference("take-until-literal"),
     new Reference("options-literal"),
     new Reference("sequence-literal"),
     new Reference("complex-anonymous-pattern")

package/src/grammar/patterns/pattern.ts

@@ -5,6 +5,7 @@ import { repeatLiteral } from "./repeatLiteral";
 import { sequenceLiteral } from "./sequenceLiteral";
 import { optionsLiteral } from "./optionsLiteral";
 import { anonymousPattern } from "./anonymousPattern";
+import { takeUntilLiteral } from "./takeUtilLiteral";
 import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
 import { name } from "./name";
@@ -20,8 +21,9 @@ export const pattern = new Options("pattern", [
     literal,
     regexLiteral,
     repeatLiteral,
+    takeUntilLiteral,
     aliasLiteral,
     optionsLiteral,
     sequenceLiteral,
     configurableAnonymousPattern,
-],  true);
+], true);

package/src/grammar/patterns/takeUtilLiteral.ts

@@ -0,0 +1,21 @@
+import { Literal } from "../../patterns/Literal"
+import { Optional } from "../../patterns/Optional";
+import { Sequence } from "../../patterns/Sequence";
+import { lineSpaces } from "./spaces";
+import { name } from "./name";
+import { Reference } from "../../patterns/Reference";
+
+const anyChar = new Literal("any-char", "?");
+const upTo = new Literal("up-to", "->");
+const wall = new Literal("wall", "|");
+const optionalLineSpaces = new Optional("optional-line-spaces", lineSpaces);
+
+export const takeUntilLiteral = new Sequence("take-until-literal", [
+    anyChar,
+    optionalLineSpaces,
+    upTo,
+    optionalLineSpaces,
+    wall,
+    optionalLineSpaces,
+    new Reference("pattern")
+]);

package/src/grammar/patterns.test.ts

@@ -1,8 +1,8 @@
 import { patterns } from "./patterns";
 
-describe("Patterns String Template Literal", ()=>{
-    test("Baseline", ()=>{
-        const {fullName} = patterns`
+describe("Patterns String Template Literal", () => {
+    test("Baseline", () => {
+        const { fullName } = patterns`
         first-name = "John"
         last-name = "Doe"
         space = /\\s+/
@@ -13,8 +13,8 @@ describe("Patterns String Template Literal", ()=>{
         expect(result?.ast?.value).toBe("John Doe");
     });
 
-    test("Simple Markup", ()=>{
-        const {body} = patterns`
+    test("Simple Markup", () => {
+        const { body } = patterns`
         tag-name = /[a-zA-Z_-]+[a-zA-Z0-9_-]*/
         space = /\\s+/
         opening-tag = "<" + tag-name + space? + ">"
@@ -32,7 +32,7 @@ describe("Patterns String Template Literal", ()=>{
             <div></div>    
         </div>
         `, true);
-        result && result.ast && result.ast.findAll(n=>n.name.includes("space")).forEach(n=>n.remove());
+        result && result.ast && result.ast.findAll(n => n.name.includes("space")).forEach(n => n.remove());
         expect(result?.ast?.value).toBe("<div><div></div><div></div></div>");
     });
 });

package/src/grammar/patterns.ts

@@ -38,5 +38,5 @@ export function createPatternsTemplate(options: GrammarOptions){
         });
     
         return result;
-    }
+    };
 }

package/src/patterns/Context.ts

@@ -9,6 +9,7 @@ export class Context implements Pattern {
     private _id: string;
     private _type: string;
     private _name: string;
+    private _referencePatternName: string;
     private _parent: Pattern | null;
     private _children: Pattern[];
     private _pattern: Pattern;
@@ -43,6 +44,10 @@ export class Context implements Pattern {
     }
 
     getPatternWithinContext(name: string): Pattern | null {
+        if (this._name === name || this._referencePatternName === name){
+            return this;
+        }
+
         return this._patterns[name] || null;
     }
 
@@ -56,6 +61,7 @@ export class Context implements Pattern {
         this._name = name;
         this._parent = null;
         this._patterns = {};
+        this._referencePatternName = name;
 
         const clonedPattern = pattern.clone();
         context.forEach(p => this._patterns[p.name] = p);
@@ -79,6 +85,7 @@ export class Context implements Pattern {
 
     clone(name = this._name): Pattern {
         const clone = new Context(name, this._pattern.clone(name), Object.values(this._patterns));
+        clone._referencePatternName = this._referencePatternName;
         clone._id = this._id;
         return clone;
     }

package/src/patterns/TakeUntil.test.ts

@@ -0,0 +1,62 @@
+import { Cursor } from "./Cursor";
+import { Literal } from "./Literal";
+import { Options } from "./Options";
+import { TakeUntil } from "./TakeUntil";
+
+describe("TakeUntil", () => {
+    test("Take With No End", () => {
+        const takeUntilScript = new TakeUntil(
+            "script-content",
+            new Literal("close-script-tag", "</script")
+        );
+
+        const result = takeUntilScript.exec("function(){}");
+
+        expect(result.ast?.value).toBe("function(){}");
+    });
+
+    test("Take Until Terminating Match", () => {
+        const takeUntilScript = new TakeUntil(
+            "script-content",
+            new Literal("close-script-tag", "</script")
+        );
+        const cursor = new Cursor("function(){}function(){}</script");
+        const result = takeUntilScript.parse(cursor);
+
+        expect(result?.value).toBe("function(){}function(){}");
+        expect(cursor.index).toBe(23);
+    });
+
+    test("Take Until Terminating Complex Match", () => {
+        const takeUntilScript = new TakeUntil(
+            "script-content",
+            new Options("end-tags", [
+                new Literal("close-script-tag", "</script"),
+                new Literal("close-style-tag", "</style")
+            ])
+        );
+        let cursor = new Cursor("function(){}function(){}</script");
+        let result = takeUntilScript.parse(cursor);
+
+        expect(result?.value).toBe("function(){}function(){}");
+        expect(cursor.index).toBe(23);
+
+        cursor = new Cursor("function(){}function(){}</style");
+        result = takeUntilScript.parse(cursor);
+
+        expect(result?.value).toBe("function(){}function(){}");
+        expect(cursor.index).toBe(23);
+    });
+
+    test("Error", () => {
+        const takeUntilScript = new TakeUntil(
+            "script-content",
+            new Literal("close-script-tag", "</script")
+        );
+        const cursor = new Cursor("</script");
+        const result = takeUntilScript.parse(cursor);
+
+        expect(result).toBeNull();
+        expect(cursor.index).toBe(0);
+    });
+});