clarity-pattern-parser 10.3.1 → 10.3.3

package/src/patterns/Options.ts

@@ -4,14 +4,8 @@ import { Pattern } from "./Pattern";
 import { clonePatterns } from "./clonePatterns";
 import { findPattern } from "./findPattern";
 import { ParseResult } from "./ParseResult";
-import { DepthCache } from './DepthCache';
 import { isRecursivePattern } from "./isRecursivePattern";
 
-/*
-  The following is created to reduce the overhead of recursion check. 
-*/
-
-const depthCache = new DepthCache();
 let idIndex = 0;
 
 export class Options implements Pattern {
@@ -49,6 +43,10 @@ export class Options implements Pattern {
     return this._children;
   }
 
+  get startedOnIndex() {
+    return this._firstIndex;
+  }
+
   constructor(name: string, options: Pattern[], isGreedy = false) {
     if (options.length === 0) {
       throw new Error("Need at least one pattern with an 'options' pattern.");
@@ -92,15 +90,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);
       cursor.resolveError();
@@ -117,7 +109,7 @@ export class Options implements Pattern {
   }
 
   private _tryToParse(cursor: Cursor): Node | null {
-    if (depthCache.getDepth(this._id, this._firstIndex) > 2) {
+    if (this._isBeyondRecursiveAllowance()) {
       return null;
     }
 
@@ -146,6 +138,24 @@ 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/Pattern.ts

@@ -7,6 +7,7 @@ export interface Pattern {
   type: string;
   name: string;
   shouldCompactAst: boolean;
+  startedOnIndex: number;
   parent: Pattern | null;
   children: Pattern[];
 

package/src/patterns/Reference.ts

@@ -15,6 +15,7 @@ export class Reference implements Pattern {
   private _cachedPattern: Pattern | null;
   private _pattern: Pattern | null;
   private _children: Pattern[];
+  private _firstIndex: number;
 
   shouldCompactAst = false;
 
@@ -42,6 +43,10 @@ export class Reference implements Pattern {
     return this._children;
   }
 
+  get startedOnIndex() {
+    return this._firstIndex;
+  }
+
   constructor(name: string) {
     this._id = `reference-${idIndex++}`;
     this._type = "reference";
@@ -50,6 +55,7 @@ export class Reference implements Pattern {
     this._pattern = null;
     this._cachedPattern = null;
     this._children = [];
+    this._firstIndex = 0;
   }
 
   test(text: string) {
@@ -72,6 +78,7 @@ export class Reference implements Pattern {
   }
 
   parse(cursor: Cursor): Node | null {
+    this._firstIndex = cursor.index;
     return this.getReferencePatternSafely().parse(cursor);
   }
 

package/src/patterns/Regex.ts

@@ -14,7 +14,7 @@ export class Regex implements Pattern {
   private _regex: RegExp;
   private _node: Node | null = null;
   private _cursor: Cursor | null = null;
-  private _firstIndex = -1;
+  private _firstIndex = 0;
   private _substring = "";
   private _tokens: string[] = [];
 
@@ -48,6 +48,10 @@ export class Regex implements Pattern {
     return [];
   }
 
+  get startedOnIndex() {
+    return this._firstIndex;
+  }
+
   constructor(name: string, regex: string) {
     this._id = `regex-${idIndex++}`;
     this._type = "regex";
@@ -149,7 +153,7 @@ export class Regex implements Pattern {
     clone._tokens = this._tokens.slice();
     clone._id = this._id;
     clone.shouldCompactAst = this.shouldCompactAst;
-    
+
     return clone;
   }
 

package/src/patterns/Repeat.ts

@@ -70,6 +70,10 @@ export class Repeat implements Pattern {
         return this._options.max;
     }
 
+    get startedOnIndex(){
+        return this._repeatPattern.startedOnIndex;
+    }
+
     constructor(name: string, pattern: Pattern, options: RepeatOptions = {}) {
         this._id = `repeat-${idIndex++}`;
         this._pattern = pattern;

package/src/patterns/RightAssociatedPattern.ts

@@ -38,6 +38,10 @@ export class RightAssociatedPattern implements Pattern {
         return this._children;
     }
 
+    get startedOnIndex() {
+        return this._children[0].startedOnIndex;
+    }
+
     constructor(pattern: Pattern) {
         this._id = `right-associated-${indexId++}`;
         this._type = "right-associated";

package/src/patterns/Sequence.ts

@@ -4,10 +4,8 @@ import { Node } from "../ast/Node";
 import { clonePatterns } from "./clonePatterns";
 import { filterOutNull } from "./filterOutNull";
 import { findPattern } from "./findPattern";
-import { DepthCache } from "./DepthCache";
 import { isRecursivePattern } from "./isRecursivePattern";
 
-const depthCache = new DepthCache();
 let idIndex = 0;
 
 export class Sequence implements Pattern {
@@ -45,6 +43,10 @@ export class Sequence implements Pattern {
     return this._children;
   }
 
+  get startedOnIndex() {
+    return this._firstIndex;
+  }
+
   constructor(name: string, sequence: Pattern[]) {
     if (sequence.length === 0) {
       throw new Error("Need at least one pattern with a 'sequence' pattern.");
@@ -88,14 +90,9 @@ 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);
@@ -115,7 +112,7 @@ export class Sequence implements Pattern {
   }
 
   private tryToParse(cursor: Cursor): boolean {
-    if (depthCache.getDepth(this._id, this._firstIndex) > 1) {
+    if (this._isBeyondRecursiveAllowance()) {
       cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
       return false;
     }
@@ -190,6 +187,24 @@ 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;

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;
-    }
-}