clarity-pattern-parser 10.0.2 → 10.0.4

package/dist/patterns/Cursor.d.ts

@@ -2,6 +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;
+    constructor(patternId: string, patternName: string);
+}
 export declare class Cursor {
     private _text;
     private _index;

package/dist/patterns/Not.d.ts

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

package/dist/patterns/Repeat.d.ts

@@ -21,8 +21,8 @@ export declare class Repeat implements Pattern {
     get parent(): Pattern | null;
     set parent(value: Pattern | null);
     get children(): Pattern[];
-    get min(): any;
-    get max(): any;
+    get min(): number;
+    get max(): number;
     constructor(name: string, pattern: Pattern, options?: RepeatOptions);
     parse(cursor: Cursor): Node | null;
     exec(text: string): ParseResult;

package/package.json

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

package/src/ast/Node.ts

@@ -315,6 +315,10 @@ export class Node {
     return JSON.stringify(this.toCycleFreeObject(), null, space);
   }
 
+  isEqual(node: Node) {
+    return node.toJson(0) === this.toJson(0);
+  }
+
   static createValueNode(name: string, value: string) {
     return new Node("custom-value-node", name, 0, 0, [], value);
   }

package/src/grammar/Grammar.test.ts

@@ -511,4 +511,38 @@ describe("Grammar", () => {
         expect(patterns.john).not.toBeNull();
         expect(patterns.jane).not.toBeNull();
     });
+
+    test("Grammar Import", async () => {
+        const importExpression = `first-name = "John"`;
+        const spaceExpression = `
+        use params { custom-space }
+        space = custom-space
+        `;
+        const expression = `
+        use params {
+          custom-space
+        }
+        import { first-name } from "first-name.cpat"
+        import { space } from "space.cpat" with params {
+          custom-space = custom-space
+        }
+        last-name = "Doe"
+        full-name = first-name + space + last-name
+        `;
+
+        const pathMap: Record<string, string> = {
+            "space.cpat": spaceExpression,
+            "first-name.cpat": importExpression,
+            "root.cpat": expression
+        };
+
+        function resolveImport(resource: string) {
+            return Promise.resolve({ expression: pathMap[resource], resource });
+        }
+
+        const patterns = await Grammar.import("root.cpat", { resolveImport, params: [new Literal("custom-space", "  ")] });
+        const fullname = patterns["full-name"] as Pattern;
+        const result = fullname.exec("John  Doe");
+        expect(result?.ast?.value).toBe("John  Doe");
+    });
 });

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,
@@ -462,7 +462,7 @@ export class Grammar {
                 );
 
                 const grammar = new Grammar({
-                    params: importedValues,
+                    params: [...importedValues, ...this._parseContext.paramsByName.values()],
                     originResource: this._originResource,
                     resolveImport: this._resolveImport
                 });

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.test.ts

@@ -118,7 +118,7 @@ describe("AutoComplete", () => {
 
         expect(result.ast).toBeNull();
         expect(result.options).toEqual(expectedOptions);
-        expect(result.errorAtIndex).toBe(text.length)
+        expect(result.errorAtIndex).toBe(text.length);
         expect(result.isComplete).toBeFalsy();
         expect(result.cursor).not.toBeNull();
     });

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,17 @@ 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;
+
+  constructor(patternId: string, patternName: string) {
+    super("Cyclical Parse Error");
+    this.patternId = patternId;
+    this.patternName = patternName;
+  }
+}
+
 export class Cursor {
   private _text: string;
   private _index: number;
@@ -145,16 +156,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._history.pushStackTrace(trace);

package/src/patterns/FiniteRepeat.test.ts

@@ -478,4 +478,10 @@ describe("BoundedRepeat", () => {
         expect(comma).toBe(numbers.children[1]);
     });
 
+    test("Trim Trailing Complex Delimiter Pattern", () => {
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), { divider: new Sequence("comma", [new Literal(",", ","), new Literal("space", " ")]), trimDivider: true, max: 3 });
+        const result = numbers.parse(new Cursor("1, 2,"));
+        expect(result?.value).toBe("1, 2");
+    });
+
 });

package/src/patterns/FiniteRepeat.ts

