clarity-pattern-parser 10.1.14 → 10.1.16

package/dist/patterns/Options.d.ts

@@ -10,6 +10,7 @@ export declare class Options implements Pattern {
     private _children;
     private _isGreedy;
     private _firstIndex;
+    private _recursiveDepth;
     get id(): string;
     get type(): string;
     get name(): string;
@@ -17,11 +18,13 @@ export declare class Options implements Pattern {
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
     constructor(name: string, options: Pattern[], isGreedy?: boolean);
+    private _calculateRecursiveDepth;
     private _assignChildrenToParent;
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
     private _tryToParse;
+    private _isBeyondRecursiveDepth;
     getTokens(): string[];
     getTokensAfter(_childReference: Pattern): string[];
     getNextTokens(): string[];

package/dist/patterns/Sequence.d.ts

@@ -24,6 +24,7 @@ export declare class Sequence implements Pattern {
     };
     parse(cursor: Cursor): Node | null;
     private tryToParse;
+    private _isBeyondRecursiveDepth;
     private getLastValidNode;
     private areRemainingPatternsOptional;
     private createNode;

package/package.json

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

package/src/grammar/ComplexGrammar.test.ts

@@ -0,0 +1,16 @@
+import { patterns } from "./patterns";
+
+describe("Complex Grammar Tests", () => {
+    test("Nested", () => {
+        const { expression } = patterns`
+                integer = /[0-9]+/
+                variable = /[A-Za-z][A-Za-z0-9]*/
+                space = /\\s+/
+                or-expression = expression + space? + "||" + space? + expression
+                mult-expression = expression + space? + "*" + space? + expression 
+                expression = or-expression | mult-expression | integer | variable
+            `;
+        const result = expression.exec("a * b || d * e");
+        expect(result.ast?.toString()).toBe("a * b || d * e");
+    });
+});

package/src/grammar/Grammar.test.ts

@@ -9,6 +9,7 @@ import { Repeat } from "../patterns/Repeat";
 import { Grammar } from "./Grammar";
 import { Optional } from "../patterns/Optional";
 import { Context } from "../patterns/Context";
+import { patterns } from "..";
 
 describe("Grammar", () => {
     test("Literal", () => {
@@ -569,4 +570,6 @@ describe("Grammar", () => {
         const result = fullname.exec("John  Doe");
         expect(result?.ast?.value).toBe("John  Doe");
     });
+
+
 });

package/src/intellisense/AutoComplete.test.ts

@@ -490,4 +490,31 @@ describe("AutoComplete", () => {
         expect(results.options).toEqual(expected);
     });
 
-});
+    test("Furthest Error", () => {
+        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"),
+          ])
+        ]);
+        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" },
+        ];
+        expect(results.options).toEqual(expected);
+    })
+});

package/src/intellisense/AutoComplete.ts

