clarity-pattern-parser 3.0.16 → 4.0.1

package/src/patterns/Or.ts

@@ -0,0 +1,132 @@
+import Pattern from "./Pattern";
+import ParseError from "./ParseError";
+import Cursor from "../Cursor";
+import Node from "../ast/Node";
+
+export default class Or extends Pattern {
+  public patternIndex: number = 0;
+  public errors: ParseError[] = [];
+  public node: Node | null = null;
+  public cursor: Cursor | null = null;
+  public mark: number = 0;
+  public parseError: ParseError | null = null;
+
+  constructor(name: string, patterns: Pattern[], isOptional = false) {
+    super("or", name, patterns, isOptional);
+    this.assertArguments();
+  }
+
+  private assertArguments() {
+    if (this._children.length < 2) {
+      throw new Error(
+        "Invalid Argument: OrValue needs to have more than one value pattern."
+      );
+    }
+
+    const hasOptionalChildren = this._children.some(
+      (pattern) => pattern.isOptional
+    );
+
+    if (hasOptionalChildren) {
+      throw new Error("OrValues cannot have optional patterns.");
+    }
+  }
+
+  private resetState(cursor: Cursor) {
+    this.patternIndex = 0;
+    this.errors = [];
+    this.node = null;
+    this.cursor = cursor;
+    this.mark = cursor.mark();
+  }
+
+  private safelyGetCursor() {
+    const cursor = this.cursor;
+
+    if (cursor == null) {
+      throw new Error("Couldn't find cursor.");
+    }
+    return cursor;
+  }
+
+  parse(cursor: Cursor) {
+    this.resetState(cursor);
+    this.tryToParse();
+
+    return this.node;
+  }
+
+  private tryToParse() {
+    const cursor = this.safelyGetCursor();
+
+    while (true) {
+      const pattern = this._children[this.patternIndex];
+      const node = pattern.parse(cursor);
+      const hasError = cursor.hasUnresolvedError();
+
+      if (hasError) {
+        const shouldBreak = this.processError();
+        if (shouldBreak) {
+          break;
+        }
+      } else if (node != null) {
+        this.processResult(node);
+        break;
+      }
+    }
+  }
+
+  private processError() {
+    const cursor = this.safelyGetCursor();
+    const isLastPattern = this.patternIndex + 1 === this._children.length;
+
+    if (!isLastPattern) {
+      this.patternIndex++;
+      cursor.resolveError();
+      cursor.moveToMark(this.mark);
+      return false;
+    } else {
+      if (this._isOptional) {
+        cursor.resolveError();
+        cursor.moveToMark(this.mark);
+      }
+      this.node = null;
+      return true;
+    }
+  }
+
+  private processResult(node: Node) {
+    const cursor = this.safelyGetCursor();
+
+    this.node = new Node(
+      "or",
+      this.name,
+      node.startIndex,
+      node.endIndex,
+      [node],
+      node.value
+    );
+
+    cursor.index = this.node.endIndex;
+    cursor.addMatch(this, this.node);
+  }
+
+  clone(name?: string, isOptional?: boolean) {
+    if (name == null) {
+      name = this.name;
+    }
+
+    if (isOptional == null) {
+      isOptional = this._isOptional;
+    }
+
+    return new Or(name, this._children, isOptional);
+  }
+
+  getTokens() {
+    return this._children.reduce<string[]>(
+      (acc, c) => acc.concat(c.getTokens()),
+      []
+    );
+  }
+}

package/src/patterns/Pattern.ts

