clarity-pattern-parser 6.0.0 → 7.0.0

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");
@@ -132,13 +132,22 @@ describe("Literal", () => {
         expect(tokens.length).toBe(0);
     });
 
+    test("Get Patterns", () => {
+        const a = new Literal("a", "A");
+
+        const tokens = a.getPatterns();
+        const expectedTokens = [a];
+
+        expect(tokens).toEqual(expectedTokens);
+    });
+
     test("Get Next Patterns", () => {
         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);
     });
@@ -159,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

@@ -151,6 +151,10 @@ export class Literal implements Pattern {
     return this.parent.getTokensAfter(this);
   }
 
+  getPatterns(): Pattern[] {
+    return [this];
+  }
+
   getPatternsAfter(): Pattern[] {
     return []
   }
@@ -163,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;
   }
 

package/src/patterns/Not.test.ts

@@ -88,7 +88,7 @@ describe("Not", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
         const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
 
-        const cloneNotAboutUs = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
+        const cloneNotAboutUs = sequence.find(p => p.name === "not-about-us") as Pattern;
         const nextTokens = cloneNotAboutUs.getNextTokens() || [];
 
         expect(nextTokens[0]).toBe("About Them");
@@ -105,7 +105,7 @@ describe("Not", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
         const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
 
-        const cloneNotAboutUs = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
+        const cloneNotAboutUs = sequence.find(p => p.name === "not-about-us") as Pattern;
         const nextTokens = cloneNotAboutUs.getTokens() || [];
 
         expect(nextTokens[0]).toBe("About Them");
@@ -114,8 +114,8 @@ describe("Not", () => {
     test("Get Tokens After", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
         const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
-        const notAboutUsClone = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
-        const aboutUsClone = sequence.findPattern(p => p.name === "about-us") as Pattern;
+        const notAboutUsClone = sequence.find(p => p.name === "not-about-us") as Pattern;
+        const aboutUsClone = sequence.find(p => p.name === "about-us") as Pattern;
         const nextTokens = notAboutUsClone.getTokensAfter(aboutUsClone) || [];
 
         expect(nextTokens[0]).toBe("About Them");
@@ -123,16 +123,27 @@ describe("Not", () => {
 
     test("Find Pattern", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
-        const child = notAboutUs.findPattern(p => p.name === "about-us")
+        const child = notAboutUs.find(p => p.name === "about-us")
 
         expect(child).not.toBeNull();
     });
 
+    test("Get Patterns", () => {
+        const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
+        const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
+
+        const cloneNotAboutUs = sequence.find(p => p.name === "not-about-us") as Pattern;
+        const nextPatterns = cloneNotAboutUs.getPatterns();
+        const expected = [sequence.find(p=>p.name === "about-them")];
+
+        expect(nextPatterns).toEqual(expected);
+    });
+
     test("Get Next Patterns", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
         const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
 
-        const cloneNotAboutUs = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
+        const cloneNotAboutUs = sequence.find(p => p.name === "not-about-us") as Pattern;
         const patterns = cloneNotAboutUs.getNextPatterns() || [];
 
         expect(patterns.length).toBe(1);
@@ -149,8 +160,8 @@ describe("Not", () => {
     test("Get Patterns After", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
         const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
-        const notAboutUsClone = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
-        const aboutUsClone = sequence.findPattern(p => p.name === "about-us") as Pattern;
+        const notAboutUsClone = sequence.find(p => p.name === "not-about-us") as Pattern;
+        const aboutUsClone = sequence.find(p => p.name === "about-us") as Pattern;
         const patterns = notAboutUsClone.getPatternsAfter(aboutUsClone) || [];
 
         expect(patterns.length).toBe(1);
@@ -159,7 +170,7 @@ describe("Not", () => {
 
     test("Get Patterns After With Null Parent", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
-        const aboutUsClone = notAboutUs.findPattern(p => p.name === "about-us") as Pattern;
+        const aboutUsClone = notAboutUs.find(p => p.name === "about-us") as Pattern;
         const patterns = notAboutUs.getPatternsAfter(aboutUsClone) || [];
 
         expect(patterns.length).toBe(0);

package/src/patterns/Not.ts

@@ -106,6 +106,10 @@ export class Not implements Pattern {
     return this.parent.getTokensAfter(this);
   }
 
+  getPatterns(): Pattern[] {
+    return [...this.getNextPatterns().map(p => p.getPatterns()).flat()];
+  }
+
   getPatternsAfter(_childReference: Pattern): Pattern[] {
     const parent = this._parent;
 
@@ -124,7 +128,7 @@ export class Not implements Pattern {
     return this.parent.getPatternsAfter(this)
   }
 
-  findPattern(predicate: (p: Pattern) => boolean): Pattern | null {
+  find(predicate: (p: Pattern) => boolean): Pattern | null {
     return predicate(this._children[0]) ? this._children[0] : null;
   }
 

package/src/patterns/Or.test.ts

@@ -118,7 +118,7 @@ describe("Or", () => {
             new Literal("c", "C")
         ]);
 
-        const orClone = sequence.findPattern(p => p.name === "a-or-b") as Pattern;
+        const orClone = sequence.find(p => p.name === "a-or-b") as Pattern;
         const tokens = orClone.getNextTokens();
 
         expect(tokens.length).toBe(1);
@@ -145,14 +145,25 @@ describe("Or", () => {
             new Literal("c", "C")
         ]);
 
-        const aClone = sequence.findPattern(p => p.name === "a") as Pattern;
-        const orClone = sequence.findPattern(p => p.name === "a-or-b") as Pattern;
+        const aClone = sequence.find(p => p.name === "a") as Pattern;
+        const orClone = sequence.find(p => p.name === "a-or-b") as Pattern;
         const tokens = orClone.getTokensAfter(aClone);
 
         expect(tokens.length).toBe(1);
         expect(tokens[0]).toBe("C");
     });
 
+    test("Get Patterns", () => {
+        const aOrB = new Or("a-b", [new Literal("a", "A"), new Literal("b", "B")]);
+        const patterns = aOrB.getPatterns();
+        const expected = [
+            aOrB.find(p => p.name === "a"),
+            aOrB.find(p => p.name === "b")
+        ];
+
+        expect(patterns).toEqual(expected);
+    });
+
     test("Get Patterns After", () => {
         const sequence = new And("sequence", [
             new Or("a-or-b", [
@@ -162,8 +173,8 @@ describe("Or", () => {
             new Literal("c", "C")
         ]);
 
-        const aClone = sequence.findPattern(p => p.name === "a") as Pattern;
-        const orClone = sequence.findPattern(p => p.name === "a-or-b") as Pattern;
+        const aClone = sequence.find(p => p.name === "a") as Pattern;
+        const orClone = sequence.find(p => p.name === "a-or-b") as Pattern;
         const patterns = orClone.getPatternsAfter(aClone);
 
         expect(patterns.length).toBe(1);
@@ -175,7 +186,7 @@ describe("Or", () => {
             new Literal("a", "A"),
             new Literal("b", "B")
         ])
-        const aClone = or.findPattern(p => p.name === "a") as Pattern;
+        const aClone = or.find(p => p.name === "a") as Pattern;
         const patterns = or.getPatternsAfter(aClone);
 
         expect(patterns.length).toBe(0);
@@ -190,7 +201,7 @@ describe("Or", () => {
             new Literal("c", "C")
         ]);
 
-        const orClone = sequence.findPattern(p => p.name === "a-or-b") as Pattern;
+        const orClone = sequence.find(p => p.name === "a-or-b") as Pattern;
         const patterns = orClone.getNextPatterns();
 
         expect(patterns.length).toBe(1);

package/src/patterns/Or.ts

@@ -136,6 +136,16 @@ export class Or implements Pattern {
     return this._parent.getTokensAfter(this);
   }
 
+  getPatterns(): Pattern[] {
+    const patterns: Pattern[] = [];
+
+    for (const pattern of this._children) {
+      patterns.push(...pattern.getPatterns());
+    }
+
+    return patterns;
+  }
+
   getPatternsAfter(_childReference: Pattern): Pattern[] {
     if (this._parent === null) {
       return [];
@@ -152,7 +162,7 @@ export class Or implements Pattern {
     return this.parent.getPatternsAfter(this)
   }
 
-  findPattern(predicate: (p: Pattern) => boolean): Pattern | null {
+  find(predicate: (p: Pattern) => boolean): Pattern | null {
     return findPattern(this, predicate);
   }
 

package/src/patterns/Pattern.ts

@@ -15,8 +15,9 @@ export interface Pattern {
   clone(name?: string, isOptional?: boolean): Pattern;
   getTokens(): string[];
   getTokensAfter(childReference: Pattern): string[];
+  getNextTokens(): string[];
+  getPatterns(): Pattern[];
   getPatternsAfter(childReference: Pattern): Pattern[];
   getNextPatterns(): Pattern[];
-  getNextTokens(): string[];
-  findPattern(predicate: (p: Pattern) => boolean): Pattern | null;
+  find(predicate: (p: Pattern) => boolean): Pattern | null;
 }

package/src/patterns/Reference.test.ts

@@ -19,7 +19,7 @@ function createValuePattern() {
     divider.setTokens([", "]);
 
     const valueRef = new Reference("value");
-    const values = new Repeat("values", valueRef, divider);
+    const values = new Repeat("values", valueRef, { divider });
     const array = new And("array", [openBracket, values, closeBracket]);
     const value = new Or("value", [number, array]);
 
@@ -34,7 +34,7 @@ describe("Reference", () => {
 
         const expected = new Node("and", "array", 0, 5, [
             new Node("literal", "open-bracket", 0, 0, [], "["),
-            new Node("repeat", "values", 1, 4, [
+            new Node("infinite-repeat", "values", 1, 4, [
                 new Node("regex", "number", 1, 1, [], "1"),
                 new Node("regex", "divider", 2, 3, [], ", "),
                 new Node("regex", "number", 4, 4, [], "2")
@@ -114,9 +114,9 @@ describe("Reference", () => {
 
     test("Find Pattern", () => {
         const value = createValuePattern();
-        const reference = value.findPattern(p => p.type === "reference") as Pattern;
+        const reference = value.find(p => p.type === "reference") as Pattern;
 
-        const pattern = reference?.findPattern(p => p.name === "Nada");
+        const pattern = reference?.find(p => p.name === "Nada");
 
         expect(pattern).toBe(null);
     });
@@ -124,7 +124,7 @@ describe("Reference", () => {
 
     test("Get Next Tokens", () => {
         const value = createValuePattern();
-        const reference = value.findPattern(p => p.type === "reference") as Pattern;
+        const reference = value.find(p => p.type === "reference") as Pattern;
         const tokens = reference.getNextTokens();
 
         expect(tokens).toEqual([", ", "]"]);
@@ -139,7 +139,7 @@ describe("Reference", () => {
 
     test("Get Tokens After", () => {
         const value = createValuePattern();
-        const reference = value.findPattern(p => p.type === "reference") as Pattern;
+        const reference = value.find(p => p.type === "reference") as Pattern;
         const tokens = reference.getTokensAfter(new Literal("bogus", "Bogus"));
 
         expect(tokens).toEqual([", ", "]"]);
@@ -152,9 +152,19 @@ describe("Reference", () => {
         expect(tokens).toEqual([])
     });
 
+    test("Get Patterns", () => {
+        const value = createValuePattern();
+        const ref = findPattern(value, (p) => p.type === "reference");
+        const patterns = ref?.getPatterns() || [];
+
+        expect(patterns.length).toBe(2);
+        expect(patterns[0].name).toBe("number");
+        expect(patterns[1].name).toBe("open-bracket");
+    });
+
     test("Get Patterns After", () => {
         const value = createValuePattern();
-        const reference = value.findPattern(p => p.type === "reference") as Pattern;
+        const reference = value.find(p => p.type === "reference") as Pattern;
         const patterns = reference.getPatternsAfter(new Literal("bogus", "Bogus"));
 
         expect(patterns.length).toEqual(2);
@@ -173,7 +183,7 @@ describe("Reference", () => {
 
     test("Get Next Patterns", () => {
         const value = createValuePattern();
-        const reference = value.findPattern(p => p.type === "reference") as Pattern;
+        const reference = value.find(p => p.type === "reference") as Pattern;
         const patterns = reference.getNextPatterns();
 
         expect(patterns.length).toEqual(2);

package/src/patterns/Reference.ts

@@ -127,6 +127,10 @@ export class Reference implements Pattern {
     return this.parent.getTokensAfter(this);
   }
 
+  getPatterns(): Pattern[] {
+    return this._getPatternSafely().getPatterns();
+  }
+
   getPatternsAfter(_childReference: Pattern): Pattern[] {
     if (this._parent == null) {
       return [];
@@ -143,7 +147,7 @@ export class Reference implements Pattern {
     return this.parent.getPatternsAfter(this)
   }
 
-  findPattern(_predicate: (p: Pattern) => boolean): Pattern | null {
+  find(_predicate: (p: Pattern) => boolean): Pattern | null {
     return null;
   }