clarity-pattern-parser 11.0.7 → 11.0.8

package/dist/patterns/Expression.d.ts

@@ -51,7 +51,6 @@ export declare class Expression implements Pattern {
     private _tryToMatchAtom;
     private _tryToMatchPostfix;
     private _tryToMatchBinary;
-    private _isBeyondRecursiveAllowance;
     test(text: string, record?: boolean): boolean;
     exec(text: string, record?: boolean): ParseResult;
     getTokens(): string[];

package/dist/patterns/Options.d.ts

@@ -23,7 +23,6 @@ export declare class Options implements Pattern {
     exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
     private _tryToParse;
-    private _isBeyondRecursiveAllowance;
     getTokens(): string[];
     getTokensAfter(_childReference: Pattern): string[];
     getNextTokens(): string[];

package/dist/patterns/Reference.d.ts

@@ -11,6 +11,8 @@ export declare class Reference implements Pattern {
     private _pattern;
     private _children;
     private _firstIndex;
+    private _cachedAncestors;
+    private _recursiveAncestors;
     get id(): string;
     get type(): string;
     get name(): string;
@@ -22,6 +24,8 @@ export declare class Reference implements Pattern {
     test(text: string, record?: boolean): boolean;
     exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
+    private _cacheAncestors;
+    private _isBeyondRecursiveAllowance;
     getReferencePatternSafely(): Pattern;
     private _findPattern;
     private _isValidPattern;

package/dist/patterns/Sequence.d.ts

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

package/package.json

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

package/src/patterns/Expression.ts

@@ -263,11 +263,6 @@ export class Expression implements Pattern {
 
 
     private _tryToParse(cursor: Cursor): Node | null {
-        if (this._isBeyondRecursiveAllowance()) {
-            cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
-            return null;
-        }
-
         this._shouldStopParsing = false;
 
         while (true) {
@@ -426,25 +421,6 @@ export class Expression implements Pattern {
         }
     }
 
-
-    private _isBeyondRecursiveAllowance() {
-        let depth = 0;
-        let pattern: Pattern | null = this;
-
-        while (pattern != null) {
-            if (pattern.id === this.id && pattern.startedOnIndex === this.startedOnIndex) {
-                depth++;
-            }
-
-            if (depth > 2) {
-                return true;
-            }
-            pattern = pattern.parent;
-        }
-
-        return false;
-    }
-
     test(text: string, record = false): boolean {
         return testPattern(this, text, record);
     }

package/src/patterns/Options.test.ts

@@ -7,6 +7,7 @@ import { Pattern } from "./Pattern";
 import { Optional } from "./Optional";
 import { Regex } from "./Regex";
 import { Reference } from "./Reference";
+import { Expression } from "./Expression";
 
 describe("Options", () => {
     test("Empty Options", () => {
@@ -283,7 +284,7 @@ describe("Options", () => {
         const space = new Regex("space", "\\s+");
         const expressionReference = new Reference("expression");
         const ternary = new Sequence("ternary", [expressionReference, space, questionMark, space, expressionReference, space, colon, space, expressionReference]);
-        const expression = new Options("expression", [names, ternary], true);
+        const expression = new Expression("expression", [names, ternary]);
 
         let result = expression.exec("John");
         expect(result.ast?.toString()).toBe("John");

package/src/patterns/Options.ts

@@ -94,10 +94,6 @@ export class Options implements Pattern {
   }
 
   private _tryToParse(cursor: Cursor): Node | null {
-    if (this._isBeyondRecursiveAllowance()) {
-      return null;
-    }
-
     const results: (Node | null)[] = [];
 
     for (const pattern of this._children) {
@@ -123,24 +119,6 @@ export class Options implements Pattern {
     return nonNullResults[0] || null;
   }
 
-  private _isBeyondRecursiveAllowance() {
-    let depth = 0;
-    let pattern: Pattern | null = this;
-
-    while (pattern != null) {
-      if (pattern.id === this.id && pattern.startedOnIndex === this.startedOnIndex) {
-        depth++;
-      }
-
-      if (depth > 2) {
-        return true;
-      }
-      pattern = pattern.parent;
-    }
-
-    return false;
-  }
-
   getTokens(): string[] {
     const tokens: string[] = [];
 

package/src/patterns/Reference.ts

@@ -18,6 +18,8 @@ export class Reference implements Pattern {
   private _pattern: Pattern | null;
   private _children: Pattern[];
   private _firstIndex: number;
+  private _cachedAncestors: boolean;
+  private _recursiveAncestors: Reference[];
 
   get id(): string {
     return this._id;
@@ -56,6 +58,8 @@ export class Reference implements Pattern {
     this._cachedPattern = null;
     this._children = [];
     this._firstIndex = 0;
+    this._cachedAncestors = false;
+    this._recursiveAncestors = [];
   }
 
   test(text: string, record = false): boolean {
@@ -68,9 +72,46 @@ export class Reference implements Pattern {
 
   parse(cursor: Cursor): Node | null {
     this._firstIndex = cursor.index;
+    this._cacheAncestors();
+
+    if (this._isBeyondRecursiveAllowance()) {
+      cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
+      return null;
+    }
+
     return this.getReferencePatternSafely().parse(cursor);
   }
 
+  private _cacheAncestors() {
+    if (!this._cachedAncestors) {
+      let pattern: Pattern | null = this.parent;
+
+      while (pattern != null) {
+        if (pattern.type === this.type && pattern.id === this._id) {
+          this._recursiveAncestors.push(pattern as Reference);
+        }
+        pattern = pattern.parent;
+      }
+    }
+
+  }
+
+  private _isBeyondRecursiveAllowance() {
+    let depth = 0;
+
+    for (let pattern of this._recursiveAncestors) {
+      if (pattern._firstIndex === this._firstIndex) {
+        depth++;
+
+        if (depth > 2) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
   getReferencePatternSafely(): Pattern {
     if (this._pattern === null) {
       let pattern: Pattern | null = null;

package/src/patterns/Sequence.ts

@@ -98,11 +98,6 @@ export class Sequence implements Pattern {
   }
 
   private tryToParse(cursor: Cursor): boolean {
-    if (this._isBeyondRecursiveAllowance()) {
-      cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
-      return false;
-    }
-
     let passed = false;
 
     for (let i = 0; i < this._children.length; i++) {
@@ -173,24 +168,6 @@ export class Sequence implements Pattern {
     return nodes[nodes.length - 1];
   }
 
-  private _isBeyondRecursiveAllowance() {
-    let depth = 0;
-    let pattern: Pattern | null = this;
-
-    while (pattern != null) {
-      if (pattern.id === this.id && pattern.startedOnIndex === this.startedOnIndex) {
-        depth++;
-      }
-
-      if (depth > 1) {
-        return true;
-      }
-      pattern = pattern.parent;
-    }
-
-    return false;
-  }
-
   private areRemainingPatternsOptional(fromIndex: number): boolean {
     const startOnIndex = fromIndex + 1;
     const length = this._children.length;