@@ -6,27 +6,26 @@ export default abstract class Pattern {
   protected _name: string;
   protected _children: Pattern[];
   protected _parent: Pattern | null;
-  public isSequence: boolean;
+  protected _isOptional = false;
 
-  constructor(type: string = "", name: string, children: Pattern[] = []) {
+  get isOptional() {
+    return this._isOptional;
+  }
+
+  constructor(
+    type: string,
+    name: string,
+    children: Pattern[] = [],
+    isOptional = false
+  ) {
     this._type = type;
     this._name = name;
     this._children = [];
     this._parent = null;
-    this.isSequence = false;
-
-    this._assertName();
+    this._isOptional = isOptional;
     this.children = children;
   }
 
-  private _assertName() {
-    if (typeof this.name !== "string") {
-      throw new Error(
-        "Invalid Argument: Patterns needs to have a name that's a string."
-      );
-    }
-  }
-
   abstract parse(cursor: Cursor): Node | null;
 
   exec(text: string) {
@@ -57,9 +56,7 @@ export default abstract class Pattern {
   }
 
   set parent(value: Pattern | null) {
-    if (value instanceof Pattern) {
-      this._parent = value;
-    }
+    this._parent = value;
   }
 
   get children() {
@@ -68,38 +65,17 @@ export default abstract class Pattern {
 
   set children(value) {
     this._children = value;
-    this._cloneChildren();
-    this._assertChildren();
-    this._assignAsParent();
-  }
-
-  protected _assertChildren() {
-    // Empty,can be overridden by subclasses.
-  }
-
-  private _cloneChildren() {
-    // We need to clone the patterns so nested patterns can be parsed.
-    this._children = this._children.map((pattern) => {
-      if (!(pattern instanceof Pattern)) {
-        throw new Error(
-          `The ${this.name} pattern has an invalid child pattern.`
-        );
-      }
-      return pattern.clone();
-    });
-
-    // We need to freeze the children so they aren't modified.
-    Object.freeze(this._children);
-  }
-
-  private _assignAsParent() {
-    this._children.forEach((child) => (child.parent = this));
+    this.cloneChildren();
+    this.assignAsParent();
   }
 
   abstract clone(name?: string): Pattern;
-
   abstract getTokens(): string[];
 
+  getTokenValue(): string | null {
+    return null;
+  }
+
   getNextTokens(): string[] {
     const parent = this._parent;
 
@@ -124,14 +100,14 @@ export default abstract class Pattern {
       if (
         this._parent?.type?.indexOf("and") === 0 &&
         nextSibling != null &&
-        nextSibling?.type?.indexOf("optional") === 0
+        nextSibling.isOptional
       ) {
         let tokens: string[] = [];
 
         for (let x = index + 1; x < siblings.length; x++) {
           const child = siblings[x];
 
-          if (child.type.indexOf("optional") === 0) {
+          if (child.isOptional) {
             tokens = tokens.concat(child.getTokens());
           } else {
             tokens = tokens.concat(child.getTokens());
@@ -161,7 +137,15 @@ export default abstract class Pattern {
     return [];
   }
 
-  getTokenValue(): string | null {
-    return null;
+  private cloneChildren() {
+    this._children = this._children.map((pattern) => {
+      return pattern.clone();
+    });
+
+    Object.freeze(this._children);
+  }
+
+  private assignAsParent() {
+    this._children.forEach((child) => (child.parent = this));
   }
 }

package/src/patterns/Recursive.ts

@@ -0,0 +1,92 @@
+import Pattern from "./Pattern";
+import ParserError from "./ParseError";
+import Cursor from "../Cursor";
+
+export default class Recursive extends Pattern {
+  public isRecursing: boolean;
+  public pattern: Pattern | null = null;
+
+  constructor(name: string, isOptional = false) {
+    super("recursive", name, [], isOptional);
+    this.isRecursing = false;
+  }
+
+  getPattern() {
+    return this.climb(this.parent, (pattern: Pattern | null) => {
+      if (pattern == null) {
+        return false;
+      }
+      return (
+        pattern.type !== "recursive" &&
+        pattern.name === this.name
+      );
+    });
+  }
+
+  private climb(
+    pattern: Pattern | null,
+    isMatch: (pattern: Pattern | null) => boolean
+  ): Pattern | null {
+    if (isMatch(pattern)) {
+      return pattern;
+    } else {
+      if (pattern && pattern.parent != null) {
+        return this.climb(pattern.parent, isMatch);
+      }
+      return null;
+    }
+  }
+
+  parse(cursor: Cursor) {
+    if (this.pattern == null) {
+      const pattern = this.getPattern();
+
+      if (pattern == null) {
+        if (!this._isOptional) {
+          cursor.throwError(
+            new ParserError(
+              `Couldn't find parent pattern to recursively parse, with the name ${this.name}.`,
+              cursor.index,
+              this
+            )
+          );
+        }
+
+        return null;
+      }
+
+      this.pattern = pattern.clone();
+      this.pattern.parent = this;
+    }
+
+    const mark = cursor.mark();
+    const node = this.pattern.parse(cursor);
+
+    if (!cursor.hasUnresolvedError() && node != null) {
+      cursor.addMatch(this, node);
+    }
+
+    if (cursor.hasUnresolvedError() && this._isOptional) {
+      cursor.resolveError();
+      cursor.moveToMark(mark);
+    }
+
+    return node;
+  }
+
+  clone(name?: string, isOptional?: boolean) {
+    if (name == null) {
+      name = this.name;
+    }
+
+    if (isOptional == null) {
+      isOptional = this._isOptional;
+    }
+
+    return new Recursive(name, isOptional);
+  }
+
+  getTokens() {
+    return this.getPattern()?.getTokens() || [];
+  }
+}

package/src/patterns/{ReferencePattern.ts → Reference.ts}

@@ -2,12 +2,9 @@ import Pattern from "./Pattern";
 import ParserError from "./ParseError";
 import Cursor from "../Cursor";
 
-export default class ReferencePattern extends Pattern {
-  private isRecursing: boolean;
-
-  constructor(name: string) {
-    super("reference", name);
-    this.isRecursing = false;
+export default class Reference extends Pattern {
+  constructor(name: string, isOptional = false) {
+    super("reference", name, [], isOptional);
   }
 
   private getRoot() {
@@ -61,6 +58,8 @@ export default class ReferencePattern extends Pattern {
   }
 
   parse(cursor: Cursor) {
+    const mark = cursor.mark();
+
     try {
       const node = this.safelyGetPattern().parse(cursor);
 
@@ -68,29 +67,39 @@ export default class ReferencePattern extends Pattern {
         cursor.addMatch(this, node);
       }
 
+      if (cursor.hasUnresolvedError() && this._isOptional) {
+        cursor.resolveError();
+        cursor.moveToMark(mark);
+      }
+
       return node;
     } catch (error) {
-      cursor.throwError(
-        new ParserError(
-          `Couldn't find reference pattern to parse, with the name ${this.name}.`,
-          cursor.index,
-          this as Pattern
-        )
-      );
+      if (this._isOptional) {
+        cursor.moveToMark(mark);
+      } else {
+        cursor.throwError(
+          new ParserError(
+            `Couldn't find reference pattern to parse, with the name ${this.name}.`,
+            cursor.index,
+            this as Pattern
+          )
+        );
+      }
 
       return null;
     }
   }
 
-  clone(name?: string): Pattern {
-    if (typeof name !== "string") {
+  clone(name?: string, isOptional?: boolean) {
+    if (name == null) {
       name = this.name;
     }
-    return new ReferencePattern(name);
-  }
 
-  getTokenValue() {
-    return this.safelyGetPattern().getTokenValue();
+    if (isOptional == null) {
+      isOptional = this._isOptional;
+    }
+
+    return new Reference(name, isOptional);
   }
 
   private safelyGetPattern() {
@@ -105,19 +114,14 @@ export default class ReferencePattern extends Pattern {
         );
       }
 
-      return reference;
+      pattern = reference;
+      this.children = [pattern];
     }
+
     return pattern;
   }
 
   getTokens() {
-    if (!this.isRecursing) {
-      this.isRecursing = true;
-      let pattern = this.safelyGetPattern();
-      const tokens = pattern.getTokens();
-      this.isRecursing = false;
-      return tokens;
-    }
-    return [];
+    return this.safelyGetPattern().getTokens();
   }
 }

package/src/patterns/Regex.ts

@@ -0,0 +1,123 @@
+import ParseError from "./ParseError";
+import Node from "../ast/Node";
+import Pattern from "./Pattern";
+import Cursor from "../Cursor";
+
+export default class Regex extends Pattern {
+  private regexString: string;
+  private regex: RegExp;
+  private node: Node | null = null;
+  private cursor: Cursor | null = null;
+  private substring: string = "";
+
+  constructor(name: string, regex: string, isOptional = false) {
+    super("regex", name, [], isOptional);
+    this.regexString = regex;
+    this.regex = new RegExp(`^${regex}`, "g");
+    this.assertArguments();
+  }
+
+  private assertArguments() {
+    if (this.regexString.length < 1) {
+      throw new Error(
+        "Invalid Arguments: The regex string argument needs to be at least one character long."
+      );
+    }
+
+    if (this.regexString.charAt(0) === "^") {
+      throw new Error(
+        "Invalid Arguments: The regex string cannot start with a '^' because it is expected to be in the middle of a string."
+      );
+    }
+
+    if (this.regexString.charAt(this.regexString.length - 1) === "$") {
+      throw new Error(
+        "Invalid Arguments: The regex string cannot end with a '$' because it is expected to be in the middle of a string."
+      );
+    }
+  }
+
+  parse(cursor: Cursor) {
+    this.resetState(cursor);
+    this.tryToParse();
+
+    return this.node;
+  }
+
+  private resetState(cursor: Cursor) {
+    this.cursor = cursor;
+    this.regex.lastIndex = 0;
+    this.substring = this.cursor.text.substr(this.cursor.getIndex());
+    this.node = null;
+  }
+
+  private tryToParse() {
+    const result = this.regex.exec(this.substring);
+
+    if (result != null && result.index === 0) {
+      this.processResult(result);
+    } else {
+      this.processError();
+    }
+  }
+
+  private processResult(result: RegExpExecArray) {
+    const cursor = this.safelyGetCursor();
+    const currentIndex = cursor.getIndex();
+    const newIndex = currentIndex + result[0].length - 1;
+
+    this.node = new Node(
+      "regex",
+      this.name,
+      currentIndex,
+      newIndex,
+      [],
+      result[0]
+    );
+
+    cursor.moveToMark(newIndex);
+    cursor.addMatch(this, this.node);
+  }
+
+  private processError() {
+    const cursor = this.safelyGetCursor();
+
+    if (!this._isOptional) {
+      const message = `ParseError: Expected regex pattern of '${this.regexString}' but found '${this.substring}'.`;
+      const parseError = new ParseError(message, cursor.getIndex(), this);
+
+      cursor.throwError(parseError);
+    }
+
+    this.node = null;
+  }
+
+  private safelyGetCursor() {
+    const cursor = this.cursor;
+
+    if (cursor == null) {
+      throw new Error("Couldn't find cursor.");
+    }
+    return cursor;
+  }
+
+  clone(name?: string, isOptional?: boolean) {
+    if (name == null) {
+      name = this.name;
+    }
+
+    if (isOptional == null) {
+      isOptional = this._isOptional;
+    }
+
+    return new Regex(name, this.regexString, isOptional);
+  }
+
+  getTokenValue() {
+    return this.name;
+  }
+
+  getTokens() {
+    return [this.name];
+  }
+}