@@ -76,9 +76,10 @@ export class AutoComplete {
       errorAtIndex = this._cursor.furthestError.endIndex;
       error = this._cursor.furthestError;
 
-      errorAtIndex = options.reduce((errorAtIndex, option) =>
-        Math.max(errorAtIndex, option.startIndex),
-        errorAtIndex);
+      errorAtIndex = options.reduce(
+        (errorAtIndex, option) => Math.max(errorAtIndex, option.startIndex),
+        errorAtIndex
+      );
     }
 
     return {
@@ -98,17 +99,19 @@ export class AutoComplete {
 
   private _getAllOptions() {
     const errorMatches = this._getOptionsFromErrors();
-    const leafMatches = this._cursor.leafMatches.map((m) => this._createSuggestionsFromMatch(m)).flat();
-    const finalResults: SuggestionOption[] = [];
+    const validLeafMatches = this._cursor.leafMatches.filter(v => v.node?.lastIndex === this._cursor.getLastIndex())
 
-    [...leafMatches, ...errorMatches].forEach(m=>{
-      const index = finalResults.findIndex(f=> m.text === f.text);
+    const leafMatchSuggestions = validLeafMatches.map((m) => this._createSuggestionsFromMatch(m)).flat();
+    const uniqueResults: SuggestionOption[] = [];
+
+    [...leafMatchSuggestions, ...errorMatches].forEach(m=>{
+      const index = uniqueResults.findIndex(f => m.text === f.text);
       if (index === -1){
-        finalResults.push(m);
+        uniqueResults.push(m);
       }
     });
 
-    return finalResults;
+    return uniqueResults;
   }
 
   private _getOptionsFromErrors() {
@@ -118,9 +121,9 @@ export class AutoComplete {
       const tokens = this._getTokensForPattern(e.pattern);
       const adjustedTokens = tokens.map(t => t.slice(e.endIndex - e.startIndex));
       return this._createSuggestions(e.endIndex, adjustedTokens);
-    });
+    }).flat();
 
-    return suggestions.flat();
+    return suggestions;
   }
 
   private _createSuggestionsFromRoot(): SuggestionOption[] {

package/src/patterns/Options.ts

@@ -4,13 +4,11 @@ import { Pattern } from "./Pattern";
 import { clonePatterns } from "./clonePatterns";
 import { findPattern } from "./findPattern";
 import { ParseResult } from "./ParseResult";
-import { DepthCache } from './DepthCache';
+import { Context } from "./Context";
 
 /*
   The following is created to reduce the overhead of recursion check. 
 */
-
-const depthCache = new DepthCache();
 let idIndex = 0;
 
 export class Options implements Pattern {
@@ -21,6 +19,7 @@ export class Options implements Pattern {
   private _children: Pattern[];
   private _isGreedy: boolean;
   private _firstIndex: number;
+  private _recursiveDepth: number;
 
   get id(): string {
     return this._id;
@@ -61,6 +60,42 @@ export class Options implements Pattern {
     this._children = children;
     this._firstIndex = 0;
     this._isGreedy = isGreedy;
+    this._recursiveDepth = this._calculateRecursiveDepth();
+  }
+
+  private _calculateRecursiveDepth() {
+    let depth = 0;
+
+    this._children.forEach((child) => {
+      let hasReference = false;
+      let descendant = child.children[0];
+
+      while (descendant != null) {
+        if (descendant.type === "reference" && descendant.name === this.name) {
+          hasReference = true;
+          break;
+        }
+
+        if (descendant.type === "context") {
+          const pattern = (descendant as Context).getPatternWithinContext(this.name);
+          if (pattern != null) {
+            break;
+          }
+        }
+
+        descendant = descendant.children[0];
+      }
+
+      if (hasReference) {
+        depth++;
+      }
+    });
+
+    if (depth === 0) {
+      depth = this.children.length;
+    }
+
+    return depth;
   }
 
   private _assignChildrenToParent(children: Pattern[]): void {
@@ -90,13 +125,9 @@ export class Options implements Pattern {
 
   parse(cursor: Cursor): Node | null {
     // This is a cache to help with speed
-    this._firstIndex = cursor.index;
-    depthCache.incrementDepth(this._id, this._firstIndex);
-
     this._firstIndex = cursor.index;
     const node = this._tryToParse(cursor);
 
-    depthCache.decrementDepth(this._id, this._firstIndex);
 
     if (node != null) {
       cursor.moveTo(node.lastIndex);
@@ -109,14 +140,15 @@ export class Options implements Pattern {
   }
 
   private _tryToParse(cursor: Cursor): Node | null {
-    if (depthCache.getDepth(this._id, this._firstIndex) > 2) {
-      cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
-      return null;
+    let children = this.children;
+
+    if (this._isBeyondRecursiveDepth()) {
+      children = children.slice().reverse();
     }
 
     const results: (Node | null)[] = [];
 
-    for (const pattern of this._children) {
+    for (const pattern of children) {
       cursor.moveTo(this._firstIndex);
       let result = null;
 
@@ -139,6 +171,25 @@ export class Options implements Pattern {
     return nonNullResults[0] || null;
   }
 
+  private _isBeyondRecursiveDepth() {
+    let depth = 0;
+    let pattern: Pattern | null = this;
+
+    while (pattern != null) {
+      if (pattern.id === this.id) {
+        depth++;
+      }
+
+      if (depth > this._recursiveDepth) {
+        return true;
+      }
+
+      pattern = pattern.parent;
+    }
+
+    return false;
+  }
+
   getTokens(): string[] {
     const tokens: string[] = [];
 

package/src/patterns/Sequence.ts

@@ -4,9 +4,7 @@ import { Node } from "../ast/Node";
 import { clonePatterns } from "./clonePatterns";
 import { filterOutNull } from "./filterOutNull";
 import { findPattern } from "./findPattern";
-import { DepthCache } from "./DepthCache";
 
-const depthCache = new DepthCache();
 let idIndex = 0;
 
 export class Sequence implements Pattern {
@@ -87,12 +85,8 @@ export class Sequence implements Pattern {
   parse(cursor: Cursor): Node | null {
     // This is a cache to help with speed
     this._firstIndex = cursor.index;
-    depthCache.incrementDepth(this._id, this._firstIndex);
-
     this._nodes = [];
-
     const passed = this.tryToParse(cursor);
-    depthCache.decrementDepth(this._id, this._firstIndex);
 
     if (passed) {
       const node = this.createNode(cursor);
@@ -108,7 +102,7 @@ export class Sequence implements Pattern {
   }
 
   private tryToParse(cursor: Cursor): boolean {
-    if (depthCache.getDepth(this._id, this._firstIndex) > 1) {
+    if (this._isBeyondRecursiveDepth()) {
       cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
       return false;
     }
@@ -173,6 +167,25 @@ export class Sequence implements Pattern {
     return passed;
   }
 
+  private _isBeyondRecursiveDepth() {
+    let depth = 0;
+    let pattern: Pattern | null = this;
+
+    while (pattern != null) {
+      if (pattern.id === this.id && this._firstIndex === (pattern as Sequence)._firstIndex) {
+        depth++;
+      }
+
+      if (depth > 1) {
+        return true;
+      }
+
+      pattern = pattern.parent;
+    }
+
+    return false;
+  }
+
   private getLastValidNode(): Node | null {
     const nodes = filterOutNull(this._nodes);
 

package/src/patterns/DepthCache.ts

@@ -1,26 +0,0 @@
-export class DepthCache {
-    private _depthMap: Record<string, Record<number, number>> = {};
-
-    getDepth(name: string, cursorIndex: number) {
-        if (this._depthMap[name] == null) {
-            this._depthMap[name] = {};
-        }
-
-        if (this._depthMap[name][cursorIndex] == null) {
-            this._depthMap[name][cursorIndex] = 0;
-        }
-
-
-        return this._depthMap[name][cursorIndex];
-    }
-
-    incrementDepth(name: string, cursorIndex: number) {
-        const depth = this.getDepth(name, cursorIndex);
-        this._depthMap[name][cursorIndex] = depth + 1;
-    }
-
-    decrementDepth(name: string, cursorIndex: number) {
-        const depth = this.getDepth(name, cursorIndex);
-        this._depthMap[name][cursorIndex] = depth - 1;
-    }
-}