clarity-pattern-parser 8.4.14 → 9.0.0

package/src/grammar/Grammar.ts

@@ -4,11 +4,24 @@ import { Pattern } from "../patterns/Pattern";
 import { Regex } from "../patterns/Regex";
 import { Reference } from "../patterns/Reference";
 import { grammar } from "./patterns/grammar";
-import { Or } from "../patterns/Or";
+import { Options } from "../patterns/Options";
 import { Not } from "../patterns/Not";
-import { And } from "../patterns/And";
+import { Sequence } from "../patterns/Sequence";
 import { Repeat, RepeatOptions } from "../patterns/Repeat";
 import { AutoComplete } from "../intellisense/AutoComplete";
+import { Optional } from "../patterns/Optional";
+
+let anonymousIndexId = 0;
+
+const patternNodes: Record<string, boolean> = {
+    "literal": true,
+    "regex-literal": true,
+    "options-literal": true,
+    "sequence-literal": true,
+    "repeat-literal": true,
+    "alias-literal": true,
+    "configurable-anonymous-pattern": true
+};
 
 class ParseContext {
     constructor(params: Pattern[]) {
@@ -75,7 +88,7 @@ export class Grammar {
         await this._resolveImports(ast);
         this._buildPatterns(ast);
 
-        return this._parseContext.patternsByName;
+        return Object.fromEntries(this._parseContext.patternsByName) as Record<string, Pattern>;
     }
 
     parseString(expression: string) {
@@ -85,9 +98,8 @@ export class Grammar {
         if (this._hasImports(ast)) {
             throw new Error("Cannot use imports on parseString, use parse instead.");
         }
-
         this._buildPatterns(ast);
-        return this._parseContext.patternsByName;
+        return Object.fromEntries(this._parseContext.patternsByName) as Record<string, Pattern>;
     }
 
     private _tryToParse(expression: string): Node {
@@ -101,7 +113,7 @@ export class Grammar {
                 const startText = text.slice(Math.max(o.startIndex - 10), o.startIndex);
                 return startText + o.text;
             }).join("' or '") + "'";
-            const message = `[Parse Error] Found: '${foundText}', expected: ${expectedTexts}.`
+            const message = `[Parse Error] Found: '${foundText}', expected: ${expectedTexts}.`;
             throw new Error(message);
         }
 
@@ -125,38 +137,40 @@ export class Grammar {
             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 = n.name === "export-name" ? "export-name" : typeNode?.name || "unknown";
+        body.findAll(n => n.name === "assign-statement").forEach((n) => {
+            const patternNode = n.children.find(n => patternNodes[n.name] != null);
 
-            switch (type) {
+            if (patternNode == null) {
+                return;
+            }
+
+            switch (patternNode.name) {
                 case "literal": {
-                    this._buildLiteral(n)
+                    this._saveLiteral(n);
                     break;
                 }
                 case "regex-literal": {
-                    this._buildRegex(n);
+                    this._saveRegex(n);
                     break;
                 }
-                case "or-literal": {
-                    this._buildOr(n);
+                case "options-literal": {
+                    this._saveOptions(n);
                     break;
                 }
-                case "and-literal": {
-                    this._buildAnd(n)
+                case "sequence-literal": {
+                    this._saveSequence(n);
                     break;
                 }
                 case "repeat-literal": {
-                    this._buildRepeat(n)
+                    this._saveRepeat(n);
                     break;
                 }
                 case "alias-literal": {
-                    this._buildAlias(n)
+                    this._saveAlias(n);
                     break;
                 }
-                case "export-name": {
-                    const pattern = this._getPattern(n.value);
-                    this._parseContext.patternsByName.set(n.value, pattern);
+                case "configurable-anonymous-pattern": {
+                    this._saveConfigurableAnonymous(n);
                     break;
                 }
                 default: {
@@ -164,6 +178,205 @@ export class Grammar {
                 }
             }
         });
+
+        body.findAll(n => n.name === "export-name").forEach((n) => {
+            const pattern = this._getPattern(n.value).clone();
+            this._parseContext.patternsByName.set(n.value, pattern);
+        });
+    }
+
+    private _saveLiteral(statementNode: Node) {
+        const nameNode = statementNode.find(n => n.name === "name") as Node;
+        const literalNode = statementNode.find(n => n.name === "literal") as Node;
+        const name = nameNode.value;
+        const literal = this._buildLiteral(name, literalNode);
+
+        this._parseContext.patternsByName.set(name, literal);
+    }
+
+    private _buildLiteral(name: string, node: Node) {
+        return new Literal(name, this._resolveStringValue(node.value));
+    }
+
+    private _resolveStringValue(value: string) {
+        return value.replace(/\\n/g, '\n')
+            .replace(/\\r/g, '\r')
+            .replace(/\\t/g, '\t')
+            .replace(/\\b/g, '\b')
+            .replace(/\\f/g, '\f')
+            .replace(/\\v/g, '\v')
+            .replace(/\\0/g, '\0')
+            .replace(/\\x([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
+            .replace(/\\u([0-9A-Fa-f]{4})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
+            .replace(/\\(.)/g, '$1').slice(1, -1);
+    }
+
+    private _saveRegex(statementNode: Node) {
+        const nameNode = statementNode.find(n => n.name === "name") as Node;
+        const regexNode = statementNode.find(n => n.name === "regex-literal") as Node;
+        const name = nameNode.value;
+        const regex = this._buildRegex(name, regexNode);
+
+        this._parseContext.patternsByName.set(name, regex);
+    }
+
+    private _buildRegex(name: string, node: Node) {
+        const value = node.value.slice(1, node.value.length - 1);
+        return new Regex(name, value);
+    }
+
+    private _saveOptions(statementNode: Node) {
+        const nameNode = statementNode.find(n => n.name === "name") as Node;
+        const name = nameNode.value;
+        const optionsNode = statementNode.find(n => n.name === "options-literal") as Node;
+        const options = this._buildOptions(name, optionsNode);
+
+        this._parseContext.patternsByName.set(name, options);
+    }
+
+    private _buildOptions(name: string, node: Node) {
+        const patternNodes = node.children.filter(n => n.name !== "default-divider" && n.name !== "greedy-divider");
+        const isGreedy = node.find(n => n.name === "greedy-divider") != null;
+        const patterns = patternNodes.map(n => this._buildPattern(n));
+        const or = new Options(name, patterns, isGreedy);
+
+        return or;
+    }
+
+    private _buildPattern(node: Node): Pattern {
+        const type = node.name;
+        const name = `anonymous-pattern-${anonymousIndexId++}`;
+
+        switch (type) {
+            case "pattern-name": {
+                return this._getPattern(node.value).clone();
+            }
+            case "literal": {
+                return this._buildLiteral(node.value.slice(1, -1), node);
+            }
+            case "regex-literal": {
+                return this._buildRegex(node.value.slice(1, -1), node);
+            }
+            case "repeat-literal": {
+                return this._buildRepeat(name, node);
+            }
+            case "options-literal": {
+                return this._buildOptions(name, node);
+            }
+            case "sequence-literal": {
+                return this._buildSequence(name, node);
+            }
+            case "complex-anonymous-pattern": {
+                return this._buildComplexAnonymousPattern(node);
+            }
+        }
+
+        throw new Error(`Couldn't build node: ${node.name}.`);
+    }
+
+    private _saveSequence(statementNode: Node) {
+        const nameNode = statementNode.find(n => n.name === "name") as Node;
+        const name = nameNode.value;
+        const sequenceNode = statementNode.find(n => n.name === "sequence-literal") as Node;
+        const sequence = this._buildSequence(name, sequenceNode);
+
+        this._parseContext.patternsByName.set(name, sequence);
+    }
+
+    private _buildSequence(name: string, node: Node) {
+        const patternNodes = node.children.filter(n => n.name !== "and-divider");
+
+        const patterns = patternNodes.map(n => {
+            const patternNode = n.children[0].name === "not" ? n.children[1] : n.children[0];
+            const isNot = n.find(n => n.name === "not") != null;
+            const isOptional = n.find(n => n.name === "is-optional");
+            const pattern = this._buildPattern(patternNode);
+            const finalPattern = isOptional ? new Optional(pattern.name, pattern) : pattern;
+
+            if (isNot) {
+                return new Not(`not-${finalPattern.name}`, finalPattern);
+            }
+
+            return finalPattern;
+        });
+
+        return new Sequence(name, patterns);
+    }
+
+    private _saveRepeat(statementNode: Node) {
+        const nameNode = statementNode.find(n => n.name === "name") as Node;
+        const name = nameNode.value;
+        const repeatNode = statementNode.find(n => n.name === "repeat-literal") as Node;
+        const repeat = this._buildRepeat(name, repeatNode);
+
+        this._parseContext.patternsByName.set(name, repeat);
+    }
+
+    private _buildRepeat(name: string, repeatNode: Node) {
+        let isOptional = false;
+        const bounds = repeatNode.find(n => n.name === "bounds");
+        const exactCount = repeatNode.find(n => n.name === "exact-count");
+        const quantifier = repeatNode.find(n => n.name === "quantifier-shorthand");
+        const trimDivider = repeatNode.find(n => n.name === "trim-flag") != null;
+        const patterNode = repeatNode.children[1].type === "spaces" ? repeatNode.children[2] : repeatNode.children[1];
+        const pattern = this._buildPattern(patterNode);
+        const dividerSectionNode = repeatNode.find(n => n.name === "divider-section");
+
+        const options: RepeatOptions = {
+            min: 1,
+            max: Infinity
+        };
+
+        if (trimDivider) {
+            options.trimDivider = trimDivider;
+        }
+
+        if (dividerSectionNode != null) {
+            const dividerNode = dividerSectionNode.children[1];
+            options.divider = this._buildPattern(dividerNode);
+        }
+
+        if (bounds != null) {
+            const minNode = bounds.find(p => p.name === "min");
+            const maxNode = bounds.find(p => p.name === "max");
+
+            const min = minNode == null ? 0 : Number(minNode.value);
+            const max = maxNode == null ? Infinity : Number(maxNode.value);
+
+            options.min = min;
+            options.max = max;
+        } else if (exactCount != null) {
+            const integerNode = exactCount.find(p => p.name === "integer") as Node;
+            const integer = Number(integerNode.value);
+
+            options.min = integer;
+            options.max = integer;
+        } else if (quantifier != null) {
+            const type = quantifier.value;
+            if (type === "+") {
+                options.min = 1;
+                options.max = Infinity;
+            } else {
+                isOptional = true;
+            }
+        }
+
+        return isOptional ? new Optional(name, new Repeat(name, pattern, options)) : new Repeat(name, pattern, options);
+    }
+
+    private _saveConfigurableAnonymous(node: Node) {
+        const nameNode = node.find(n => n.name === "name") as Node;
+        const name = nameNode.value;
+        const anonymousNode = node.find(n => n.name === "complex-anonymous-pattern") as Node;
+        const isOptional = node.children[1] != null;
+
+        const anonymous = isOptional ? new Optional(name, this._buildPattern(anonymousNode)) : this._buildPattern(anonymousNode);
+        this._parseContext.patternsByName.set(name, anonymous);
+    }
+
+    private _buildComplexAnonymousPattern(node: Node) {
+        const wrappedNode = node.children[1].name === "line-spaces" ? node.children[2] : node.children[1];
+        return this._buildPattern(wrappedNode);
     }
 
     private async _resolveImports(ast: Node) {
@@ -197,7 +410,7 @@ export class Grammar {
                             throw new Error(`'${importName}' was already used within another import.`);
                         }
 
-                        const pattern = patterns.get(importName);
+                        const pattern = patterns[importName];
                         if (pattern == null) {
                             throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
                         }
@@ -213,7 +426,7 @@ export class Grammar {
                             throw new Error(`'${alias}' was already used within another import.`);
                         }
 
-                        const pattern = patterns.get(importName);
+                        const pattern = patterns[importName];
                         if (pattern == null) {
                             throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
                         }
@@ -244,7 +457,7 @@ export class Grammar {
                     ._parseContext
                     .importedPatternsByName
                     .values()
-                )
+                );
 
                 const grammar = new Grammar({
                     params: importedValues,
@@ -253,59 +466,13 @@ export class Grammar {
                 });
 
                 const patterns = grammar.parseString(expression);
-                params = Array.from(patterns.values());
+                params = Array.from(Object.values(patterns));
             }
         }
 
         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;
-        const name = nameNode.value;
-        const value = this._resolveStringValue(literalNode.value.slice(1, -1));
-        const literal = new Literal(name, value);
-
-        this._parseContext.patternsByName.set(name, literal)
-    }
-
-    private _resolveStringValue(value: string) {
-        return value.replace(/\\n/g, '\n')
-            .replace(/\\r/g, '\r')
-            .replace(/\\t/g, '\t')
-            .replace(/\\b/g, '\b')
-            .replace(/\\f/g, '\f')
-            .replace(/\\v/g, '\v')
-            .replace(/\\0/g, '\0')
-            .replace(/\\x([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
-            .replace(/\\u([0-9A-Fa-f]{4})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
-            .replace(/\\(.)/g, '$1');
-    }
-
-    private _buildRegex(statementNode: Node) {
-        const nameNode = statementNode.find(n => n.name === "name") as Node;
-        const regexNode = statementNode.find(n => n.name === "regex-literal") as Node;
-        const value = regexNode.value.slice(1, regexNode.value.length - 1);
-        const name = nameNode.value;
-
-        const regex = new Regex(name, value);
-
-        this._parseContext.patternsByName.set(name, regex);
-    }
-
-    private _buildOr(statementNode: Node) {
-        const nameNode = statementNode.find(n => n.name === "name") as Node;
-        const orNode = statementNode.find(n => n.name === "or-literal") as Node;
-        const patternNodes = orNode.children.filter(n => n.name === "pattern-name");
-
-        const name = nameNode.value;
-        const patterns = patternNodes.map(n => this._getPattern(n.value));
-        const or = new Or(name, patterns, false, true);
-
-        this._parseContext.patternsByName.set(name, or);
-    }
-
     private _getPattern(name: string) {
         let pattern = this._parseContext.patternsByName.get(name);
 
@@ -324,98 +491,14 @@ export class Grammar {
         return pattern;
     }
 
-    private _buildAnd(statementNode: Node) {
-        const nameNode = statementNode.find(n => n.name === "name") as Node;
-        const andNode = statementNode.find(n => n.name === "and-literal") as Node;
-        const patternNodes = andNode.children.filter(n => n.name === "pattern");
-
-        const name = nameNode.value;
-        const patterns = patternNodes.map(n => {
-            const nameNode = n.find(n => n.name === "pattern-name") as Node;
-            const isNot = n.find(n => n.name === "not") != null;
-            const isOptional = n.find(n => n.name === "is-optional") != null;
-            const name = nameNode.value;
-            const pattern = this._getPattern(name);
-
-            if (isNot) {
-                return new Not(`not-${name}`, pattern.clone(name, isOptional));
-            }
-
-            return pattern.clone(name, isOptional);
-        });
-
-        const and = new And(name, patterns);
-
-        this._parseContext.patternsByName.set(name, and);
-    }
-
-    private _buildRepeat(statementNode: Node) {
-        const nameNode = statementNode.find(n => n.name === "name") as Node;
-        const repeatNode = statementNode.find(n => n.name === "repeat-literal") as Node;
-        const patternNameNode = statementNode.find(n => n.name === "pattern-name") as Node;
-        const dividerNode = repeatNode.find(n => n.name === "divider-pattern");
-        const bounds = repeatNode.find(n => n.name === "bounds");
-        const exactCount = repeatNode.find(n => n.name === "exact-count");
-        const quantifier = repeatNode.find(n => n.name === "quantifier-shorthand");
-        const isPatternOptional = repeatNode.find(n => n.name === "is-optional") != null;
-        const trimDivider = repeatNode.find(n => n.name === "trim-divider") != null;
-
-        const name = nameNode.value;
-        const pattern = this._getPattern(patternNameNode.value);
-
-        const options: RepeatOptions = {
-            min: 1,
-            max: Infinity
-        }
-
-        if (trimDivider) {
-            options.trimDivider = trimDivider;
-        }
-
-        if (dividerNode != null) {
-            options.divider = this._getPattern(dividerNode.value);
-        }
-
-        if (bounds != null) {
-            const minNode = bounds.find(p => p.name === "min");
-            const maxNode = bounds.find(p => p.name === "max");
-
-            const min = minNode == null ? 0 : Number(minNode.value);
-            const max = maxNode == null ? Infinity : Number(maxNode.value);
-
-            options.min = min;
-            options.max = max;
-        } else if (exactCount != null) {
-            const integerNode = exactCount.find(p => p.name === "integer") as Node;
-            const integer = Number(integerNode.value);
-
-            options.min = integer;
-            options.max = integer;
-        } else if (quantifier != null) {
-            const type = quantifier.value;
-            if (type === "+") {
-                options.min = 1;
-                options.max = Infinity;
-            } else {
-                options.min = 0;
-                options.max = Infinity;
-            }
-        }
-
-        const repeat = new Repeat(name, pattern.clone(pattern.name, isPatternOptional), options);
-
-        this._parseContext.patternsByName.set(name, repeat);
-    }
-
-    private _buildAlias(statementNode: Node) {
+    private _saveAlias(statementNode: Node) {
         const nameNode = statementNode.find(n => n.name === "name") as Node;
         const aliasNode = statementNode.find(n => n.name === "alias-literal") as Node;
         const aliasName = aliasNode.value;
         const name = nameNode.value;
-        const pattern = this._getPattern(aliasName);
-        const alias = pattern.clone(name);
+        const alias = this._getPattern(aliasName).clone(name);
 
-        this._parseContext.patternsByName.set(name, alias)
+        this._parseContext.patternsByName.set(name, alias);
     }
 
     static parse(expression: string, options?: GrammarOptions) {

package/src/grammar/patterns/anonymousPattern.ts

@@ -0,0 +1,23 @@
+import { Literal } from "../../patterns/Literal";
+import { Sequence } from "../../patterns/Sequence";
+import { lineSpaces } from "./spaces";
+import { anonymousLiterals, anonymousWrappedLiterals } from './literals';
+import { Options } from "../../patterns/Options";
+import { Optional } from "../../patterns/Optional";
+
+const inlinePatternOpenParen = new Literal("anonymous-pattern-open-paren", "(");
+const inlinePatternCloseParen = new Literal("anonymous-pattern-close-paren", ")");
+const optionalLineSpaces = new Optional("optional-line-spaces", lineSpaces);
+
+const complexAnonymousPattern = new Sequence("complex-anonymous-pattern", [
+    inlinePatternOpenParen,
+    optionalLineSpaces,
+    anonymousWrappedLiterals,
+    optionalLineSpaces,
+    inlinePatternCloseParen,
+]);
+
+export const anonymousPattern = new Options("anonymous-pattern", [
+    anonymousLiterals,
+    complexAnonymousPattern
+]);

package/src/grammar/patterns/body.ts

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

package/src/grammar/patterns/comment.ts

@@ -1,3 +1,4 @@
-import { Regex } from "../../patterns/Regex"
+import { Regex } from "../../patterns/Regex";
 
-export const comment = new Regex("comment", "#[^\r\n]+");
+export const comment = new Regex("comment", "#[^\r\n]+");
+comment.setTokens(["# "]);

package/src/grammar/patterns/grammar.ts

@@ -1,11 +1,12 @@
-import { Or } from "../../patterns/Or";
+import { Options } from "../../patterns/Options";
 import { Regex } from "../../patterns/Regex";
 import { Repeat } from "../../patterns/Repeat";
 import { comment } from "./comment";
 import { importStatement } from './import';
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { allSpaces } from "./spaces";
 import { body } from "./body";
+import { Optional } from "../../patterns/Optional";
 
 const tabs = new Regex("tabs", "\\t+");
 const spaces = new Regex("spaces", "[ ]+");
@@ -15,25 +16,27 @@ spaces.setTokens([" "]);
 tabs.setTokens(["\t"]);
 newLine.setTokens(["\n"]);
 
-const lineSpaces = new Repeat("line-spaces", new Or("line-space", [tabs, spaces]));
+const lineSpaces = new Repeat("line-spaces", new Options("line-space", [tabs, spaces]));
+const optionalLineSpaces = new Optional("optional-line-spaces", lineSpaces);
 
-const headLineContent = new Or("head-line-content", [
+const headLineContent = new Options("head-line-content", [
     comment,
     importStatement
 ]);
 
-const headLine = new And("head-line-content", [
-    lineSpaces.clone("line-spaces", true),
+const headLine = new Sequence("head-line-content", [
+    optionalLineSpaces,
     headLineContent,
-    lineSpaces.clone("line-spaces", true),
+    optionalLineSpaces,
 ]);
 
-const head = new Repeat("head", headLine, { divider: newLine, min: 0 });
+const head = new Optional("optional-head", new Repeat("head", headLine, { divider: newLine }));
+const optionalSpaces = new Optional("optional-spaces", allSpaces);
 
-export const grammar = new And("grammar", [
-    allSpaces,
+export const grammar = new Sequence("grammar", [
+    optionalSpaces,
     head,
-    allSpaces,
+    optionalSpaces,
     body,
-    allSpaces
+    optionalSpaces
 ]);