clarity-pattern-parser 6.0.2 → 7.0.0

package/src/patterns/InfiniteRepeat.test.ts

@@ -0,0 +1,296 @@
+import { Node } from "../ast/Node";
+import { And } from "./And";
+import { Cursor } from "./Cursor";
+import { findPattern } from "./findPattern";
+import { Literal } from "./Literal";
+import { Pattern } from "./Pattern";
+import { Regex } from "./Regex";
+import { InfiniteRepeat } from "./InfiniteRepeat";
+
+describe("InfiniteRepeat", () => {
+    test("Successful Parse", () => {
+        const digit = new Regex("digit", "\\d");
+        const integer = new InfiniteRepeat("number", digit);
+        const cursor = new Cursor("337");
+        const result = integer.parse(cursor);
+        const expected = new Node("infinite-repeat", "number", 0, 2, [
+            new Node("regex", "digit", 0, 0, [], "3"),
+            new Node("regex", "digit", 1, 1, [], "3"),
+            new Node("regex", "digit", 2, 2, [], "7"),
+        ]);
+
+        expect(result).toEqual(expected)
+        expect(cursor.hasError).toBeFalsy()
+    });
+
+    test("Bounds", () => {
+        const digit = new Regex("digit", "\\d");
+        const integer = new InfiniteRepeat("number", digit, { min: 2 });
+
+        let cursor = new Cursor("3");
+        let result = integer.parse(cursor);
+        let expected: Node | null = null;
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeTruthy();
+
+        cursor = new Cursor("33");
+        result = integer.parse(cursor);
+        expected = new Node("infinite-repeat", "number", 0, 1, [
+            new Node("regex", "digit", 0, 0, [], "3"),
+            new Node("regex", "digit", 1, 1, [], "3")
+        ]);
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
+    });
+
+    test("Failed Parse", () => {
+        const digit = new Regex("digit", "\\d");
+        const integer = new InfiniteRepeat("number", digit);
+        const cursor = new Cursor("John");
+        const result = integer.parse(cursor);
+
+        expect(result).toBeNull()
+        expect(cursor.hasError).toBeTruthy()
+    });
+
+    test("Successful Parse With Divider", () => {
+        const digit = new Regex("digit", "\\d");
+        const divider = new Literal("divider", ",");
+        const integer = new InfiniteRepeat("number", digit, { divider });
+        const cursor = new Cursor("3,3,7");
+        const result = integer.parse(cursor);
+        const expected = new Node("infinite-repeat", "number", 0, 4, [
+            new Node("regex", "digit", 0, 0, [], "3"),
+            new Node("literal", "divider", 1, 1, [], ","),
+            new Node("regex", "digit", 2, 2, [], "3"),
+            new Node("literal", "divider", 3, 3, [], ","),
+            new Node("regex", "digit", 4, 4, [], "7"),
+        ]);
+
+        expect(result).toEqual(expected)
+        expect(cursor.hasError).toBeFalsy()
+    });
+
+    test("Successful Parse Text Ends With Divider", () => {
+        const digit = new Regex("digit", "\\d");
+        const divider = new Literal("divider", ",");
+        const integer = new InfiniteRepeat("number", digit, { divider, trimDivider: true });
+        const cursor = new Cursor("3,3,7,");
+        const result = integer.parse(cursor);
+        const expected = new Node("infinite-repeat", "number", 0, 4, [
+            new Node("regex", "digit", 0, 0, [], "3"),
+            new Node("literal", "divider", 1, 1, [], ","),
+            new Node("regex", "digit", 2, 2, [], "3"),
+            new Node("literal", "divider", 3, 3, [], ","),
+            new Node("regex", "digit", 4, 4, [], "7"),
+        ]);
+
+        expect(result).toEqual(expected)
+        expect(cursor.hasError).toBeFalsy()
+    });
+
+    test("Successful Parse Trailing Comma", () => {
+        const digit = new Regex("digit", "\\d");
+        const divider = new Literal("divider", ",");
+        const integer = new InfiniteRepeat("number", digit, { divider, trimDivider: true });
+        const cursor = new Cursor("3,3,7,t");
+        const result = integer.parse(cursor);
+        const expected = new Node("infinite-repeat", "number", 0, 4, [
+            new Node("regex", "digit", 0, 0, [], "3"),
+            new Node("literal", "divider", 1, 1, [], ","),
+            new Node("regex", "digit", 2, 2, [], "3"),
+            new Node("literal", "divider", 3, 3, [], ","),
+            new Node("regex", "digit", 4, 4, [], "7"),
+        ]);
+
+        expect(result).toEqual(expected)
+        expect(cursor.hasError).toBeFalsy()
+    });
+
+    test("Optional Repeating Pattern", () => {
+        const digit = new Regex("digit", "\\d+", true);
+        const divider = new Regex("divider", "\\s");
+        const integer = new InfiniteRepeat("number", digit, { divider });
+        const cursor = new Cursor(
+            "\n" +
+            "3\n" +
+            "\n" +
+            "\n"
+        );
+        const result = integer.parse(cursor);
+        const expected = new Node("infinite-repeat", "number", 0, 4, [
+            new Node("regex", "divider", 0, 0, [], "\n"),
+            new Node("regex", "digit", 1, 1, [], "3"),
+            new Node("regex", "divider", 2, 2, [], "\n"),
+            new Node("regex", "divider", 3, 3, [], "\n"),
+            new Node("regex", "divider", 4, 4, [], "\n"),
+        ]);
+
+        expect(result).toEqual(expected)
+        expect(cursor.hasError).toBeFalsy()
+    });
+
+    test("Failed (Optional)", () => {
+        const digit = new Regex("digit", "\\d");
+        const integer = new InfiniteRepeat("number", digit, { min: 0 });
+        const cursor = new Cursor("John");
+        const result = integer.parse(cursor);
+
+        expect(result).toBeNull()
+        expect(cursor.hasError).toBeFalsy()
+    });
+
+    test("Get Tokens", () => {
+        const a = new Literal("a", "A");
+        const manyA = new InfiniteRepeat("number", a);
+        const tokens = manyA.getTokens();
+        const expected = ["A"];
+
+        expect(tokens).toEqual(expected)
+    });
+
+    test("Get Tokens After With Bogus Pattern", () => {
+        const a = new Literal("a", "A");
+        const manyA = new InfiniteRepeat("many-a", a);
+        const tokens = manyA.getTokensAfter(new Literal("bogus", "bogus"));
+        const expected: string[] = [];
+
+        expect(tokens).toEqual(expected)
+    });
+
+    test("Get Tokens After With Divider", () => {
+        const a = new Literal("a", "A");
+        const b = new Literal("b", "B");
+        const divider = new Literal("divider", ",");
+        const manyA = new InfiniteRepeat("many-a", a, { divider });
+        const parent = new And("parent", [manyA, b]);
+
+        const clonedManyA = findPattern(parent, p => p.name == "many-a");
+        let tokens = clonedManyA?.getTokensAfter(clonedManyA.children[0]);
+        let expected = [",", "B"];
+
+        expect(tokens).toEqual(expected)
+
+        tokens = clonedManyA?.getTokensAfter(clonedManyA.children[1]);
+        expected = ["A"];
+
+        expect(tokens).toEqual(expected)
+    });
+
+    test("Get Tokens After Without Divider", () => {
+        const a = new Literal("a", "A");
+        const b = new Literal("b", "B");
+        const manyA = new InfiniteRepeat("many-a", a);
+        const parent = new And("parent", [manyA, b]);
+
+        const clonedManyA = findPattern(parent, p => p.name == "many-a");
+        const tokens = clonedManyA?.getTokensAfter(clonedManyA.children[0]);
+        const expected = ["A", "B"];
+
+        expect(tokens).toEqual(expected)
+    });
+
+    test("Properties", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+
+        expect(integer.type).toBe("infinite-repeat");
+        expect(integer.name).toBe("integer");
+        expect(integer.min).toBe(1);
+        expect(integer.isOptional).toBeFalsy()
+        expect(integer.parent).toBeNull();
+        expect(integer.children[0].name).toBe("digit");
+    });
+
+    test("Exec", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+        const { ast: result } = integer.exec("B");
+        expect(result).toBeNull()
+    });
+
+    test("Test With Match", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+        const result = integer.test("1");
+        expect(result).toBeTruthy()
+    });
+
+    test("Test With No Match", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+        const result = integer.test("b");
+        expect(result).toBeFalsy()
+    });
+
+    test("Get Next Tokens", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+        const parent = new And("parent", [integer, new Literal("pow", "!")]);
+        const integerClone = parent.find(p => p.name === "integer") as Pattern;
+        const tokens = integerClone.getNextTokens();
+
+        expect(tokens).toEqual(["!"])
+    });
+
+    test("Get Next Tokens With Null Parents", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+        const tokens = integer.getNextTokens();
+
+        expect(tokens.length).toBe(0);
+    });
+
+    test("Find Pattern", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+        const digitClone = integer.find(p => p.name === "digit") as Pattern;
+
+        expect(digitClone).not.toBeNull();
+    });
+
+    test("Get Patterns", () => {
+        const a = new Literal("a", "A");
+        const manyA = new InfiniteRepeat("number", a);
+        const patterns = manyA.getPatterns();
+        const expected = [manyA.find(p => p.name === "a")];
+
+        expect(patterns).toEqual(expected)
+    });
+
+    test("Get Next Patterns", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+        const parent = new And("parent", [integer, new Literal("pow", "!")]);
+        const integerClone = parent.find(p => p.name === "integer") as Pattern;
+        const powClone = parent.find(p => p.name === "pow") as Pattern;
+        const patterns = integerClone.getNextPatterns();
+
+        expect(patterns.length).toBe(1);
+        expect(patterns[0]).toBe(powClone);
+    });
+
+    test("Get Next Patterns With Null Parents", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+        const patterns = integer.getNextPatterns();
+
+        expect(patterns.length).toBe(0);
+    });
+
+    test("Clone With Custom Overrides", () => {
+        const numbers = new InfiniteRepeat("numbers", new Regex("number", "\\d"), { min: 0 });
+        let clone = numbers.clone();
+        let expected = new InfiniteRepeat("numbers", new Regex("number", "\\d"), { min: 0 });
+
+        expect(clone).toEqual(expected);
+
+        clone = numbers.clone("cloned-numbers");
+        expected = new InfiniteRepeat("cloned-numbers", new Regex("number", "\\d"), { min: 0 });
+
+        expect(clone).toEqual(expected);
+
+        clone = numbers.clone("cloned-numbers", true);
+        expected = new InfiniteRepeat("cloned-numbers", new Regex("number", "\\d"), { min: 0 });
+
+        expect(clone).toEqual(expected);
+
+        clone = numbers.clone("cloned-numbers", false);
+        expected = new InfiniteRepeat("cloned-numbers", new Regex("number", "\\d"), { min: 1 });
+
+        expect(clone).toEqual(expected);
+    });
+});

