clarity-pattern-parser 10.1.20 → 10.1.21

package/package.json

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

package/src/intellisense/AutoComplete.test.ts

@@ -490,4 +490,89 @@ describe("AutoComplete", () => {
         expect(results.options).toEqual(expected);
     });
 
+    test("Multiple Complex Branches", () => {
+        const branchOne = new Sequence("branch-1", [
+            new Literal("space-1-1", " "),
+            new Literal("space-1-2", " "),
+            new Options('branch-1-options', [
+                new Literal("AA", "AA"),
+                new Literal("AB", "AB"),
+                new Literal("BC", "BC"),
+            ])
+        ]);
+        const branchTwo = new Sequence("branch-2", [
+            new Literal("space-2-1", " "),
+            new Literal("space-2-2", " "),
+            new Options('branch-2-options', [
+                new Literal("BA", "BA"),
+                new Literal("BB", "BB")
+            ])
+        ]);
+        const eitherBranch = new Options("either-branch", [branchOne, branchTwo]);
+
+        const autoComplete = new AutoComplete(eitherBranch);
+        const results = autoComplete.suggestFor("  B");
+        const expected = [
+            { startIndex: 3, text: "A" },
+            { startIndex: 3, text: "B" },
+            { startIndex: 3, text: "C" },
+        ];
+        expect(results.options).toEqual(expected);
+    });
+
+
+    test("Recursion With Or", () => {
+        const ref = new Reference("names");
+        const names = new Options("names", [
+            ref,
+            new Literal("john", "John"),
+            new Literal("jane", "Jane")
+        ]);
+
+        const autoComplete = new AutoComplete(names);
+        const suggestion = autoComplete.suggestFor("Jo");
+
+        expect(suggestion.options).toEqual([
+            { text: 'hn', startIndex: 2 }
+        ]);
+        expect(suggestion.error?.endIndex).toBe(2);
+    });
+
+    test("Recursion With And", () => {
+        const firstNames = new Options("first-names", [
+            new Literal("john", "John"),
+            new Literal("jane", "Jane"),
+        ]);
+
+        const lastNames = new Options("last-names", [
+            new Literal("doe", "Doe"),
+            new Literal("smith", "Smith"),
+        ]);
+
+        const fullName = new Sequence("full-name", [
+            firstNames,
+            new Literal("space", " "),
+            lastNames
+        ]);
+
+        const ref = new Reference("names");
+        const names = new Sequence("names", [
+            fullName,
+            ref,
+            lastNames,
+        ]);
+
+        const autoComplete = new AutoComplete(names, {
+            greedyPatternNames: ["space"]
+        });
+        const suggestion = autoComplete.suggestFor("John");
+
+        expect(suggestion.options).toEqual([{
+            "text": " Doe",
+            "startIndex": 4
+        }, {
+            "text": " Smith",
+            "startIndex": 4
+        }]);
+    });
 });

package/src/patterns/ExpressionPattern.ts