@@ -117,7 +117,7 @@ export class FiniteRepeat implements Pattern {
         }
 
         if (this._trimDivider && this._hasDivider) {
-            const isDividerLastMatch = cursor.leafMatch.pattern?.id === this.children[1].id;
+            const isDividerLastMatch = this.children.length > 1 && nodes[nodes.length - 1].name === this.children[1].name;
             if (isDividerLastMatch) {
                 const node = nodes.pop() as Node;
                 cursor.moveTo(node.firstIndex);

package/src/patterns/InfiniteRepeat.test.ts

@@ -264,5 +264,11 @@ describe("InfiniteRepeat", () => {
         expect(result.cursor.hasError).toBeTruthy();
     });
 
+    test("Trim Trailing Complex Delimiter Pattern", () => {
+        const numbers = new InfiniteRepeat("numbers", new Regex("number", "\\d"), { divider: new Sequence("comma", [new Literal(",", ","), new Literal("space", " ")]), trimDivider: true });
+        const result = numbers.parse(new Cursor("1, 2,"));
+        expect(result?.value).toBe("1, 2");
+    });
+
 
 });

package/src/patterns/InfiniteRepeat.ts

@@ -235,7 +235,7 @@ export class InfiniteRepeat implements Pattern {
     if (
       hasDivider &&
       this._trimDivider &&
-      cursor.leafMatch.pattern === this._divider
+      this._nodes[this._nodes.length - 1].name === this._divider?.name
     ) {
       const dividerNode = this._nodes.pop() as Node;
       cursor.moveTo(dividerNode.firstIndex);

package/src/patterns/Not.test.ts

@@ -53,7 +53,6 @@ describe("Not", () => {
         expect(notA.name).toBe("not-a");
         expect(notA.parent).toBeNull();
         expect(notA.children[0].name).toBe("a");
-        expect(notA.isOptional).toBeFalsy();
     });
 
     test("Not A Not", () => {

package/src/patterns/Not.ts

@@ -36,10 +36,6 @@ export class Not implements Pattern {
     return this._children;
   }
 
-  get isOptional(): boolean {
-    return false;
-  }
-
   constructor(name: string, pattern: Pattern) {
     this._id = `not-${idIndex++}`;
     this._type = "not";

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,26 @@ 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");
+    });
 });

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,18 @@ 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 (error: any) {
+        if (error.patternId === this._id) {
+          continue;
+        } else {
+          cursor.endParse();
+          throw error;
+        }
+      }
 
       if (this._isGreedy) {
         results.push(result);

package/src/patterns/Repeat.ts

@@ -53,11 +53,11 @@ export class Repeat implements Pattern {
     }
 
     get min() {
-        return (this.children[0] as any).min;
+        return this._options.min;
     }
 
     get max() {
-        return (this.children[0] as any).max || Infinity;
+        return this._options.max;
     }
 
     constructor(name: string, pattern: Pattern, options: RepeatOptions = {}) {

package/src/patterns/Sequence.test.ts

@@ -3,6 +3,7 @@ import { Sequence } from "./Sequence";
 import { Literal } from "./Literal";
 import { Node } from "../ast/Node";
 import { Optional } from "./Optional";
+import { Pattern } from "./Pattern";
 
 describe("Sequence", () => {
     test("No Patterns", () => {
@@ -310,9 +311,9 @@ describe("Sequence", () => {
 
         const sequenceClone = parent.find(p => p.name === "sequence");
         const nextPatterns = sequenceClone?.getNextPatterns() || [];
-        const b = parent.find(p => p.name === "b")
+        const b = parent.find(p => p.name === "b") as Pattern;
 
-        expect(nextPatterns[0]).toBe(b);
+        expect(nextPatterns[0].isEqual(b)).toBeTruthy();
     });
 
     test("Get Next Patterns With Null Parent", () => {

package/src/patterns/Sequence.ts

@@ -212,7 +212,7 @@ export class Sequence implements Pattern {
     for (const child of this._children) {
       tokens.push(...child.getTokens());
 
-      if (child.type !== "optional") {
+      if (child.type !== "optional" && child.type !== "not") {
         break;
       }
     }
@@ -243,7 +243,7 @@ export class Sequence implements Pattern {
     for (const child of this._children) {
       patterns.push(...child.getPatterns());
 
-      if (child.type !== "optional") {
+      if (child.type !== "optional" && child.type !== "not") {
         break;
       }
     }