package/src/patterns/InfiniteRepeat.ts

@@ -0,0 +1,329 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { Pattern } from "./Pattern";
+import { clonePatterns } from "./clonePatterns";
+import { findPattern } from "./findPattern";
+
+export interface InfiniteRepeatOptions {
+  divider?: Pattern;
+  min?: number;
+  trimDivider?: boolean;
+}
+
+export class InfiniteRepeat implements Pattern {
+  private _type: string;
+  private _name: string;
+  private _parent: Pattern | null;
+  private _children: Pattern[];
+  private _pattern: Pattern;
+  private _divider: Pattern | null;
+  private _nodes: Node[];
+  private _firstIndex: number;
+  private _min: number;
+  private _trimDivider: boolean;
+
+  get type(): string {
+    return this._type;
+  }
+
+  get name(): string {
+    return this._name;
+  }
+
+  get parent(): Pattern | null {
+    return this._parent;
+  }
+
+  set parent(pattern: Pattern | null) {
+    this._parent = pattern;
+  }
+
+  get children(): Pattern[] {
+    return this._children;
+  }
+
+  get isOptional(): boolean {
+    return this._min === 0;
+  }
+
+  get min(): number {
+    return this._min;
+  }
+
+  constructor(name: string, pattern: Pattern, options: InfiniteRepeatOptions = {}) {
+    const min = options.min != null ? options.min : 1;
+    const divider = options.divider;
+    let children: Pattern[];
+
+    if (divider != null) {
+      children = [pattern.clone(), divider.clone(divider.name, false)]
+    } else {
+      children = [pattern.clone()]
+    }
+
+    this._assignChildrenToParent(children);
+
+    this._type = "infinite-repeat";
+    this._name = name;
+    this._min = min;
+    this._parent = null;
+    this._children = children;
+    this._pattern = children[0];
+    this._divider = children[1];
+    this._firstIndex = -1
+    this._nodes = [];
+    this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
+  }
+
+  private _assignChildrenToParent(children: Pattern[]): void {
+    for (const child of children) {
+      child.parent = this;
+    }
+  }
+
+  test(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor);
+
+    return ast?.value === text;
+  }
+
+  exec(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor);
+
+    return {
+      ast: ast?.value === text ? ast : null,
+      cursor
+    };
+  }
+
+  parse(cursor: Cursor): Node | null {
+    this._firstIndex = cursor.index;
+    this._nodes = [];
+
+    const passed = this._tryToParse(cursor);
+
+    if (passed) {
+      cursor.resolveError();
+      const node = this._createNode(cursor);
+
+      if (node != null) {
+        cursor.moveTo(node.lastIndex);
+        cursor.recordMatch(this, node);
+      }
+
+      return node;
+    }
+
+    if (this._min > 0) {
+      return null;
+    }
+
+    cursor.resolveError();
+    return null;
+  }
+
+  private _meetsMin() {
+    if (this._divider != null) {
+      return Math.ceil(this._nodes.length / 2) >= this._min;
+    }
+    return this._nodes.length >= this._min;
+  }
+
+  private _tryToParse(cursor: Cursor): boolean {
+    let passed = false;
+
+    while (true) {
+      const runningCursorIndex = cursor.index;
+      const repeatedNode = this._pattern.parse(cursor);
+
+      if (cursor.hasError) {
+        const lastValidNode = this._getLastValidNode();
+
+        if (lastValidNode != null) {
+          passed = true;
+        } else {
+          cursor.moveTo(runningCursorIndex);
+          cursor.recordErrorAt(runningCursorIndex, this._pattern);
+          passed = false;
+        }
+
+        break;
+      } else {
+        if (repeatedNode != null) {
+          this._nodes.push(repeatedNode);
+
+          if (!cursor.hasNext()) {
+            passed = true;
+            break;
+          }
+
+          cursor.next();
+        }
+
+        if (this._divider != null) {
+          const dividerNode = this._divider.parse(cursor);
+
+          if (cursor.hasError) {
+            passed = true;
+            break;
+          } else if (dividerNode != null) {
+            this._nodes.push(dividerNode);
+
+            if (!cursor.hasNext()) {
+              passed = true;
+              break;
+            }
+
+            cursor.next();
+          }
+        }
+      }
+    }
+
+    const hasMinimum = this._meetsMin();
+
+    if (hasMinimum) {
+      return passed;
+    } else if (!hasMinimum && passed) {
+      cursor.recordErrorAt(cursor.index, this);
+      cursor.moveTo(this._firstIndex);
+      return false;
+    }
+
+    return passed;
+  }
+
+  private _createNode(cursor: Cursor): Node | null {
+    const hasDivider = this._divider != null;
+
+    if (
+      hasDivider &&
+      this._trimDivider &&
+      cursor.leafMatch.pattern === this._divider
+    ) {
+      const dividerNode = this._nodes.pop() as Node;
+      cursor.moveTo(dividerNode.firstIndex);
+    }
+
+    const lastIndex = this._nodes[this._nodes.length - 1].lastIndex;
+    cursor.moveTo(lastIndex);
+
+    return new Node(
+      this._type,
+      this._name,
+      this._firstIndex,
+      lastIndex,
+      this._nodes
+    );
+  }
+
+  private _getLastValidNode(): Node | null {
+    const nodes = this._nodes.filter((node) => node !== null);
+
+    if (nodes.length === 0) {
+      return null;
+    }
+
+    return nodes[nodes.length - 1];
+  }
+
+  getTokens(): string[] {
+    return this._pattern.getTokens();
+  }
+
+  getTokensAfter(childReference: Pattern): string[] {
+    const patterns = this.getPatternsAfter(childReference);
+    const tokens: string[] = [];
+
+    patterns.forEach(p => tokens.push(...p.getTokens()));
+
+    return tokens;
+  }
+
+  getNextTokens(): string[] {
+    if (this._parent == null) {
+      return []
+    }
+
+    return this._parent.getTokensAfter(this);
+  }
+
+  getPatterns(): Pattern[] {
+    return this._pattern.getPatterns();
+  }
+
+  getPatternsAfter(childReference: Pattern): Pattern[] {
+    let index = -1;
+    const patterns: Pattern[] = [];
+
+    for (let i = 0; i < this._children.length; i++) {
+      if (this._children[i] === childReference) {
+        index = i;
+      }
+    }
+
+    // If the last match isn't a child of this pattern.
+    if (index === -1) {
+      return [];
+    }
+
+    // If the last match was the repeated patterns, then suggest the divider.
+    if (index === 0 && this._divider) {
+      patterns.push(this._children[1]);
+
+      if (this._parent) {
+        patterns.push(...this._parent.getPatternsAfter(this));
+      }
+    }
+
+    // Suggest the pattern because the divider was the last match.
+    if (index === 1) {
+      patterns.push(this._children[0]);
+    }
+
+    // If there is no divider then suggest the repeating pattern and the next pattern after.
+    if (index === 0 && !this._divider && this._parent) {
+      patterns.push(this._children[0]);
+      patterns.push(...this._parent.getPatternsAfter(this));
+    }
+
+    return patterns;
+  }
+
+  getNextPatterns(): Pattern[] {
+    if (this._parent == null) {
+      return [];
+    }
+
+    return this._parent.getPatternsAfter(this)
+  }
+
+  find(predicate: (p: Pattern) => boolean): Pattern | null {
+    return findPattern(this, predicate);
+  }
+
+  clone(name = this._name, isOptional?: boolean): Pattern {
+    let min = this._min;
+
+    if (isOptional != null) {
+      if (isOptional) {
+        min = 0
+      } else {
+        min = Math.max(this._min, 1);
+      }
+    }
+
+    return new InfiniteRepeat(
+      name,
+      this._pattern,
+      {
+        divider: this._divider == null ? undefined : this._divider,
+        min: min,
+        trimDivider: this._trimDivider
+      }
+    );
+  }
+}
+