@@ -12,6 +12,9 @@ export class ExpressionPattern implements Pattern {
     private _parent: Pattern | null;
     private _token: string;
     private _firstIndex: number;
+    private _patterns: Pattern[];
+    private _unaryPatterns: Pattern[];
+    private _binaryPatterns: Pattern[];
 
     get id(): string {
         return this._id;
@@ -41,10 +44,42 @@ export class ExpressionPattern implements Pattern {
         return [];
     }
 
-    constructor(){
+    constructor(name: string, patterns: []) {
         this._id = `expression-${indexId++}`;
         this._type = "expression";
+        this._unaryPatterns = [];
+        this._binaryPatterns = [];
+    }
+
+    private _organizePatterns() {
+        this._patterns.forEach((pattern) => {
+            if (this._isBinary(pattern)) {
+                this._binaryPatterns.push(pattern);
+            } else {
+                this._unaryPatterns.push();
+            }
+        });
+    }
+
+    private _isBinary(pattern: Pattern) {
+        if (pattern.type === "right-associated" && this._isBinaryPattern(pattern.children[0])) {
+            return true;
+        }
+
+        return this._isBinaryPattern(pattern);
+    }
+
+    private _isBinaryPattern(pattern: Pattern) {
+        return pattern.type === "sequence" &&
+            pattern.children[0].type === "reference" &&
+            pattern.children[0].name === this.name &&
+            pattern.children[2].type === "reference" &&
+            pattern.children[2].name === this.name &&
+            pattern.children.length === 3;
+    }
 
+    private extractDelimiter(pattern) {
+        return pattern.children[1];
     }
 
     parse(cursor: Cursor): Node | null {

package/src/patterns/Options.ts

@@ -142,8 +142,11 @@ export class Options implements Pattern {
   getTokens(): string[] {
     const tokens: string[] = [];
 
-    for (const child of this._children) {
-      tokens.push(...child.getTokens());
+    for (const pattern of this._children) {
+      if (pattern.type === "reference" && pattern.name === this.name) {
+        continue;
+      }
+      tokens.push(...pattern.getTokens());
     }
 
     return tokens;
@@ -169,6 +172,9 @@ export class Options implements Pattern {
     const patterns: Pattern[] = [];
 
     for (const pattern of this._children) {
+      if (pattern.type === "reference" && pattern.name === this.name) {
+        continue;
+      }
       patterns.push(...pattern.getPatterns());
     }
 

package/src/patterns/RightAssociatedPattern.ts

@@ -0,0 +1,71 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
+import { Pattern } from "./Pattern";
+
+let indexId = 0;
+
+export class RightAssociatedPattern implements Pattern {
+    readonly id: string;
+    readonly type: string;
+    readonly name: string;
+    private _parent: Pattern | null;
+    readonly children: Pattern[];
+
+    get parent() {
+        return this._parent;
+    }
+
+    set parent(pattern: Pattern | null) {
+        this._parent = pattern;
+    }
+
+    constructor(pattern: Pattern) {
+        this.id = `right-associated-${indexId++}`;
+        this.type = "right-associated";
+        this.name = "";
+        this.parent = null;
+        this.children = [pattern];
+    }
+
+    parse(cursor: Cursor): Node | null {
+        return this.children[0].parse(cursor);
+    }
+
+    exec(text: string, record?: boolean | undefined): ParseResult {
+        return this.children[0].exec(text, record);
+    }
+
+    test(text: string, record?: boolean | undefined): boolean {
+        return this.children[0].test(text, record);
+    }
+
+    clone(name?: string | undefined): Pattern {
+        return new RightAssociatedPattern(this.children[0]);
+    }
+
+    getTokens(): string[] {
+        return this.children[0].getTokens();
+    }
+    getTokensAfter(childReference: Pattern): string[] {
+        return this.children[0].getTokensAfter(childReference);
+    }
+    getNextTokens(): string[] {
+        return this.children[0].getNextTokens();
+    }
+    getPatterns(): Pattern[] {
+        return this.children[0].getPatterns();
+    }
+    getPatternsAfter(childReference: Pattern): Pattern[] {
+        return this.children[0].getPatternsAfter(childReference);
+    }
+    getNextPatterns(): Pattern[] {
+        return this.children[0].getNextPatterns();
+    }
+    find(predicate: (pattern: Pattern) => boolean): Pattern | null {
+        return this.children[0].find(predicate);
+    }
+    isEqual(pattern: Pattern): boolean {
+        return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+    }
+}

package/src/patterns/Sequence.ts

@@ -216,10 +216,13 @@ export class Sequence implements Pattern {
   getTokens(): string[] {
     const tokens: string[] = [];
 
-    for (const child of this._children) {
-      tokens.push(...child.getTokens());
+    for (const pattern of this._children) {
+      if (pattern.type === "reference" && pattern.name === this.name && pattern === this.children[0]) {
+        return tokens;
+      }
 
-      if (child.type !== "optional" && child.type !== "not") {
+      tokens.push(...pattern.getTokens());
+      if (pattern.type !== "optional" && pattern.type !== "not") {
         break;
       }
     }
@@ -247,10 +250,15 @@ export class Sequence implements Pattern {
   getPatterns(): Pattern[] {
     const patterns: Pattern[] = [];
 
-    for (const child of this._children) {
-      patterns.push(...child.getPatterns());
+    for (const pattern of this._children) {
+
+      if (pattern.type === "reference" && pattern.name === this.name && pattern === this.children[0]) {
+        return patterns;
+      }
+
+      patterns.push(...pattern.getPatterns());
 
-      if (child.type !== "optional" && child.type !== "not") {
+      if (pattern.type !== "optional" && pattern.type !== "not") {
         break;
       }
     }