clarity-pattern-parser 4.0.2 → 5.0.0

package/src/patterns/Repeat.test.ts

@@ -0,0 +1,196 @@
+import { Node } from "../ast/Node";
+import { And } from "./And";
+import { Cursor } from "./Cursor";
+import { findPattern } from "./findPattern";
+import { Literal } from "./Literal";
+import { Regex } from "./Regex";
+import { Repeat } from "./Repeat";
+
+describe("Repeat", () => {
+    test("Successful Parse", () => {
+        const digit = new Regex("digit", "\\d");
+        const integer = new Repeat("number", digit);
+        const cursor = new Cursor("337");
+        const result = integer.parse(cursor);
+        const expected = new Node("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("Failed Parse", () => {
+        const digit = new Regex("digit", "\\d");
+        const integer = new Repeat("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 Repeat("number", digit, divider);
+        const cursor = new Cursor("3,3,7");
+        const result = integer.parse(cursor);
+        const expected = new Node("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 Repeat("number", digit, divider);
+        const cursor = new Cursor("3,3,7,");
+        const result = integer.parse(cursor);
+        const expected = new Node("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 Repeat("number", digit, divider);
+        const cursor = new Cursor("3,3,7,t");
+        const result = integer.parse(cursor);
+        const expected = new Node("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("Failed (Optional)", () => {
+        const digit = new Regex("digit", "\\d");
+        const integer = new Repeat("number", digit, undefined, true);
+        const cursor = new Cursor("John");
+        const result = integer.parse(cursor);
+
+        expect(result).toBeNull()
+        expect(cursor.hasError).toBeFalsy()
+    });
+
+    test("Ast Reduction", () => {
+        const digit = new Regex("digit", "\\d");
+        const integer = new Repeat("number", digit);
+        const cursor = new Cursor("337");
+
+        integer.enableAstReduction();
+
+        let result = integer.parse(cursor);
+        let expected = new Node("repeat", "number", 0, 2, [], "337");
+
+        expect(result).toEqual(expected)
+
+        integer.disableAstReduction()
+        cursor.moveTo(0)
+
+        result = integer.parse(cursor);
+        expected = new Node("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)
+    });
+
+    test("Get Tokens", () => {
+        const a = new Literal("a", "A");
+        const manyA = new Repeat("number", a);
+        const tokens = manyA.getTokens();
+        const expected = ["A"];
+
+        expect(tokens).toEqual(expected)
+    });
+
+    test("Get Next Tokens With Bogus Pattern", () => {
+        const a = new Literal("a", "A");
+        const manyA = new Repeat("many-a", a);
+        const tokens = manyA.getNextTokens(new Literal("bogus", "bogus"));
+        const expected: string[] = [];
+
+        expect(tokens).toEqual(expected)
+    });
+
+    test("Get Next Tokens With Divider", () => {
+        const a = new Literal("a", "A");
+        const b = new Literal("b", "B");
+        const divider = new Literal("divider", ",");
+        const manyA = new Repeat("many-a", a, divider);
+        const parent = new And("parent", [manyA, b]);
+
+        const clonedManyA = findPattern(parent, p => p.name == "many-a");
+        let tokens = clonedManyA?.getNextTokens(clonedManyA.children[0]);
+        let expected = [",", "B"];
+
+        expect(tokens).toEqual(expected)
+
+        tokens = clonedManyA?.getNextTokens(clonedManyA.children[1]);
+        expected = ["A"];
+
+        expect(tokens).toEqual(expected)
+    });
+
+    test("Get Next Tokens Without Divider", () => {
+        const a = new Literal("a", "A");
+        const b = new Literal("b", "B");
+        const manyA = new Repeat("many-a", a);
+        const parent = new And("parent", [manyA, b]);
+
+        const clonedManyA = findPattern(parent, p => p.name == "many-a");
+        const tokens = clonedManyA?.getNextTokens(clonedManyA.children[0]);
+        const expected = ["A", "B"];
+
+        expect(tokens).toEqual(expected)
+    });
+
+    test("Get Next Pattern", () => {
+        const repeat = new Repeat("many-a", new Literal("a", "A"));
+        const nextPattern = repeat.getNextPattern();
+
+        expect(nextPattern).toBeNull()
+    });
+
+    test("Properties", () => {
+        const integer = new Repeat("integer", new Regex("digit", "\\d"));
+
+        expect(integer.type).toBe("repeat");
+        expect(integer.name).toBe("integer");
+        expect(integer.isOptional).toBeFalsy()
+        expect(integer.parent).toBeNull();
+        expect(integer.children[0].name).toBe("digit");
+    });
+
+    test("Parse Text", () => {
+        const integer = new Repeat("integer", new Regex("digit", "\\d"));
+        const { ast: result } = integer.parseText("B");
+        expect(result).toBeNull()
+    });
+});

package/src/patterns/Repeat.ts

@@ -1,87 +1,145 @@
-import Pattern from "./Pattern";
-import Node from "../ast/Node";
-import ParseError from "./ParseError";
-import Cursor from "../Cursor";
-
-export default class Repeat extends Pattern {
-  public _pattern: Pattern;
-  public _divider: Pattern;
-  public nodes: Node[] = [];
-  public cursor!: Cursor;
-  public mark: number = 0;
-  public node: Node | null = null;
-
-  constructor(
-    name: string,
-    pattern: Pattern,
-    divider?: Pattern,
-    isOptional = false
-  ) {
-    super(
-      "repeat",
-      name,
-      divider != null ? [pattern, divider] : [pattern],
-      isOptional
-    );
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { Pattern } from "./Pattern";
+import { clonePatterns } from "./clonePatterns";
+import { getNextPattern } from "./getNextPattern";
+import { findPattern } from "./findPattern";
+
+export class Repeat implements Pattern {
+  private _type: string;
+  private _name: string;
+  private _parent: Pattern | null;
+  private _children: Pattern[];
+  private _pattern: Pattern;
+  private _divider: Pattern;
+  private _isOptional: boolean;
+  private _nodes: Node[];
+  private _firstIndex: number;
+  private _shouldReduceAst: 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._isOptional;
+  }
+
+  constructor(name: string, pattern: Pattern, divider?: Pattern, isOptional = false) {
+    const patterns = divider != null ? [pattern, divider] : [pattern];
+    const children: Pattern[] = clonePatterns(patterns, false);
+    this._assignChildrenToParent(children);
 
-    this._pattern = this.children[0];
-    this._divider = this.children[1];
-    this.assertArguments();
+    this._type = "repeat";
+    this._name = name;
+    this._isOptional = isOptional;
+    this._parent = null;
+    this._children = children;
+    this._pattern = children[0];
+    this._divider = children[1];
+    this._firstIndex = -1
+    this._shouldReduceAst = false
+    this._nodes = [];
   }
 
-  private assertArguments() {
-    if (this._pattern.isOptional) {
-      throw new Error(
-        "Invalid Arguments: The pattern cannot be a optional pattern."
-      );
+  private _assignChildrenToParent(children: Pattern[]): void {
+    for (const child of children) {
+      child.parent = this;
     }
   }
 
-  private _reset(cursor: Cursor) {
-    this.nodes = [];
-    this.cursor = cursor;
-    this.mark = this.cursor.mark();
+  parseText(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor)
+
+    return {
+      ast,
+      cursor
+    };
   }
 
-  parse(cursor: Cursor) {
-    this._reset(cursor);
-    this.tryToParse();
+  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) {
+        cursor.recordMatch(this, node);
+      }
+
+      return node;
+    }
+
+    if (!this._isOptional) {
+      return null;
+    }
 
-    return this.node;
+    cursor.resolveError();
+    cursor.moveTo(this._firstIndex);
+    return null;
   }
 
-  private tryToParse() {
-    const cursor = this.safelyGetCursor();
+  private tryToParse(cursor: Cursor): boolean {
+    let passed = false;
 
     while (true) {
-      const node = this._pattern.parse(cursor);
+      const runningCursorIndex = cursor.index;
+      const repeatedNode = this._pattern.parse(cursor);
+
+      if (cursor.hasError) {
+        const lastValidNode = this.getLastValidNode();
+
+        if (lastValidNode) {
+          passed = true;
+        } else {
+          cursor.moveTo(runningCursorIndex);
+          cursor.recordErrorAt(runningCursorIndex, this._pattern);
+          passed = false;
+        }
 
-      if (cursor.hasUnresolvedError()) {
-        this.processResult();
         break;
-      } else if (node != null) {
-        this.nodes.push(node);
+      } else if (repeatedNode) {
+        this._nodes.push(repeatedNode);
 
-        if (node.endIndex === cursor.lastIndex()) {
-          this.processResult();
+        if (!cursor.hasNext()) {
+          passed = true;
           break;
         }
 
         cursor.next();
 
-        if (this._divider != null) {
-          const mark = cursor.mark();
-          const node = this._divider.parse(cursor);
+        if (this._divider) {
+          const dividerNode = this._divider.parse(cursor);
 
-          if (cursor.hasUnresolvedError()) {
-            cursor.moveToMark(mark);
-            this.processResult();
+          if (cursor.hasError) {
+            passed = true;
             break;
-          } else if (node != null) {
-            this.nodes.push(node);
+          } else if (dividerNode) {
+            this._nodes.push(dividerNode);
 
-            if (node.endIndex === cursor.lastIndex()) {
-              this.processResult();
+            if (!cursor.hasNext()) {
+              passed = true;
               break;
             }
 
@@ -90,66 +148,112 @@ export default class Repeat extends Pattern {
         }
       }
     }
-  }
 
-  private processResult() {
-    const endsOnDivider = this.nodes.length % 2 === 0;
-    const noMatch = this.nodes.length === 0;
-    const hasDivider = this._divider != null;
+    return passed;
+  }
 
-    this.cursor.resolveError();
+  private createNode(cursor: Cursor): Node | null {
+    let children: Node[] = [];
 
-    if ((hasDivider && endsOnDivider) || noMatch) {
-      if (this._isOptional) {
-        this.cursor.moveToMark(this.mark);
-      } else  {
-        const parseError = new ParseError(
-          `Did not find a repeating match of ${this.name}.`,
-          this.mark,
-          this
-        );
-        this.cursor.throwError(parseError);
-      }
-      this.node = null;
+    if (!this._divider) {
+      children = this._nodes;
     } else {
-      const value = this.nodes.map((node) => node.value).join("");
-
-      this.node = new Node(
-        "repeat",
-        this.name,
-        this.nodes[0].startIndex,
-        this.nodes[this.nodes.length - 1].endIndex,
-        this.nodes,
-        value
-      );
-
-      this.cursor.index = this.node.endIndex;
-      this.cursor.addMatch(this, this.node);
+      if (this._nodes.length % 2 !== 1) {
+        const dividerNode = this._nodes[this._nodes.length - 1];
+        cursor.moveTo(dividerNode.firstIndex);
+        children = this._nodes.slice(0, this._nodes.length - 1);
+      } else {
+        children = this._nodes;
+      }
     }
+
+    const lastIndex = children[children.length - 1].lastIndex;
+    const value = cursor.getChars(this._firstIndex, lastIndex);
+    cursor.moveTo(lastIndex);
+
+    if (this._shouldReduceAst) {
+      children = [];
+    }
+
+    return new Node(
+      "repeat",
+      this._name,
+      this._firstIndex,
+      lastIndex,
+      children,
+      this._shouldReduceAst ? value : undefined
+    );
   }
 
-  private safelyGetCursor() {
-    const cursor = this.cursor;
+  private getLastValidNode(): Node | null {
+    const nodes = this._nodes.filter((node) => node !== null);
 
-    if (cursor == null) {
-      throw new Error("Couldn't find cursor.");
+    if (nodes.length === 0) {
+      return null;
     }
-    return cursor;
+
+    return nodes[nodes.length - 1];
+  }
+
+  enableAstReduction(): void {
+    this._shouldReduceAst = true;
+  }
+
+  disableAstReduction(): void {
+    this._shouldReduceAst = false;
+  }
+
+  getTokens(): string[] {
+    return this._pattern.getTokens();
   }
 
-  clone(name?: string, isOptional?: boolean) {
-    if (name == null) {
-      name = this.name;
+  getNextTokens(lastMatched: Pattern): string[] {
+    let index = -1;
+    const tokens: string[] = [];
+
+    for (let i = 0; i < this._children.length; i++) {
+      if (this._children[i] === lastMatched) {
+        index = i;
+      }
     }
 
-    if (isOptional == null) {
-      isOptional = this._isOptional;
+    if (index === -1) {
+      return [];
     }
 
-    return new Repeat(name, this._pattern, this._divider, isOptional);
+    if (index === 0 && this._divider) {
+      tokens.push(...this._children[1].getTokens());
+
+      if (this._parent) {
+        tokens.push(...this._parent.getNextTokens(this));
+      }
+    }
+
+    if (index === 1) {
+      tokens.push(...this._children[0].getTokens());
+    }
+
+    if (index === 0 && !this._divider && this._parent) {
+      tokens.push(...this._children[0].getTokens());
+      tokens.push(...this._parent.getNextTokens(this));
+    }
+
+    return tokens;
   }
 
-  getTokens() {
-    return this._pattern.getTokens();
+  getNextPattern(): Pattern | null {
+    return getNextPattern(this)
+  }
+
+  findPattern(isMatch: (p: Pattern) => boolean): Pattern | null {
+    return findPattern(this, isMatch);
+  }
+
+  clone(name = this._name, isOptional = this._isOptional): Pattern {
+    const repeat = new Repeat(name, this._pattern, this._divider, isOptional);
+    repeat._shouldReduceAst = this._shouldReduceAst;
+
+    return repeat;
   }
 }
+

package/src/patterns/clonePatterns.ts

@@ -0,0 +1,5 @@
+import { Pattern } from "./Pattern";
+
+export function clonePatterns(patterns: Pattern[], isOptional?: boolean): Pattern[] {
+    return patterns.map(p => p.clone(p.name, isOptional))
+}

package/src/patterns/filterOutNull.ts

@@ -0,0 +1,13 @@
+import { Node } from "../ast/Node"
+
+export function filterOutNull(nodes: (Node | null)[]): Node[] {
+    const filteredNodes: Node[] = [];
+
+    for (const node of nodes) {
+        if (node !== null) {
+            filteredNodes.push(node);
+        }
+    }
+
+    return filteredNodes;
+}

package/src/patterns/findPattern.ts

@@ -0,0 +1,25 @@
+import { Pattern } from "./Pattern";
+
+export function findPattern(pattern: Pattern, predicate: (pattern: Pattern) => boolean): Pattern | null {
+    let children: Pattern[] = [];
+
+    if (pattern.type === "reference") {
+        children = [];
+    } else {
+        children = pattern.children;
+    }
+
+    for (const child of children) {
+        const result = findPattern(child, predicate);
+
+        if (result !== null) {
+            return result;
+        }
+    }
+
+    if (predicate(pattern)) {
+        return pattern;
+    } else {
+        return null;
+    }
+}

package/src/patterns/getNextPattern.test.ts

@@ -0,0 +1,39 @@
+import { And } from "./And";
+import { findPattern } from "./findPattern";
+import { Literal } from "./Literal";
+
+describe("getNextPatter", ()=>{
+    test("No Parent", ()=>{
+        const a = new Literal("a", "A");
+        const nextPattern = a.getNextPattern();
+
+        expect(nextPattern).toBe(null);
+    });
+
+    test("No Next Sibling", ()=>{
+        const a = new Literal("a", "A");
+        const parent = new And("parent", [a]);
+        const nextPattern = parent.children[0].getNextPattern();
+
+        expect(nextPattern).toBe(null);
+    });
+
+    test("Get Parents Sibling", ()=>{
+        const a = new Literal("a", "A");
+        const parent = new And("parent", [a]);
+        const grandParent = new And("grand-parent", [parent]);
+        const clonedA = findPattern(grandParent, p=>p.name === "a");
+        const nextPattern = clonedA?.getNextPattern();
+
+        expect(nextPattern).toBe(null);
+    });
+
+    test("Get Sibling", ()=>{
+        const a = new Literal("a", "A");
+        const b = new Literal("b", "B");
+        const parent = new And("parent", [a, b]);
+
+        const nextPattern = parent.children[0].getNextPattern();
+        expect(nextPattern?.name).toBe("b");
+    });
+});

package/src/patterns/getNextPattern.ts

@@ -0,0 +1,18 @@
+import { Pattern } from "./Pattern";
+
+export function getNextPattern(pattern: Pattern): Pattern | null {
+    const parent = pattern.parent;
+
+    if (parent == null) {
+        return null;
+    }
+
+    const patternIndex = parent.children.indexOf(pattern);
+    const nextPattern = parent.children[patternIndex + 1] || null;
+
+    if (nextPattern == null) {
+        return parent.getNextPattern();
+    }
+
+    return nextPattern;
+}