clarity-pattern-parser 10.1.15 → 10.1.17

package/dist/patterns/Options.d.ts

@@ -22,7 +22,6 @@ export declare class Options implements Pattern {
     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,7 +24,6 @@ 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.15",
+  "version": "10.1.17",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",

package/src/grammar/Grammar.test.ts

@@ -9,7 +9,6 @@ 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", () => {
@@ -570,6 +569,4 @@ describe("Grammar", () => {
         const result = fullname.exec("John  Doe");
         expect(result?.ast?.value).toBe("John  Doe");
     });
-
-
 });

package/src/intellisense/AutoComplete.test.ts

@@ -490,31 +490,4 @@ 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,10 +76,9 @@ 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 {
@@ -99,19 +98,17 @@ export class AutoComplete {
 
   private _getAllOptions() {
     const errorMatches = this._getOptionsFromErrors();
-    const validLeafMatches = this._cursor.leafMatches.filter(v => v.node?.lastIndex === this._cursor.getLastIndex())
+    const leafMatches = this._cursor.leafMatches.map((m) => this._createSuggestionsFromMatch(m)).flat();
+    const finalResults: SuggestionOption[] = [];
 
-    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);
+    [...leafMatches, ...errorMatches].forEach(m=>{
+      const index = finalResults.findIndex(f=> m.text === f.text);
       if (index === -1){
-        uniqueResults.push(m);
+        finalResults.push(m);
       }
     });
 
-    return uniqueResults;
+    return finalResults;
   }
 
   private _getOptionsFromErrors() {
@@ -121,9 +118,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;
+    return suggestions.flat();
   }
 
   private _createSuggestionsFromRoot(): SuggestionOption[] {

package/src/intellisense/javascript/Javascript.test.ts

@@ -220,4 +220,6 @@ describe("Ecmascript 3", () => {
         result = expression.exec(`name.prop.anotherProp["Ha"][coolYo] === 1`);
         expect(result.ast?.value).toBe(`name.prop.anotherProp["Ha"][coolYo] === 1`);
     });
-});
+
+
+});

package/src/patterns/DepthCache.ts

@@ -0,0 +1,26 @@
+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;
+    }
+}

package/src/patterns/Options.ts

@@ -4,10 +4,13 @@ import { Pattern } from "./Pattern";
 import { clonePatterns } from "./clonePatterns";
 import { findPattern } from "./findPattern";
 import { ParseResult } from "./ParseResult";
+import { DepthCache } from './DepthCache';
 
 /*
   The following is created to reduce the overhead of recursion check. 
 */
+
+const depthCache = new DepthCache();
 let idIndex = 0;
 
 export class Options implements Pattern {
@@ -87,9 +90,13 @@ 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);
@@ -101,16 +108,17 @@ export class Options implements Pattern {
     return null;
   }
 
-  private _tryToParse(cursor: Cursor): Node | null {
-    let children = this.children;
 
-    if (this._isBeyondRecursiveDepth()) {
-      children = children.slice().reverse();
+
+  private _tryToParse(cursor: Cursor): Node | null {
+    if (depthCache.getDepth(this._id, this._firstIndex) > 2) {
+      cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
+      return null;
     }
 
     const results: (Node | null)[] = [];
 
-    for (const pattern of children) {
+    for (const pattern of this._children) {
       cursor.moveTo(this._firstIndex);
       let result = null;
 
@@ -133,25 +141,6 @@ 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.children.length) {
-        return true;
-      }
-
-      pattern = pattern.parent;
-    }
-
-    return false;
-  }
-
   getTokens(): string[] {
     const tokens: string[] = [];
 

package/src/patterns/Sequence.ts

@@ -4,7 +4,9 @@ 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 {
@@ -85,8 +87,12 @@ 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);
@@ -102,7 +108,7 @@ export class Sequence implements Pattern {
   }
 
   private tryToParse(cursor: Cursor): boolean {
-    if (this._isBeyondRecursiveDepth()) {
+    if (depthCache.getDepth(this._id, this._firstIndex) > 1) {
       cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
       return false;
     }
@@ -167,25 +173,6 @@ 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/grammar/ComplexGrammar.test.ts

@@ -1,16 +0,0 @@
-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 || c");
-        expect(result.ast?.toString()).toBe("a * b || c");
-    });
-});