clarity-pattern-parser 10.0.3 → 10.0.5

package/dist/patterns/Cursor.d.ts

@@ -2,6 +2,12 @@ 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;

package/package.json

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

package/src/grammar/Grammar.ts

@@ -322,7 +322,7 @@ export class Grammar {
         const trimDivider = repeatNode.find(n => n.name === "trim-flag") != null;
         const patterNode = repeatNode.children[1].type === "spaces" ? repeatNode.children[2] : repeatNode.children[1];
         const pattern = this._buildPattern(patterNode);
-        const dividerSectionNode = repeatNode.find(n => n.name === "divider-section");
+        const dividerSectionNode = repeatNode.find(n => n.name === "repeat-divider-section");
 
         const options: RepeatOptions = {
             min: 1,

package/src/grammar/patterns/import.ts

@@ -9,7 +9,7 @@ import { allSpaces, lineSpaces } from "./spaces";
 import { Optional } from "../../patterns/Optional";
 
 const optionalSpaces = new Optional("optional-spaces", allSpaces);
-const optionalLineSpaces = new Optional("options-line-spaces", lineSpaces);
+const optionalLineSpaces = new Optional("optional-line-spaces", lineSpaces);
 
 const importNameDivider = new Regex("import-name-divider", "(\\s+)?,(\\s+)?");
 importNameDivider.setTokens([", "]);

package/src/grammar/patterns/optionsLiteral.ts

@@ -7,7 +7,7 @@ import { Options } from "../../patterns/Options";
 const patternName = name.clone("pattern-name");
 patternName.setTokens(["[PATTERN_NAME]"]);
 
-const patterns = new Options("or-patterns", [patternName, anonymousPattern]);
+const patterns = new Options("options-patterns", [patternName, anonymousPattern]);
 const defaultDivider = new Regex("default-divider", "\\s*[|]\\s*");
 defaultDivider.setTokens(["|"]);
 

package/src/grammar/patterns/repeatLiteral.ts

@@ -8,8 +8,8 @@ import { lineSpaces, spaces } from "./spaces";
 import { Optional } from "../../patterns/Optional";
 
 const optionalSpaces = new Optional("optional-spaces", spaces);
-const openBracket = new Literal("open-bracket", "{");
-const closeBracket = new Literal("close-bracket", "}");
+const openBracket = new Literal("repeat-open-bracket", "{");
+const closeBracket = new Literal("repeat-close-bracket", "}");
 const comma = new Literal("comma", ",");
 
 const integer = new Regex("integer", "([1-9][0-9]*)|0");
@@ -55,16 +55,16 @@ dividerComma.setTokens([", "]);
 
 
 const patternName = name.clone("pattern-name");
-const patterns = new Options("or-patterns", [patternName, anonymousPattern]);
-const dividerPattern = patterns.clone("divider-pattern");
-const dividerSection = new Sequence("divider-section", [dividerComma, dividerPattern, trimFlag]);
-const optionalDividerSection = new Optional("optional-divider-section", dividerSection);
+const repeatPattern = new Options("repeat-pattern", [patternName, anonymousPattern]);
+const repeatDividerPattern = repeatPattern.clone("repeat-divider-pattern");
+const repeatDividerSection = new Sequence("repeat-divider-section", [dividerComma, repeatDividerPattern, trimFlag]);
+const repeatOptionalDividerSection = new Optional("repeat-optional-divider-section", repeatDividerSection);
 
 export const repeatLiteral = new Sequence("repeat-literal", [
     openParen,
     optionalSpaces,
-    patterns,
-    optionalDividerSection,
+    repeatPattern,
+    repeatOptionalDividerSection,
     optionalSpaces,
     closeParen,
     new Sequence("quantifier-section", [quantifier]),

package/src/intellisense/AutoComplete.ts

@@ -48,11 +48,11 @@ export class AutoComplete {
         errorAtIndex: 0,
         cursor,
         ast: null
-      }
+      };
     }
 
     let errorAtIndex = null;
-    let error = null
+    let error = null;
 
     const ast = this._pattern.parse(this._cursor);
     const isComplete = ast?.value === this._text;
@@ -74,7 +74,7 @@ export class AutoComplete {
       errorAtIndex = startIndex;
     } else if (!isComplete && this._cursor.hasError && this._cursor.furthestError != null) {
       errorAtIndex = this._cursor.furthestError.endIndex;
-      error = this._cursor.furthestError
+      error = this._cursor.furthestError;
 
       errorAtIndex = options.reduce((errorAtIndex, option) =>
         Math.max(errorAtIndex, option.startIndex),
@@ -88,7 +88,7 @@ export class AutoComplete {
       errorAtIndex,
       cursor: cursor,
       ast,
-    }
+    };
 
   }
 
@@ -108,7 +108,7 @@ export class AutoComplete {
       }
     });
 