package/src/patterns/Literal.test.ts

@@ -119,7 +119,7 @@ describe("Literal", () => {
         const sequence = new And("sequence", [new Literal("a", "A")]);
         const parent = new And("parent", [sequence, new Literal("b", "B")]);
 
-        const a = parent.findPattern(p => p.name === "a");
+        const a = parent.find(p => p.name === "a");
         const tokens = a?.getNextTokens() || [];
 
         expect(tokens[0]).toBe("B");
@@ -145,9 +145,9 @@ describe("Literal", () => {
         const sequence = new And("sequence", [new Literal("a", "A")]);
         const parent = new And("parent", [sequence, new Literal("b", "B")]);
 
-        const a = parent.findPattern(p => p.name === "a");
+        const a = parent.find(p => p.name === "a");
         const nextPatterns = a?.getNextPatterns() || [];
-        const b = parent.findPattern(p => p.name === "b")
+        const b = parent.find(p => p.name === "b")
 
         expect(nextPatterns[0]).toBe(b);
     });
@@ -168,7 +168,7 @@ describe("Literal", () => {
 
     test("Find Pattern", () => {
         const a = new Literal("a", "A");
-        const pattern = a.findPattern(p => p.name === "nada");
+        const pattern = a.find(p => p.name === "nada");
 
         expect(pattern).toBeNull();
     });

package/src/patterns/Literal.ts

@@ -167,7 +167,7 @@ export class Literal implements Pattern {
     return this.parent.getPatternsAfter(this)
   }
 
-  findPattern(_predicate: (p: Pattern) => boolean): Pattern | null {
+  find(_predicate: (p: Pattern) => boolean): Pattern | null {
     return null;
   }