clarity-pattern-parser 10.1.0 → 10.1.2

package/dist/patterns/Context.d.ts

@@ -0,0 +1,31 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
+import { Pattern } from "./Pattern";
+export declare class Context implements Pattern {
+    private _id;
+    private _type;
+    private _name;
+    private _parent;
+    private _children;
+    private _pattern;
+    get id(): string;
+    get type(): string;
+    get name(): string;
+    get parent(): Pattern | null;
+    set parent(pattern: Pattern | null);
+    get children(): Pattern[];
+    constructor(name: string, pattern: Pattern, context?: Pattern[]);
+    parse(cursor: Cursor): Node | null;
+    exec(text: string, record?: boolean | undefined): ParseResult;
+    test(text: string, record?: boolean | undefined): boolean;
+    clone(name?: string): Pattern;
+    getTokens(): string[];
+    getTokensAfter(childReference: Pattern): string[];
+    getNextTokens(): string[];
+    getPatterns(): Pattern[];
+    getPatternsAfter(childReference: Pattern): Pattern[];
+    getNextPatterns(): Pattern[];
+    find(predicate: (pattern: Pattern) => boolean): Pattern | null;
+    isEqual(pattern: Pattern): boolean;
+}

package/package.json

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

package/src/grammar/Grammar.test.ts

@@ -8,6 +8,7 @@ import { Regex } from "../patterns/Regex";
 import { Repeat } from "../patterns/Repeat";
 import { Grammar } from "./Grammar";
 import { Optional } from "../patterns/Optional";
