clarity-pattern-parser 6.0.0 → 7.0.0

package/src/patterns/Repeat.ts

@@ -1,272 +1,141 @@
 import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
+import { FiniteRepeat } from "./FiniteRepeat";
+import { InfiniteRepeat } from "./InfiniteRepeat";
+import { ParseResult } from "./ParseResult";
 import { Pattern } from "./Pattern";
-import { clonePatterns } from "./clonePatterns";
-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;
-
-  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);
+export interface RepeatOptions {
+    min?: number;
+    max?: number;
+    divider?: Pattern;
+    trimDivider?: boolean;
+}
 
-    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._nodes = [];
-  }
+interface InternalRepeatOptions {
+    min: number;
+    max: number;
+    divider?: Pattern;
+}
 
-  private _assignChildrenToParent(children: Pattern[]): void {
-    for (const child of children) {
-      child.parent = this;
+export class Repeat implements Pattern {
+    private _repeatPattern: InfiniteRepeat | FiniteRepeat;
+    private _parent: Pattern | null;
+    private _pattern: Pattern;
+    private _options: InternalRepeatOptions;
+    private _children: Pattern[];
+
+    get type() {
+        return this._repeatPattern.type;
     }
-  }
-
-  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.recordMatch(this, node);
-      }
-
-      return node;
+    get name() {
+        return this._repeatPattern.name;
     }
 
-    if (!this._isOptional) {
-      return null;
+    get parent() {
+        return this._parent;
     }
 
-    cursor.resolveError();
-    cursor.moveTo(this._firstIndex);
-    return null;
-  }
-
-  private tryToParse(cursor: Cursor): boolean {
-    let passed = false;
+    set parent(value: Pattern | null) {
+        this._parent = value;
+    }
 
-    while (true) {
-      const runningCursorIndex = cursor.index;
-      const repeatedNode = this._pattern.parse(cursor);
+    get children() {
+        return this._children;
+    }
 
-      if (cursor.hasError) {
-        const lastValidNode = this.getLastValidNode();
+    get isOptional() {
+        return this._repeatPattern.isOptional;
+    }
 
-        if (lastValidNode != null) {
-          passed = true;
+    constructor(name: string, pattern: Pattern, options: RepeatOptions = {}) {
+        this._pattern = pattern;
+        this._parent = null;
+        this._options = {
+            ...options,
+            min: options.min == null ? 1 : options.min,
+            max: options.max == null ? Infinity : options.max
+        };
+
+        if (this._options.max != Infinity) {
+            this._repeatPattern = new FiniteRepeat(name, pattern, this._options.max, this._options);
         } else {
-          cursor.moveTo(runningCursorIndex);
-          cursor.recordErrorAt(runningCursorIndex, this._pattern);
-          passed = false;
+            this._repeatPattern = new InfiniteRepeat(name, pattern, this._options)
         }
 
-        break;
-      } else if (repeatedNode) {
-        this._nodes.push(repeatedNode);
+        this._children = [this._repeatPattern]
+        this._repeatPattern.parent = this;
+    }
 
-        if (!cursor.hasNext()) {
-          passed = true;
-          break;
-        }
+    parse(cursor: Cursor): Node | null {
+        return this._repeatPattern.parse(cursor);
+    }
 
-        cursor.next();
+    exec(text: string): ParseResult {
+        return this._repeatPattern.exec(text);
+    }
 
-        if (this._divider != null) {
-          const dividerNode = this._divider.parse(cursor);
+    test(text: string): boolean {
+        return this._repeatPattern.test(text);
+    }
 
-          if (cursor.hasError) {
-            passed = true;
-            break;
-          } else if (dividerNode != null) {
-            this._nodes.push(dividerNode);
+    clone(name = this.name, isOptional?: boolean) {
+        let min = this._options.min;
 
-            if (!cursor.hasNext()) {
-              passed = true;
-              break;
+        if (isOptional != null) {
+            if (isOptional) {
+                min = 0
+            } else {
+                min = Math.max(this._options.min, 1);
             }
-
-            cursor.next();
-          }
         }
-      }
-    }
-
-    return passed;
-  }
-
-  private createNode(cursor: Cursor): Node | null {
-    let children: Node[] = [];
 
-    if (!this._divider) {
-      children = this._nodes;
-    } else {
-      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;
-      }
+        return new Repeat(name, this._pattern, { ...this._options, min });
     }
 
-    const lastIndex = children[children.length - 1].lastIndex;
-    const value = cursor.getChars(this._firstIndex, lastIndex);
-    cursor.moveTo(lastIndex);
-
-    return new Node(
-      "repeat",
-      this._name,
-      this._firstIndex,
-      lastIndex,
-      children,
-      undefined
-    );
-  }
-
-  private getLastValidNode(): Node | null {
-    const nodes = this._nodes.filter((node) => node !== null);
-
-    if (nodes.length === 0) {
-      return null;
+    getTokens(): string[] {
+        return this._repeatPattern.getTokens();
     }
 
-    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;
-  }
+    getTokensAfter(_childReference: Pattern): string[] {
+        if (this._parent == null) {
+            return []
+        }
 
-  getNextTokens(): string[] {
-    if (this.parent == null) {
-      return []
+        return this._parent.getTokensAfter(this);
     }
 
-    return this.parent.getTokensAfter(this);
-  }
-
-  getPatternsAfter(childReference: Pattern): Pattern[] {
-    let index = -1;
-    const patterns: Pattern[] = [];
+    getNextTokens(): string[] {
+        if (this._parent == null) {
+            return []
+        }
 
-    for (let i = 0; i < this._children.length; i++) {
-      if (this._children[i] === childReference) {
-        index = i;
-      }
+        return this._parent.getTokensAfter(this);
     }
 
-    // If the last match isn't a child of this pattern.
-    if (index === -1) {
-      return [];
+    getPatterns(): Pattern[] {
+        return this._repeatPattern.getPatterns();
     }
 
-    // If the last match was the repeated patterns, then suggest the divider.
-    if (index === 0 && this._divider) {
-      patterns.push(this._children[1]);
+    getPatternsAfter(_childReference: Pattern): Pattern[] {
+        if (this._parent == null) {
+            return []
+        }
 
-      if (this._parent) {
-        patterns.push(...this._parent.getPatternsAfter(this));
-      }
+        return this._parent.getPatternsAfter(this);
     }
 
-    // Suggest the pattern because the divider was the last match.
-    if (index === 1) {
-      patterns.push(this._children[0]);
-    }
+    getNextPatterns(): Pattern[] {
+        if (this._parent == null) {
+            return []
+        }
 
-    if (index === 0 && !this._divider && this._parent) {
-      patterns.push(this._children[0]);
-      patterns.push(...this._parent.getPatternsAfter(this));
+        return this._parent.getPatternsAfter(this);
     }
 
-    return patterns;
-  }
-
-  getNextPatterns(): Pattern[] {
-    if (this.parent == null) {
-      return [];
+    find(predicate: (p: Pattern) => boolean): Pattern | null {
+        return this._repeatPattern.find(predicate);
     }
 
-    return this.parent.getPatternsAfter(this)
-  }
-
-  findPattern(predicate: (p: Pattern) => boolean): Pattern | null {
-    return findPattern(this, predicate);
-  }
-
-  clone(name = this._name, isOptional = this._isOptional): Pattern {
-    return new Repeat(name, this._pattern, this._divider, isOptional);
-  }
-}
-
+}