clarity-pattern-parser 10.0.5 → 10.0.7

package/dist/patterns/Cursor.d.ts

@@ -2,18 +2,11 @@ import { Node } from "../ast/Node";
 import { Match } from "./CursorHistory";
 import { ParseError } from "./ParseError";
 import { Pattern } from "./Pattern";
-export declare class CyclicalParseError extends Error {
-    readonly patternId: string;
-    readonly patternName: string;
-    readonly cursorIndex: number;
-    constructor(patternId: string, patternName: string, cursorIndex: number);
-}
 export declare class Cursor {
     private _text;
     private _index;
     private _length;
     private _history;
-    private _stackTrace;
     get text(): string;
     get isOnFirst(): boolean;
     get isOnLast(): boolean;
@@ -45,8 +38,4 @@ export declare class Cursor {
     resolveError(): void;
     startRecording(): void;
     stopRecording(): void;
-    startParseWith(pattern: Pattern): void;
-    endParse(): void;
-    audit(): string[];
-    private _buildPatternContext;
 }

package/dist/patterns/CursorHistory.d.ts

@@ -1,10 +1,6 @@
 import { Node } from "../ast/Node";
 import { ParseError } from "./ParseError";
 import { Pattern } from "./Pattern";
-export interface Trace {
-    pattern: Pattern;
-    cursorIndex: number;
-}
 export interface Match {
     pattern: Pattern | null;
     node: Node | null;
@@ -18,7 +14,6 @@ export declare class CursorHistory {
     private _patterns;
     private _nodes;
     private _errors;
-    private _trace;
     get isRecording(): boolean;
     get rootMatch(): Match;
     get leafMatch(): Match;
@@ -28,11 +23,9 @@ export declare class CursorHistory {
     get error(): ParseError | null;
     get nodes(): Node[];
     get patterns(): Pattern[];
-    get trace(): Trace[];
     recordMatch(pattern: Pattern, node: Node): void;
     recordErrorAt(startIndex: number, endIndex: number, pattern: Pattern): void;
     startRecording(): void;
     stopRecording(): void;
     resolveError(): void;
-    pushStackTrace(trace: Trace): void;
 }

package/dist/patterns/DepthCache.d.ts

@@ -0,0 +1,6 @@
+export declare class DepthCache {
+    private _depthMap;
+    getDepth(name: string, cursorIndex: number): number;
+    incrementDepth(name: string, cursorIndex: number): void;
+    decrementDepth(name: string, cursorIndex: number): void;
+}

package/package.json

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

package/src/patterns/Cursor.ts

@@ -1,27 +1,13 @@
 import { Node } from "../ast/Node";
-import { CursorHistory, Match, Trace } from "./CursorHistory";
+import { CursorHistory, Match } from "./CursorHistory";
 import { ParseError } from "./ParseError";
 import { Pattern } from "./Pattern";
 
-export class CyclicalParseError extends Error {
-  readonly patternId: string;
-  readonly patternName: string;
-  readonly cursorIndex: number;
-
-  constructor(patternId: string, patternName: string, cursorIndex: number) {
-    super("Cyclical Parse Error");
-    this.patternId = patternId;
-    this.patternName = patternName;
-    this.cursorIndex = cursorIndex;
-  }
-}
-
 export class Cursor {
   private _text: string;
   private _index: number;
   private _length: number;
   private _history: CursorHistory;
-  private _stackTrace: Trace[];
 
   get text(): string {
     return this._text;
@@ -92,7 +78,6 @@ export class Cursor {
     this._index = 0;
     this._length = [...text].length;
     this._history = new CursorHistory();
-    this._stackTrace = [];
   }
 
   hasNext(): boolean {
@@ -157,39 +142,4 @@ export class Cursor {
     this._history.stopRecording();
   }
 
-  startParseWith(pattern: Pattern) {
-    const trace = {
-      pattern,
-      cursorIndex: this.index
-    };
-
-    const hasCycle = this._stackTrace.filter(t => t.pattern.id === pattern.id && this.index === t.cursorIndex).length > 1;
-    if (hasCycle) {
-      throw new CyclicalParseError(pattern.id, pattern.name, this.index);
-    }
-
-    this._history.pushStackTrace(trace);
-    this._stackTrace.push(trace);
-  }
-
-  endParse() {
-    this._stackTrace.pop();
-  }
-
-  audit() {
-    return this._history.trace.map(t => {
-      const onChar = this.getChars(t.cursorIndex, t.cursorIndex);
-      const restChars = this.getChars(t.cursorIndex + 1, t.cursorIndex + 5);
-      const context = `{${t.cursorIndex}}[${onChar}]${restChars}`;
-      return `${this._buildPatternContext(t.pattern)}-->${context}`;
-    });
-  }
-
-  private _buildPatternContext(pattern: Pattern) {
-    if (pattern.parent != null) {
-      return `${pattern.parent.name}.${pattern.name}`;
-    }
-    return pattern.name;
-  }
-
 }

package/src/patterns/CursorHistory.ts

@@ -2,11 +2,6 @@ import { Node } from "../ast/Node";
 import { ParseError } from "./ParseError";
 import { Pattern } from "./Pattern";
 
-export interface Trace {
-  pattern: Pattern;
-  cursorIndex: number;
-}
-
 export interface Match {
   pattern: Pattern | null;
   node: Node | null;
@@ -21,7 +16,6 @@ export class CursorHistory {
   private _patterns: Pattern[] = [];
   private _nodes: Node[] = [];
   private _errors: ParseError[] = [];
-  private _trace: Trace[] = [];
 
   get isRecording(): boolean {
     return this._isRecording;
@@ -59,10 +53,6 @@ export class CursorHistory {
     return this._patterns;
   }
 
-  get trace(): Trace[] {
-    return this._trace;
-  }
-
   recordMatch(pattern: Pattern, node: Node): void {
     if (this._isRecording) {
       this._patterns.push(pattern);
@@ -131,10 +121,4 @@ export class CursorHistory {
     this._currentError = null;
   }
 
-  pushStackTrace(trace: Trace) {
-    if (this._isRecording) {
-      this._trace.push(trace);
-    }
-  }
-
 }

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/FiniteRepeat.ts

@@ -83,8 +83,6 @@ export class FiniteRepeat implements Pattern {
     }
 
     parse(cursor: Cursor): Node | null {
-        cursor.startParseWith(this);
-
         const startIndex = cursor.index;
         const nodes: Node[] = [];
         const modulo = this._hasDivider ? 2 : 1;
@@ -128,13 +126,11 @@ export class FiniteRepeat implements Pattern {
             const lastIndex = cursor.index;
             cursor.moveTo(startIndex);
             cursor.recordErrorAt(startIndex, lastIndex, this);
-            cursor.endParse();
             return null;
         }
 
         if (nodes.length === 0 && !cursor.hasError) {
             cursor.moveTo(startIndex);
-            cursor.endParse();
             return null;
         }
 
@@ -143,7 +139,6 @@ export class FiniteRepeat implements Pattern {
 
         cursor.resolveError();
         cursor.moveTo(lastIndex);
-        cursor.endParse();
 
         return new Node(this._type, this.name, firstIndex, lastIndex, nodes);
     }

package/src/patterns/InfiniteRepeat.ts

@@ -106,8 +106,6 @@ export class InfiniteRepeat implements Pattern {
   }
 
   parse(cursor: Cursor): Node | null {
-    cursor.startParseWith(this);
-
     this._firstIndex = cursor.index;
     this._nodes = [];
 
@@ -122,17 +120,14 @@ export class InfiniteRepeat implements Pattern {
         cursor.recordMatch(this, node);
       }
 
-      cursor.endParse();
       return node;
     }
 
     if (this._min > 0) {
-      cursor.endParse();
       return null;
     }
 
     cursor.resolveError();
-    cursor.endParse();
     return null;
   }
 

package/src/patterns/Literal.ts

@@ -82,8 +82,6 @@ export class Literal implements Pattern {
   }
 
   parse(cursor: Cursor): Node | null {
-    cursor.startParseWith(this);
-
     this._firstIndex = cursor.index;
     const passed = this._tryToParse(cursor);
 
@@ -92,12 +90,10 @@ export class Literal implements Pattern {
       const node = this._createNode();
       cursor.recordMatch(this, node);
 
-      cursor.endParse();
       return node;
     }
 
     cursor.recordErrorAt(this._firstIndex, this._endIndex, this);
-    cursor.endParse();
     return null;
   }
 

package/src/patterns/Not.ts

@@ -65,8 +65,6 @@ export class Not implements Pattern {
   }
 
   parse(cursor: Cursor): Node | null {
-    cursor.startParseWith(this);
-
     const firstIndex = cursor.index;
     this._children[0].parse(cursor);
 
@@ -79,7 +77,6 @@ export class Not implements Pattern {
       cursor.recordErrorAt(firstIndex, firstIndex, this);
     }
 
-    cursor.endParse();
     return null;
   }
 

package/src/patterns/Optional.ts

@@ -65,8 +65,6 @@ export class Optional implements Pattern {
   }
 
   parse(cursor: Cursor): Node | null {
-    cursor.startParseWith(this);
-
     const firstIndex = cursor.index;
     const node = this._children[0].parse(cursor);
 
@@ -74,10 +72,8 @@ export class Optional implements Pattern {
       cursor.resolveError();
       cursor.moveTo(firstIndex);
 
-      cursor.endParse();
       return null;
     } else {
-      cursor.endParse();
       return node;
     }
 

package/src/patterns/Options.test.ts

@@ -291,9 +291,8 @@ describe("Options", () => {
         result = expression.exec("John ? Jane : John");
         expect(result.ast?.toString()).toBe("John ? Jane : John");
 
-
-        result = expression.exec("John ? Jane : John ? Jane : John");
-        expect(result.ast?.toString()).toBe("John ? Jane : John ? Jane : John");
+        result = expression.exec("John ? John ? Jane : John ? Jane : John : John");
+        expect(result.ast?.toString()).toBe("John ? John ? Jane : John ? Jane : John : John");
     });
 
     test("Deeper Cyclical Error Recorvery", () => {

package/src/patterns/Options.ts

@@ -4,7 +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 {
@@ -83,37 +89,40 @@ export class Options implements Pattern {
   }
 
   parse(cursor: Cursor): Node | null {
-    cursor.startParseWith(this);
-
+    // 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();
-
-      cursor.endParse();
       return node;
     }
 
     cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
-    cursor.endParse();
     return null;
   }
 
+
+
   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 this._children) {
       cursor.moveTo(this._firstIndex);
       let result = null;
 
-      try {
-        result = pattern.parse(cursor);
-      } catch {
-        continue;
-      }
+      result = pattern.parse(cursor);
 
       if (this._isGreedy) {
         results.push(result);

package/src/patterns/Regex.ts

@@ -96,13 +96,10 @@ export class Regex implements Pattern {
   }
 
   parse(cursor: Cursor) {
-    cursor.startParseWith(this);
-
     this._firstIndex = cursor.index;
     this.resetState(cursor);
     this.tryToParse(cursor);
 
-    cursor.endParse();
     return this._node;
   }
 

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 {
@@ -83,12 +85,14 @@ export class Sequence implements Pattern {
   }
 
   parse(cursor: Cursor): Node | null {
-    cursor.startParseWith(this);
-
+    // 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);
@@ -97,15 +101,18 @@ export class Sequence implements Pattern {
         cursor.recordMatch(this, node);
       }
 
-      cursor.endParse();
       return node;
     }
 
-    cursor.endParse();
     return null;
   }
 
   private tryToParse(cursor: Cursor): boolean {
+    if (depthCache.getDepth(this._id, this._firstIndex) > 1) {
+      cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
+      return false;
+    }
+
     let passed = false;
 
     for (let i = 0; i < this._children.length; i++) {