+import { Context } from "../patterns/Context";
 
 describe("Grammar", () => {
     test("Literal", () => {
@@ -17,7 +18,8 @@ describe("Grammar", () => {
 
         const patterns = Grammar.parseString(expression);
         const namePattern = patterns["name"];
-        const expected = new Literal("name", "John");
+        const name = new Literal("name", "John");
+        const expected = new Context("name", name);
 
         expect(namePattern.isEqual(expected)).toBeTruthy();
     });
@@ -28,7 +30,8 @@ describe("Grammar", () => {
         `;
         const patterns = Grammar.parseString(expression);
         const namePattern = patterns["chars"];
-        const expected = new Literal("chars", "\n\r\t\b\f\v\0\x00\u0000\"\\");
+        const chars = new Literal("chars", "\n\r\t\b\f\v\0\x00\u0000\"\\");
+        const expected = new Context('chars', chars);
 
         expect(namePattern.isEqual(expected)).toBeTruthy();
     });
@@ -39,7 +42,8 @@ describe("Grammar", () => {
         `;
         const patterns = Grammar.parseString(expression);
         const namePattern = patterns["content"];
-        const expected = new Literal("content", "With Con\"tent");
+        const content = new Literal("content", "With Con\"tent");
+        const expected = new Context(`content`, content);
 
         expect(namePattern.isEqual(expected)).toBeTruthy();
     });
@@ -52,8 +56,9 @@ describe("Grammar", () => {
         const patterns = Grammar.parseString(expression);
         const pattern = patterns["name"];
         const name = new Regex("name", "\\w");
+        const expected = new Context(`name`, name);
 
-        expect(pattern.isEqual(name)).toBeTruthy();
+        expect(pattern.isEqual(expected)).toBeTruthy();
     });
 
     test("Or", () => {
@@ -68,8 +73,9 @@ describe("Grammar", () => {
         const john = new Literal("john", "John");
         const jane = new Literal("jane", "Jane");
         const names = new Options("names", [john, jane], true);
+        const expected = new Context("names", names, [john, jane]);
 
-        expect(pattern.isEqual(names)).toBeTruthy();
+        expect(pattern.isEqual(expected)).toBeTruthy();
     });
 
     test("And", () => {
@@ -86,8 +92,9 @@ describe("Grammar", () => {
         const firstName = new Regex("first-name", "\\w");
         const lastName = new Regex("last-name", "\\w");
         const fullName = new Sequence("full-name", [firstName, space, lastName]);
+        const expected = new Context("full-name", fullName, [space, firstName, lastName]);
 
-        expect(pattern.isEqual(fullName)).toBeTruthy();
+        expect(pattern.isEqual(expected)).toBeTruthy();
     });
 
     test("And With Optional Pattern", () => {
@@ -106,10 +113,12 @@ describe("Grammar", () => {
         const firstName = new Regex("first-name", "\\w");
         const lastName = new Regex("last-name", "\\w");
         const middleName = new Regex("middle-name", "\\w");
-        const middleNameWithSpace = new Optional("optional-middle-name-with-space", new Sequence("middle-name-with-space", [middleName, space]));
-        const fullName = new Sequence("full-name", [firstName, space, middleNameWithSpace, lastName]);
+        const middleNameWithSpace = new Sequence("middle-name-with-space", [middleName, space]);
+        const optionalMiddleNameWithSpace = new Optional("optional-middle-name-with-space", middleNameWithSpace);
+        const fullName = new Sequence("full-name", [firstName, space, optionalMiddleNameWithSpace, lastName]);
+        const expected = new Context("full-name", fullName, [space, firstName, lastName, middleName, middleNameWithSpace]);
 
-        expect(pattern.isEqual(fullName)).toBeTruthy();
+        expect(pattern.isEqual(expected)).toBeTruthy();
     });
 
     test("And With Not Pattern", () => {
@@ -130,11 +139,12 @@ describe("Grammar", () => {
         const lastName = new Regex("last-name", "\\w");
         const middleName = new Regex("middle-name", "\\w");
         const jack = new Literal("jack", "Jack");
-        const notJack = new Not("not-jack", jack);
-        const middleNameWithSpace = new Optional("optional-middle-name-with-space", new Sequence("middle-name-with-space", [middleName, space]));
-        const fullName = new Sequence("full-name", [notJack, firstName, space, middleNameWithSpace, lastName]);
+        const middleNameWithSpace = new Sequence("middle-name-with-space", [middleName, space]);
+        const optionalMiddleNameWithSpace = new Optional("optional-middle-name-with-space", middleNameWithSpace);
+        const fullName = new Sequence("full-name", [new Not("not-jack", jack), firstName, space, optionalMiddleNameWithSpace, lastName]);
+        const expected = new Context("full-name", fullName, [space, firstName, lastName, middleName, jack, middleNameWithSpace]);
 
-        expect(pattern.isEqual(fullName)).toBeTruthy();
+        expect(pattern.isEqual(expected)).toBeTruthy();
     });
 
     test("Repeat", () => {
@@ -147,8 +157,9 @@ describe("Grammar", () => {
         const pattern = patterns["digits"];
         const digit = new Regex("digit", "\\d");
         const digits = new Repeat("digits", digit);
+        const expected = new Context("digits", digits, [digit]);
 
-        expect(pattern.isEqual(digits)).toBeTruthy();
+        expect(pattern.isEqual(expected)).toBeTruthy();
     });
 
     test("Repeat Zero Or More", () => {
@@ -162,7 +173,9 @@ describe("Grammar", () => {
         const digit = new Regex("digit", "\\d");
         const digits = new Optional("digits", new Repeat("digits", digit, { min: 0 }));
 
-        expect(pattern.isEqual(digits)).toBeTruthy();
+        const expected = new Context("digits", digits, [digit]);
+
+        expect(pattern.isEqual(expected)).toBeTruthy();
     });
 
     test("Repeat Lower Limit", () => {
@@ -175,8 +188,9 @@ describe("Grammar", () => {
         const pattern = patterns["digits"];
         const digit = new Regex("digit", "\\d+");
         const digits = new Repeat("digits", digit, { min: 1 });
+        const expected = new Context("digits", digits, [digit]);
 
-        expect(pattern.isEqual(digits)).toBeTruthy();
+        expect(pattern.isEqual(expected)).toBeTruthy();
     });
 
     test("Repeat Bounded", () => {
@@ -189,8 +203,9 @@ describe("Grammar", () => {
         const pattern = patterns["digits"];
         const digit = new Regex("digit", "\\d+");
         const digits = new Repeat("digits", digit, { min: 1, max: 3 });
+        const expected = new Context("digits", digits, [digit]);
 
-        expect(pattern.isEqual(digits)).toBeTruthy();
+        expect(pattern.isEqual(expected)).toBeTruthy();
     });
 
     test("Repeat Upper Limit", () => {
@@ -203,8 +218,9 @@ describe("Grammar", () => {
         const pattern = patterns["digits"];
         const digit = new Regex("digit", "\\d+");
         const digits = new Repeat("digits", digit, { min: 0, max: 3 });
+        const expected = new Context("digits", digits, [digit]);
 
-        expect(pattern.isEqual(digits)).toBeTruthy();
+        expect(pattern.isEqual(expected)).toBeTruthy();
     });
 
     test("Repeat Exact", () => {
@@ -217,8 +233,9 @@ describe("Grammar", () => {
         const pattern = patterns["digits"];
         const digit = new Regex("digit", "\\d+");
         const digits = new Repeat("digits", digit, { min: 3, max: 3 });
+        const expected = new Context("digits", digits, [digit]);
 
-        expect(pattern.isEqual(digits)).toBeTruthy();
+        expect(pattern.isEqual(expected)).toBeTruthy();
     });
 
     test("Repeat Divider", () => {
@@ -231,10 +248,11 @@ describe("Grammar", () => {
         const patterns = Grammar.parseString(expression);
         const pattern = patterns["digits"];
         const digit = new Regex("digit", "\\d+");
-        const divider = new Literal("comma", ",");
-        const digits = new Repeat("digits", digit, { divider, min: 3, max: 3 });
+        const comma = new Literal("comma", ",");
+        const digits = new Repeat("digits", digit, { divider: comma, min: 3, max: 3 });
+        const expected = new Context("digits", digits, [digit, comma]);
 
-        expect(pattern.isEqual(digits)).toBeTruthy();
+        expect(pattern.isEqual(expected)).toBeTruthy();
     });
 
     test("Repeat Divider With Trim Divider", () => {
@@ -247,10 +265,11 @@ describe("Grammar", () => {
         const patterns = Grammar.parseString(expression);
         const pattern = patterns["digits"];
         const digit = new Regex("digit", "\\d+");
-        const divider = new Literal("comma", ",");
-        const digits = new Repeat("digits", digit, { divider, min: 1, trimDivider: true });
+        const comma = new Literal("comma", ",");
+        const digits = new Repeat("digits", digit, { divider: comma, min: 1, trimDivider: true });
+        const expected = new Context("digits", digits, [digit, comma]);
 
-        expect(pattern.isEqual(digits)).toBeTruthy();
+        expect(pattern.isEqual(expected)).toBeTruthy();
     });
 
     test("Repeat Divider With Trim Divider And Bounds", () => {
@@ -265,8 +284,9 @@ describe("Grammar", () => {
         const digit = new Regex("digit", "\\d+");
         const divider = new Literal("comma", ",");
         const digits = new Repeat("digits", digit, { divider, min: 3, max: 3, trimDivider: true });
+        const expected = new Context("digits", digits, [digit, divider]);
 
-        expect(pattern.isEqual(digits)).toBeTruthy();
+        expect(pattern.isEqual(expected)).toBeTruthy();
     });
 
     test("Reference", () => {
@@ -302,10 +322,14 @@ describe("Grammar", () => {
         const expectedName = new Regex("name", "regex");
 
         const alias = patterns["alias"];
+
         const expectedAlias = new Regex("alias", "regex");
 
-        expect(name.isEqual(expectedName)).toBeTruthy();
-        expect(alias.isEqual(expectedAlias)).toBeTruthy();
+        const contextualAlias = new Context("alias", expectedAlias, [expectedName]);
+        const contextualName = new Context("name", expectedName, [expectedAlias]);
+
+        expect(name.isEqual(contextualName)).toBeTruthy();
+        expect(alias.isEqual(contextualAlias)).toBeTruthy();
     });
 
     test("Bad Grammar At Beginning", () => {
@@ -481,7 +505,7 @@ describe("Grammar", () => {
         `;
 
         const patterns = Grammar.parseString(expression);
-        const expected = new Sequence("complex-expression", [
+        const expected = new Context("complex-expression", new Sequence("complex-expression", [
             new Not("not-NOT_THIS", new Literal("NOT_THIS", "NOT_THIS")),
             new Optional("Text", new Literal("Text", "Text")),
             new Regex("regex", "regex"),
@@ -496,7 +520,7 @@ describe("Grammar", () => {
                 new Reference("pattern"),
                 new Reference("pattern")
             ])
-        ]);
+        ]));
 
         expect(patterns["complex-expression"].isEqual(expected)).toBeTruthy();
     });

package/src/grammar/Grammar.ts

@@ -10,6 +10,7 @@ import { Sequence } from "../patterns/Sequence";
 import { Repeat, RepeatOptions } from "../patterns/Repeat";
 import { AutoComplete } from "../intellisense/AutoComplete";
 import { Optional } from "../patterns/Optional";
+import { Context } from "../patterns/Context";
 
 let anonymousIndexId = 0;
 
@@ -88,7 +89,18 @@ export class Grammar {
         await this._resolveImports(ast);
         this._buildPatterns(ast);
 
-        return Object.fromEntries(this._parseContext.patternsByName) as Record<string, Pattern>;
+        return this._buildPatternRecord();
+    }
+
+    private _buildPatternRecord() {
+        const patterns: Record<string, Pattern> = {};
+        const allPatterns = Array.from(this._parseContext.patternsByName.values());
+
+        allPatterns.forEach(p => {
+            patterns[p.name] = new Context(p.name, p, allPatterns.filter(o => o !== p));
+        });
+
+        return patterns;
     }
 
     parseString(expression: string) {
@@ -98,8 +110,10 @@ export class Grammar {
         if (this._hasImports(ast)) {
             throw new Error("Cannot use imports on parseString, use parse instead.");
         }
+
         this._buildPatterns(ast);
-        return Object.fromEntries(this._parseContext.patternsByName) as Record<string, Pattern>;
+
+        return this._buildPatternRecord();
     }
 
     private _tryToParse(expression: string): Node {

package/src/index.ts

@@ -18,6 +18,7 @@ import { CursorHistory, Match } from "./patterns/CursorHistory";
 import { ParseResult } from "./patterns/ParseResult";
 import { grammar } from "./grammar/patterns/grammar";
 import { patterns } from "./grammar/patterns";
+import { Context } from "./patterns/Context";
 
 export {
   Node,
@@ -30,6 +31,7 @@ export {
   Cursor,
   CursorHistory,
   Match,
+  Context,
   Literal,
   Not,
   Options,

package/src/patterns/Context.test.ts

@@ -0,0 +1,35 @@
+import { patterns } from "../grammar/patterns";
+import { Context } from "./Context";
+import { Literal } from "./Literal";
+import { Reference } from "./Reference";
+import { Sequence } from "./Sequence";
+
+describe("Context", () => {
+    test("Basic", () => {
+        const john = new Literal("john", "John");
+        const space = new Literal("space", " ");
+        const jane = new Literal("jane", "Jane");
+        const spaceReference = new Reference("space");
+
+        const names = new Sequence("names", [john, spaceReference, jane]);
+        const context = new Context("context", names, [space, names]);
+
+        const { ast } = context.exec("John Jane");
+
+        expect(ast?.toString()).toBe("John Jane");
+    });
+
+    test("With Grammar", ()=>{
+        const {names} = patterns`
+            names = john + space + jane
+            john = "John"
+            jane = "Jane"
+            space = " "
+        `;
+
+        const { ast } = names.exec("John Jane");
+
+        expect(ast?.toString()).toBe("John Jane");
+    });
+
+});

package/src/patterns/Context.ts

@@ -0,0 +1,105 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
+import { Pattern } from "./Pattern";
+
+let contextId = 0;
+
+export class Context implements Pattern {
+    private _id: string;
+    private _type: string;
+    private _name: string;
+    private _parent: Pattern | null;
+    private _children: Pattern[];
+    private _pattern: Pattern;
+
+    get id(): string {
+        return this._id;
+    }
+
+    get type(): string {
+        return this._type;
+    }
+
+    get name(): string {
+        return this._name;
+    }
+
+    get parent(): Pattern | null {
+        return this._parent;
+    }
+
+    set parent(pattern: Pattern | null) {
+        this._parent = pattern;
+    }
+
+    get children(): Pattern[] {
+        return this._children;
+    }
+
+    constructor(name: string, pattern: Pattern, context: Pattern[] = []) {
+        this._id = `context-${contextId++}`;
+        this._type = "context";
+        this._name = name;
+        this._parent = null;
+
+        const clonedContext = context.map(p => p.clone());
+        const clonedPattern = pattern.clone();
+
+        clonedContext.forEach(p => p.parent = this);
+        clonedPattern.parent = this;
+
+        this._pattern = clonedPattern;
+        this._children = [...clonedContext, clonedPattern];
+    }
+
+    parse(cursor: Cursor): Node | null {
+        return this._pattern.parse(cursor);
+    }
+
+    exec(text: string, record?: boolean | undefined): ParseResult {
+        return this._pattern.exec(text, record);
+    }
+
+    test(text: string, record?: boolean | undefined): boolean {
+        return this._pattern.test(text, record);
+    }
+
+    clone(name = this._name): Pattern {
+        const clone = new Context(name, this._pattern, this._children.slice(0, -1));
+        return clone;
+    }
+
+    getTokens(): string[] {
+        return this._pattern.getTokens();
+    }
+
+    getTokensAfter(childReference: Pattern): string[] {
+        return this._pattern.getTokensAfter(childReference);
+    }
+
+    getNextTokens(): string[] {
+        return this._pattern.getNextTokens();
+    }
+
+    getPatterns(): Pattern[] {
+        return this._pattern.getPatterns();
+    }
+
+    getPatternsAfter(childReference: Pattern): Pattern[] {
+        return this._pattern.getPatternsAfter(childReference);
+    }
+
+    getNextPatterns(): Pattern[] {
+        return this._pattern.getNextPatterns();
+    }
+
+    find(predicate: (pattern: Pattern) => boolean): Pattern | null {
+        return this._pattern.find(predicate);
+    }
+
+    isEqual(pattern: Pattern): boolean {
+        return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+    }
+
+}

package/src/patterns/Reference.ts

@@ -97,10 +97,28 @@ export class Reference implements Pattern {
   }
 
   private _findPattern(): Pattern | null {
-    const root = this._getRoot();
+    let pattern = this._parent;
+
+    while (pattern != null) {
+      if (pattern.type !== "context") {
+        pattern = pattern.parent;
+        continue;
+      }
 
+      const foundPattern = findPattern(pattern, (pattern: Pattern) => {
+        return pattern.name === this._name && pattern.type !== "reference" && pattern.type !== "context";
+      });
+
+      if (foundPattern != null) {
+        return foundPattern;
+      }
+
+      pattern = pattern.parent;
+    }
+
+    const root = this._getRoot();
     return findPattern(root, (pattern: Pattern) => {
-      return pattern.name === this._name && pattern.type !== "reference";
+      return pattern.name === this._name && pattern.type !== "reference" && pattern.type !== "context";
     });
   }