-    return finalResults
+    return finalResults;
   }
 
   private _getOptionsFromErrors() {
@@ -159,7 +159,7 @@ export class AutoComplete {
   }
 
   private _getTokensForPattern(pattern: Pattern) {
-    const augmentedTokens = this._getAugmentedTokens(pattern)
+    const augmentedTokens = this._getAugmentedTokens(pattern);
 
     if (this._options.greedyPatternNames != null && this._options.greedyPatternNames.includes(pattern.name)) {
       const nextPatterns = pattern.getNextPatterns();
@@ -225,7 +225,7 @@ export class AutoComplete {
     return {
       text: text,
       startIndex: furthestMatch,
-    }
+    };
   }
 
   static suggestFor(text: string, pattern: Pattern, options?: AutoCompleteOptions) {

package/src/patterns/Cursor.ts

@@ -3,6 +3,19 @@ import { CursorHistory, Match, Trace } 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;
@@ -145,16 +158,14 @@ export class Cursor {
   }
 
   startParseWith(pattern: Pattern) {
-    const patternName = pattern.name;
-
     const trace = {
       pattern,
       cursorIndex: this.index
     };
 
-    const hasCycle = this._stackTrace.find(t => t.pattern.id === pattern.id && this.index === t.cursorIndex);
+    const hasCycle = this._stackTrace.filter(t => t.pattern.id === pattern.id && this.index === t.cursorIndex).length > 1;
     if (hasCycle) {
-      throw new Error(`Cyclical Pattern: ${this._stackTrace.map(t => `${t.pattern.name}#${t.pattern.id}{${t.cursorIndex}}`).join(" -> ")} -> ${patternName}#${pattern.id}{${this.index}}.`);
+      throw new CyclicalParseError(pattern.id, pattern.name, this.index);
     }
 
     this._history.pushStackTrace(trace);

package/src/patterns/Options.test.ts

@@ -5,6 +5,8 @@ import { Options } from "./Options";
 import { Sequence } from "./Sequence";
 import { Pattern } from "./Pattern";
 import { Optional } from "./Optional";
+import { Regex } from "./Regex";
+import { Reference } from "./Reference";
 
 describe("Options", () => {
     test("Empty Options", () => {
@@ -271,4 +273,43 @@ describe("Options", () => {
         const result = firstName.exec("Jane");
         expect(result.ast?.value).toBe("Jane");
     });
+
+    test("Cyclical Error Recorvery", () => {
+        const john = new Literal("john", "John");
+        const jane = new Literal("jane", "Jane");
+        const names = new Options("names", [john, jane]);
+        const questionMark = new Literal("?", "?");
+        const colon = new Literal(":", ":");
+        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);
+
+        let result = expression.exec("John");
+        expect(result.ast?.toString()).toBe("John");
+
+        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");
+    });
+
+    test("Deeper Cyclical Error Recorvery", () => {
+        const john = new Literal("john", "John");
+        const expressionReference = new Reference("expression");
+
+        const johns = new Sequence("johns", [john, expressionReference]);
+        const expression = new Options("expression", [
+            john,
+            johns,
+        ], true);
+
+        let result = expression.exec("John");
+        expect(result.ast?.toString()).toBe("John");
+
+        result = expression.exec("JohnJohnJohnJohnJohn");
+        expect(result.ast?.toString()).toBe("JohnJohnJohnJohnJohn");
+    });
 });

package/src/patterns/Options.ts

@@ -84,6 +84,7 @@ export class Options implements Pattern {
 
   parse(cursor: Cursor): Node | null {
     cursor.startParseWith(this);
+
     this._firstIndex = cursor.index;
 
     const node = this._tryToParse(cursor);
@@ -106,7 +107,13 @@ export class Options implements Pattern {
 
     for (const pattern of this._children) {
       cursor.moveTo(this._firstIndex);
-      const result = pattern.parse(cursor);
+      let result = null;
+
+      try {
+        result = pattern.parse(cursor);
+      } catch {
+        continue;
+      }
 
       if (this._isGreedy) {
         results.push(result);