clarity-pattern-parser 4.0.2 → 5.0.0

package/src/patterns/Reference.ts

@@ -1,127 +1,127 @@
-import Pattern from "./Pattern";
-import ParserError from "./ParseError";
-import Cursor from "../Cursor";
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { Pattern } from "./Pattern";
+import { findPattern } from "./findPattern";
+import { getNextPattern } from "./getNextPattern";
+
+export class Reference implements Pattern {
+  private _type: string;
+  private _name: string;
+  private _parent: Pattern | null;
+  private _isOptional: boolean;
+  private _pattern: Pattern | null;
+  private _children: Pattern[];
+
+  get type(): string {
+    return this._type;
+  }
 
-export default class Reference extends Pattern {
-  constructor(name: string, isOptional = false) {
-    super("reference", name, [], isOptional);
+  get name(): string {
+    return this._name;
   }
 
-  private getRoot() {
-    let node = this.parent;
-    while (node != null) {
-      if (node.parent == null) {
-        return node;
-      }
-      node = node.parent;
-    }
-    return node;
+  get isOptional(): boolean {
+    return this._isOptional;
   }
 
-  private findPattern(): Pattern | null {
-    const root = this.getRoot();
-    let result: Pattern | null = null;
+  get parent(): Pattern | null {
+    return this._parent;
+  }
 
-    if (root == null) {
-      return null;
-    }
+  set parent(pattern: Pattern | null) {
+    this._parent = pattern;
+  }
 
-    this.walkTheTree(root, (pattern) => {
-      if (
-        pattern.name === this.name &&
-        pattern != this &&
-        pattern.type != "reference"
-      ) {
-        result = pattern;
-        return false;
-      }
-      return true;
-    });
+  get children(): Pattern[] {
+    return this._children
+  }
 
-    return result;
+  constructor(name: string, isOptional: boolean = false) {
+    this._type = "reference";
+    this._name = name;
+    this._parent = null;
+    this._isOptional = isOptional;
+    this._pattern = null;
+    this._children = [];
   }
 
-  private walkTheTree(
-    pattern: Pattern,
-    callback: (pattern: Pattern) => boolean
-  ) {
-    for (let x = 0; x < pattern.children.length; x++) {
-      const p = pattern.children[x];
-      const continueWalking = this.walkTheTree(p, callback);
+  parseText(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor)
 
-      if (!continueWalking) {
-        return false;
-      }
+    return {
+      ast,
+      cursor
+    };
+  }
+
+  parse(cursor: Cursor): Node | null {
+    return this._getPatternSafely().parse(cursor);
+  }
+
+  clone(name = this._name, isOptional = this._isOptional): Pattern {
+    return new Reference(name, isOptional);
+  }
+
+  getTokens(): string[] {
+    return this._getPatternSafely().getTokens();
+  }
+
+  getNextTokens(_lastMatched: Pattern): string[] {
+    if (this.parent == null) {
+      return [];
     }
 
-    return callback(pattern);
+    return this.parent.getNextTokens(this);
   }
 
-  parse(cursor: Cursor) {
-    const mark = cursor.mark();
+  getNextPattern(): Pattern | null {
+    return getNextPattern(this)
+  }
 
-    try {
-      const node = this.safelyGetPattern().parse(cursor);
+  findPattern(_isMatch: (p: Pattern)=>boolean): Pattern | null{
+    return null;
+  }
 
-      if (!cursor.hasUnresolvedError() && node != null) {
-        cursor.addMatch(this, node);
-      }
+  private _getPatternSafely(): Pattern {
+    if (this._pattern === null) {
+      const pattern = this._findPattern();
 
-      if (cursor.hasUnresolvedError() && this._isOptional) {
-        cursor.resolveError();
-        cursor.moveToMark(mark);
+      if (pattern === null) {
+        throw new Error(`Couldn't find '${this._name}' pattern within tree.`);
       }
 
-      return node;
-    } catch (error) {
-      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
-          )
-        );
-      }
+      const clonedPattern = pattern.clone(this._name, this._isOptional);
+      clonedPattern.parent = this;
 
-      return null;
+      this._pattern = clonedPattern;
+      this._children = [this._pattern];
     }
-  }
 
-  clone(name?: string, isOptional?: boolean) {
-    if (name == null) {
-      name = this.name;
-    }
+    return this._pattern;
+  }
 
-    if (isOptional == null) {
-      isOptional = this._isOptional;
-    }
+  private _findPattern(): Pattern | null {
+    const root = this._getRoot();
 
-    return new Reference(name, isOptional);
+    return findPattern(root, (pattern: Pattern) => {
+      return pattern.name === this._name && pattern.type !== "reference";
+    });
   }
 
-  private safelyGetPattern() {
-    let pattern = this.children[0];
-    const hasNoPattern = pattern == null;
+  private _getRoot(): Pattern {
+    let node: Pattern = this;
 
-    if (hasNoPattern) {
-      const reference = this.findPattern();
-      if (reference == null) {
-        throw new Error(
-          `Couldn't find reference pattern, with the name ${this.name}.`
-        );
-      }
+    while (true) {
+      const parent = node.parent;
 
-      pattern = reference;
-      this.children = [pattern];
+      if (parent == null) {
+        break;
+      } else {
+        node = parent
+      }
     }
 
-    return pattern;
-  }
-
-  getTokens() {
-    return this.safelyGetPattern().getTokens();
+    return node;
   }
 }

package/src/patterns/Regex.test.ts

@@ -0,0 +1,101 @@
+import { Cursor } from "./Cursor";
+import { Regex } from "./Regex";
+import { Node } from "../ast/Node"
+import { And } from "./And";
+import { Literal } from "./Literal";
+
+describe("Regex", () => {
+    test("Empty String", () => {
+        expect(() => new Regex("empty", "")).toThrowError()
+    });
+
+    test("Starts With ^", () => {
+        expect(() => new Regex("carrot", "^")).toThrowError()
+    });
+
+    test("Ends With $", () => {
+        expect(() => new Regex("money", ".$")).toThrowError()
+    });
+
+    test("Successful Parse", () => {
+        const number = new Regex("number", "\\d");
+        const cursor = new Cursor("1");
+        const result = number.parse(cursor);
+        const expected = new Node("regex", "number", 0, 0, [], "1");
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy()
+    })
+
+    test("Failed Parse", () => {
+        const number = new Regex("number", "\\d");
+        const cursor = new Cursor("F");
+        const result = number.parse(cursor);
+
+        expect(result).toBeNull();
+        expect(cursor.hasError).toBeTruthy()
+    });
+
+
+    test("Get Tokens", () => {
+        const parent = new And("parent", [
+            new Regex("a", "A"),
+            new Regex("b", "B")
+        ]);
+
+        const a = parent.children[0] as Regex;
+        const b = parent.children[1] as Regex;
+
+        a.setTokens(["A"]);
+        b.setTokens(["B"]);
+
+        let tokens = a.getTokens();
+        let expectedTokens = ["A"];
+
+        expect(tokens).toEqual(expectedTokens);
+
+        a.enableContextualTokenAggregation();
+
+        tokens = a.getTokens();
+        expectedTokens = ["AB"];
+
+        expect(tokens).toEqual(expectedTokens);
+
+        a.disableContextualTokenAggregation();
+
+        tokens = a.getTokens();
+        expectedTokens = ["A"];
+
+        expect(tokens).toEqual(expectedTokens);
+    });
+
+    test("Get Next Tokens", () => {
+        const regex = new Regex("a", "A");
+        const tokens = regex.getNextTokens(new Literal("bogus", "bogus"));
+        const expected: string[] = [];
+
+        expect(tokens).toEqual(expected)
+    });
+
+    test("Get Next Pattern", () => {
+        const regex = new Regex("a", "A");
+        const nextPattern = regex.getNextPattern();
+
+        expect(nextPattern).toBeNull()
+    });
+
+    test("Properties", () => {
+        const regex = new Regex("a", "A");
+
+        expect(regex.type).toBe("regex");
+        expect(regex.name).toBe("a");
+        expect(regex.parent).toBeNull();
+        expect(regex.children).toEqual([]);
+    });
+
+    test("Parse Text", () => {
+        const regex = new Regex("a", "A");
+        const { ast: result } = regex.parseText("B");
+        expect(result).toBeNull();
+    });
+});

package/src/patterns/Regex.ts

@@ -1,123 +1,192 @@
-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 = "";
+import { Node } from "../ast/Node";
+import { Pattern } from "./Pattern";
+import { Cursor } from "./Cursor";
+import { getNextPattern } from "./getNextPattern";
+
+export class Regex implements Pattern {
+  private _type: string;
+  private _name: string;
+  private _isOptional: boolean;
+  private _parent: Pattern | null;
+  private _originalRegexString: string;
+  private _regex: RegExp;
+  private _node: Node | null = null;
+  private _cursor: Cursor | null = null;
+  private _substring: string = "";
+  private _tokens: string[] = [];
+  private _hasContextualTokenAggregation = false;
+  private _isRetrievingContextualTokens: boolean = false;
+
+  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 [];
+  }
+
+  get isOptional(): boolean {
+    return this._isOptional;
+  }
 
   constructor(name: string, regex: string, isOptional = false) {
-    super("regex", name, [], isOptional);
-    this.regexString = regex;
-    this.regex = new RegExp(`^${regex}`, "g");
+    this._type = "regex"
+    this._name = name;
+    this._isOptional = isOptional;
+    this._parent = null;
+    this._originalRegexString = regex;
+    this._regex = new RegExp(`^${regex}`, "g");
     this.assertArguments();
   }
 
   private assertArguments() {
-    if (this.regexString.length < 1) {
+    if (this._originalRegexString.length < 1) {
       throw new Error(
         "Invalid Arguments: The regex string argument needs to be at least one character long."
       );
     }
 
-    if (this.regexString.charAt(0) === "^") {
+    if (this._originalRegexString.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) === "$") {
+    if (this._originalRegexString.charAt(this._originalRegexString.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."
       );
     }
   }
 
+  parseText(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor)
+
+    return {
+      ast,
+      cursor
+    };
+  }
+
   parse(cursor: Cursor) {
     this.resetState(cursor);
-    this.tryToParse();
+    this.tryToParse(cursor);
 
-    return this.node;
+    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;
+    this._cursor = cursor;
+    this._regex.lastIndex = 0;
+    this._substring = this._cursor.text.substr(this._cursor.index);
+    this._node = null;
   }
 
-  private tryToParse() {
-    const result = this.regex.exec(this.substring);
+  private tryToParse(cursor: Cursor) {
+    const result = this._regex.exec(this._substring);
 
     if (result != null && result.index === 0) {
-      this.processResult(result);
+      this.processResult(cursor, result);
     } else {
-      this.processError();
+      this.processError(cursor);
     }
   }
 
-  private processResult(result: RegExpExecArray) {
-    const cursor = this.safelyGetCursor();
-    const currentIndex = cursor.getIndex();
+  private processResult(cursor: Cursor, result: RegExpExecArray) {
+    const currentIndex = cursor.index;
     const newIndex = currentIndex + result[0].length - 1;
 
-    this.node = new Node(
+    this._node = new Node(
       "regex",
-      this.name,
+      this._name,
       currentIndex,
       newIndex,
       [],
       result[0]
     );
 
-    cursor.moveToMark(newIndex);
-    cursor.addMatch(this, this.node);
+    cursor.moveTo(newIndex);
+    cursor.recordMatch(this, this._node);
   }
 
-  private processError() {
-    const cursor = this.safelyGetCursor();
-
+  private processError(cursor: Cursor) {
     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);
+      cursor.recordErrorAt(cursor.index, this);
     }
 
-    this.node = null;
+    this._node = null;
   }
 
-  private safelyGetCursor() {
-    const cursor = this.cursor;
+  clone(name = this._name, isOptional = this._isOptional) {
+    const pattern = new Regex(name, this._originalRegexString, isOptional);
+    pattern._tokens = this._tokens.slice();
+    pattern._hasContextualTokenAggregation =
+      this._hasContextualTokenAggregation;
 
-    if (cursor == null) {
-      throw new Error("Couldn't find cursor.");
-    }
-    return cursor;
+    return pattern;
   }
 
-  clone(name?: string, isOptional?: boolean) {
-    if (name == null) {
-      name = this.name;
+  getTokens() {
+    const parent = this._parent;
+
+    if (this._hasContextualTokenAggregation &&
+      parent != null &&
+      !this._isRetrievingContextualTokens
+    ) {
+      this._isRetrievingContextualTokens = true;
+
+      const tokens = this._tokens;
+      const aggregateTokens: string[] = [];
+      const nextTokens = parent.getNextTokens(this);
+
+      for (let nextToken of nextTokens) {
+        for (let token of tokens) {
+          aggregateTokens.push(token + nextToken);
+        }
+      }
+
+      this._isRetrievingContextualTokens = false
+      return aggregateTokens;
     }
 
-    if (isOptional == null) {
-      isOptional = this._isOptional;
-    }
+    return this._tokens;
+  }
 
-    return new Regex(name, this.regexString, isOptional);
+  getNextTokens(_reference: Pattern): string[] {
+    return [];
   }
 
-  getTokenValue() {
-    return this.name;
+  getNextPattern(): Pattern | null {
+    return getNextPattern(this)
+  }
+  
+  findPattern(_isMatch: (p: Pattern)=>boolean): Pattern | null{
+    return null;
   }
 
-  getTokens() {
-    return [this.name];
+  setTokens(tokens: string[]) {
+    this._tokens = tokens;
+  }
+
+  enableContextualTokenAggregation() {
+    this._hasContextualTokenAggregation = true;
   }
-}
+
+  disableContextualTokenAggregation() {
+    this._hasContextualTokenAggregation = false;
+  }
+
+}