clarity-pattern-parser 10.3.0 → 10.3.2

package/dist/patterns/Context.d.ts

@@ -17,6 +17,7 @@ export declare class Context implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
+    get startedOnIndex(): number;
     getPatternWithinContext(name: string): Pattern | null;
     getPatternsWithinContext(): {
         [x: string]: Pattern;

package/dist/patterns/ExpressionPattern.d.ts

@@ -29,6 +29,7 @@ export declare class ExpressionPattern implements Pattern {
     get unaryPatterns(): readonly Pattern[];
     get binaryPatterns(): readonly Pattern[];
     get recursivePatterns(): readonly Pattern[];
+    get startedOnIndex(): number;
     constructor(name: string, patterns: Pattern[]);
     private _organizePatterns;
     private _isBinary;
@@ -42,6 +43,7 @@ export declare class ExpressionPattern implements Pattern {
     parse(cursor: Cursor): Node | null;
     private _compactResult;
     private _tryToParse;
+    private _isBeyondRecursiveAllowance;
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;
     getTokens(): string[];

package/dist/patterns/FiniteRepeat.d.ts

@@ -18,6 +18,7 @@ export declare class FiniteRepeat implements Pattern {
     private _min;
     private _max;
     private _trimDivider;
+    private _firstIndex;
     shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
@@ -27,6 +28,7 @@ export declare class FiniteRepeat implements Pattern {
     get children(): Pattern[];
     get min(): number;
     get max(): number;
+    get startedOnIndex(): number;
     constructor(name: string, pattern: Pattern, options?: FiniteRepeatOptions);
     parse(cursor: Cursor): Node | null;
     test(text: string): boolean;

package/dist/patterns/InfiniteRepeat.d.ts

@@ -27,6 +27,7 @@ export declare class InfiniteRepeat implements Pattern {
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
     get min(): number;
+    get startedOnIndex(): number;
     constructor(name: string, pattern: Pattern, options?: InfiniteRepeatOptions);
     private _assignChildrenToParent;
     test(text: string): boolean;

package/dist/patterns/Literal.d.ts

@@ -20,6 +20,7 @@ export declare class Literal implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
+    get startedOnIndex(): number;
     constructor(name: string, value: string);
     test(text: string, record?: boolean): boolean;
     exec(text: string, record?: boolean): ParseResult;

package/dist/patterns/Not.d.ts

@@ -15,6 +15,7 @@ export declare class Not implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
+    get startedOnIndex(): number;
     constructor(name: string, pattern: Pattern);
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;

package/dist/patterns/Optional.d.ts

@@ -15,6 +15,7 @@ export declare class Optional implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
+    get startedOnIndex(): number;
     constructor(name: string, pattern: Pattern);
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;

package/dist/patterns/Options.d.ts

@@ -17,12 +17,14 @@ export declare class Options implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
+    get startedOnIndex(): number;
     constructor(name: string, options: Pattern[], isGreedy?: boolean);
     private _assignChildrenToParent;
     test(text: string): boolean;
     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/Pattern.d.ts

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

package/dist/patterns/Reference.d.ts

@@ -10,6 +10,7 @@ export declare class Reference implements Pattern {
     private _cachedPattern;
     private _pattern;
     private _children;
+    private _firstIndex;
     shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
@@ -17,6 +18,7 @@ export declare class Reference implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
+    get startedOnIndex(): number;
     constructor(name: string);
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;

package/dist/patterns/Regex.d.ts

@@ -22,6 +22,7 @@ export declare class Regex implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
+    get startedOnIndex(): number;
     constructor(name: string, regex: string);
     private assertArguments;
     test(text: string): boolean;

package/dist/patterns/Repeat.d.ts

@@ -26,6 +26,7 @@ export declare class Repeat implements Pattern {
     get children(): Pattern[];
     get min(): number;
     get max(): number;
+    get startedOnIndex(): number;
     constructor(name: string, pattern: Pattern, options?: RepeatOptions);
     parse(cursor: Cursor): Node | null;
     exec(text: string): ParseResult;

package/dist/patterns/Sequence.d.ts

@@ -16,6 +16,7 @@ export declare class Sequence implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
+    get startedOnIndex(): number;
     constructor(name: string, sequence: Pattern[]);
     private _assignChildrenToParent;
     test(text: string): boolean;
@@ -26,6 +27,7 @@ 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": "10.3.0",
+  "version": "10.3.2",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",

package/src/patterns/Context.ts

@@ -40,6 +40,10 @@ export class Context implements Pattern {
         return this._children;
     }
 
+    get startedOnIndex(){
+        return this.children[0].startedOnIndex;
+    }
+
     getPatternWithinContext(name: string): Pattern | null {
         return this._patterns[name] || null;
     }

package/src/patterns/ExpressionPattern.test.ts

@@ -96,6 +96,34 @@ function createOptionsExpression() {
     return expressionPattern;
 }
 
+function createTailExpression() {
+    const a = new Literal("a", "a");
+    const b = new Literal("b", "b");
+    const c = new Literal("c", "c");
+    const variable = new Options("variable", [a, b, c]);
+    const period = new Literal(".", ".");
+
+    const refinement = new Sequence("refinement", [period, variable]);
+    const refinementExpression = new Sequence("refinement-expression", [
+        new Reference("expression"),
+        refinement
+    ]);
+
+    const invocation = new Literal("invocation", "()");
+    const invocationExpression = new Sequence("invocation-expression", [
+        new Reference("expression"),
+        invocation
+    ]);
+
+    const expression = new ExpressionPattern("expression", [
+        refinementExpression,
+        invocationExpression,
+        variable
+    ]);
+
+    return expression;
+}
+
 describe("Expression Pattern", () => {
     test("Single Expression", () => {
         const expression = createExpressionPattern();
@@ -113,6 +141,16 @@ describe("Expression Pattern", () => {
         expect(result).toBe(result);
     });
 
+    test("Tail", () => {
+        const expression = createTailExpression();
+        let result = expression.exec("a");
+        result = expression.exec("a.b");
+        result = expression.exec("a.b.c");
+        result = expression.exec("a.b.c()()()");
+
+        expect(result).toBe(result);
+    });
+
     test("Options like", () => {
         const expression = createOptionsExpression();
         const autoComplete = new AutoComplete(expression);

package/src/patterns/ExpressionPattern.ts

@@ -1,13 +1,11 @@
 import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
-import { DepthCache } from "./DepthCache";
 import { ParseResult } from "./ParseResult";
 import { Pattern } from "./Pattern";
 import { findPattern } from "./findPattern";
 import { Sequence } from "./Sequence";
 
 let indexId = 0;
-const depthCache = new DepthCache();
 
 function createNode(name: string, children: Node[]) {
     return new Node("expression", name, 0, 0, children, "");
@@ -74,6 +72,10 @@ export class ExpressionPattern implements Pattern {
         return this._recursivePatterns;
     }
 
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
+
     constructor(name: string, patterns: Pattern[]) {
         if (patterns.length === 0) {
             throw new Error("Need at least one pattern with an 'expression' pattern.");
@@ -211,15 +213,9 @@ export class ExpressionPattern 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();
@@ -254,12 +250,11 @@ export class ExpressionPattern implements Pattern {
     }
 
     private _tryToParse(cursor: Cursor): Node | null {
-        if (depthCache.getDepth(this._id, this._firstIndex) > 2) {
+        if (this._isBeyondRecursiveAllowance()) {
             cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
             return null;
         }
 
-
         let lastUnaryNode: Node | null = null;
         let lastBinaryNode: Node | null = null;
         let onIndex = cursor.index;
@@ -330,7 +325,9 @@ export class ExpressionPattern implements Pattern {
                             }
                             break outer;
                         }
-                        break;
+                        onIndex = cursor.index;
+                        i = -1;
+                        continue;
                     }
                 }
 
@@ -446,6 +443,24 @@ export class ExpressionPattern 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) {
         const cursor = new Cursor(text);
         const ast = this.parse(cursor);

package/src/patterns/FiniteRepeat.ts

@@ -23,6 +23,7 @@ export class FiniteRepeat implements Pattern {
     private _min: number;
     private _max: number;
     private _trimDivider: boolean;
+    private _firstIndex: number;
 
     shouldCompactAst = false;
 
@@ -58,6 +59,10 @@ export class FiniteRepeat implements Pattern {
         return this._max;
     }
 
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
+
     constructor(name: string, pattern: Pattern, options: FiniteRepeatOptions = {}) {
         this._id = `finite-repeat-${idIndex++}`;
         this._type = "finite-repeat";
@@ -68,6 +73,7 @@ export class FiniteRepeat implements Pattern {
         this._min = options.min != null ? Math.max(options.min, 1) : 1;
         this._max = Math.max(this.min, options.max || this.min);
         this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
+        this._firstIndex = 0;
 
         for (let i = 0; i < this._max; i++) {
             const child = pattern.clone();
@@ -85,6 +91,8 @@ export class FiniteRepeat implements Pattern {
     }
 
     parse(cursor: Cursor): Node | null {
+        this._firstIndex = cursor.index;
+
         const startIndex = cursor.index;
         const nodes: Node[] = [];
         const modulo = this._hasDivider ? 2 : 1;

package/src/patterns/InfiniteRepeat.ts

@@ -56,6 +56,10 @@ export class InfiniteRepeat implements Pattern {
     return this._min;
   }
 
+  get startedOnIndex(){
+    return this._firstIndex;
+  }
+
   constructor(name: string, pattern: Pattern, options: InfiniteRepeatOptions = {}) {
     const min = options.min != null ? Math.max(options.min, 1) : 1;
     const divider = options.divider;

package/src/patterns/Literal.ts

@@ -46,6 +46,10 @@ export class Literal implements Pattern {
     return [];
   }
 
+  get startedOnIndex() {
+    return this._firstIndex;
+  }
+
   constructor(name: string, value: string) {
     if (value.length === 0) {
       throw new Error("Value Cannot be empty.");

package/src/patterns/Not.ts

@@ -38,6 +38,10 @@ export class Not implements Pattern {
     return this._children;
   }
 
+  get startedOnIndex() {
+    return this.children[0].startedOnIndex;
+  }
+
   constructor(name: string, pattern: Pattern) {
     this._id = `not-${idIndex++}`;
     this._type = "not";

package/src/patterns/Optional.ts

@@ -38,6 +38,10 @@ export class Optional implements Pattern {
     return this._children;
   }
 
+  get startedOnIndex() {
+    return this._children[0].startedOnIndex;
+  }
+
   constructor(name: string, pattern: Pattern) {
     this._id = `optional-${idIndex++}`;
     this._type = "optional";

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