clarity-pattern-parser 4.0.2 → 5.0.0

package/src/patterns/Or.test.ts

@@ -0,0 +1,105 @@
+import { Cursor } from "./Cursor";
+import { Node } from "../ast/Node";
+import { Literal } from "./Literal";
+import { Or } from "./Or";
+import { And } from "./And";
+
+describe("Or", () => {
+    test("Empty Options", () => {
+        expect(() => {
+            new Or("bad", []);
+        }).toThrowError();
+    });
+
+    test("One Option Successful", () => {
+        const a = new Or("a", [new Literal("a", "A")]);
+        const cursor = new Cursor("A");
+        const result = a.parse(cursor);
+        const expected = new Node("literal", "a", 0, 0, [], "A")
+
+        expect(result).toEqual(expected);
+    });
+
+    test("One Option Failed", () => {
+        const a = new Or("a", [new Literal("a", "A")]);
+        const cursor = new Cursor("B");
+        const result = a.parse(cursor);
+
+        expect(result).toEqual(null);
+        expect(cursor.index).toBe(0);
+        expect(cursor.hasError).toBeTruthy();
+    });
+
+    test("Two Option", () => {
+        const a = new Or("a-b", [new Literal("a", "A"), new Literal("b", "B")]);
+        const cursor = new Cursor("AB");
+        let result = a.parse(cursor);
+        let expected = new Node("literal", "a", 0, 0, [], "A")
+
+        expect(result).toEqual(expected);
+
+        cursor.next();
+
+        result = a.parse(cursor);
+        expected = new Node("or", "a-b", 0, 0, [
+            new Node("literal", "b", 0, 0, [], "B")
+        ], "B");
+    });
+
+    test("Failed (Optional)", () => {
+        const a = new Or("a", [new Literal("a", "A")], true);
+        const cursor = new Cursor("B");
+        const result = a.parse(cursor);
+
+        expect(result).toBeNull();
+        expect(cursor.hasError).toBeFalsy();
+    });
+
+    test("Get Tokens", () => {
+        const aOrB = new Or("a-b", [new Literal("a", "A"), new Literal("b", "B")]);
+        const tokens = aOrB.getTokens();
+        const expected = ["A", "B"];
+
+        expect(tokens).toEqual(expected);
+    });
+
+    test("Get Next Tokens", () => {
+        const a = new Or("a", [new Literal("a", "A")]);
+        const parent = new And("parent", [a, new Literal("b", "B")]);
+        const tokens = parent.children[0].getNextTokens(parent.children[0].children[0]);
+        const expected = ["B"];
+
+        expect(tokens).toEqual(expected);
+    });
+
+    test("Get Next Tokens Without A Parent", () => {
+        const a = new Or("a", [new Literal("a", "A")]);
+        const tokens = a.getNextTokens(a.children[0]);
+        const expected: string[] = [];
+
+        expect(tokens).toEqual(expected);
+    });
+
+    test("Get Next Pattern", () => {
+        const a = new Or("a", [new Literal("a", "A")]);
+        const nextToken = a.getNextPattern();
+
+        expect(nextToken).toBeNull();
+    });
+
+    test("Properties", () => {
+        const a = new Or("a", [new Literal("a", "A")]);
+
+        expect(a.type).toBe("or");
+        expect(a.name).toBe("a");
+        expect(a.isOptional).toBeFalsy();
+        expect(a.parent).toBeNull();
+        expect(a.children[0].name).toBe("a");
+    });
+
+    test("Parse Text", () => {
+        const a = new Or("a", [new Literal("a", "A")]);
+        const { ast: result } = a.parseText("B");
+        expect(result).toBeNull();
+    });
+});

package/src/patterns/Or.ts

@@ -1,132 +1,140 @@
-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."
-      );
-    }
+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 Or implements Pattern {
+  private _type: string;
+  private _name: string;
+  private _parent: Pattern | null;
+  private _children: Pattern[];
+  private _isOptional: boolean;
+  private _node: Node | null;
+  private _firstIndex: number;
+
+  get type(): string {
+    return this._type;
+  }
 
-    const hasOptionalChildren = this._children.some(
-      (pattern) => pattern.isOptional
-    );
+  get name(): string {
+    return this._name;
+  }
 
-    if (hasOptionalChildren) {
-      throw new Error("OrValues cannot have optional patterns.");
-    }
+  get parent(): Pattern | null {
+    return this._parent;
   }
 
-  private resetState(cursor: Cursor) {
-    this.patternIndex = 0;
-    this.errors = [];
-    this.node = null;
-    this.cursor = cursor;
-    this.mark = cursor.mark();
+  set parent(pattern: Pattern | null) {
+    this._parent = pattern;
   }
 
-  private safelyGetCursor() {
-    const cursor = this.cursor;
+  get children(): Pattern[] {
+    return this._children;
+  }
+
+  get isOptional(): boolean {
+    return this._isOptional;
+  }
 
-    if (cursor == null) {
-      throw new Error("Couldn't find cursor.");
+  constructor(name: string, options: Pattern[], isOptional: boolean = false) {
+    if (options.length === 0) {
+      throw new Error("Need at least one pattern with an 'or' pattern.");
+    }
+
+    const children = clonePatterns(options, false);
+    this._assignChildrenToParent(children);
+
+    this._type = "or";
+    this._name = name;
+    this._parent = null;
+    this._children = children;
+    this._isOptional = isOptional;
+    this._node = null;
+    this._firstIndex = 0;
+  }
+
+  private _assignChildrenToParent(children: Pattern[]): void {
+    for (const child of children) {
+      child.parent = this;
     }
-    return cursor;
   }
 
-  parse(cursor: Cursor) {
-    this.resetState(cursor);
-    this.tryToParse();
+  parseText(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor)
 
-    return this.node;
+    return {
+      ast,
+      cursor
+    };
   }
 
-  private tryToParse() {
-    const cursor = this.safelyGetCursor();
+  parse(cursor: Cursor): Node | null {
+    this._firstIndex = cursor.index;
+    this._node = null;
 
-    while (true) {
-      const pattern = this._children[this.patternIndex];
-      const node = pattern.parse(cursor);
-      const hasError = cursor.hasUnresolvedError();
+    const node = this._tryToParse(cursor);
 
-      if (hasError) {
-        const shouldBreak = this.processError();
-        if (shouldBreak) {
-          break;
-        }
-      } else if (node != null) {
-        this.processResult(node);
-        break;
-      }
+    if (node != null) {
+      cursor.resolveError();
+      return node
+    }
+
+    if (!this._isOptional) {
+      cursor.recordErrorAt(this._firstIndex, this)
+      return null;
     }
+
+    cursor.resolveError();
+    cursor.moveTo(this._firstIndex);
+    return null;
   }
 
-  private processError() {
-    const cursor = this.safelyGetCursor();
-    const isLastPattern = this.patternIndex + 1 === this._children.length;
+  private _tryToParse(cursor: Cursor): Node | null {
+    for (const pattern of this._children) {
+      cursor.moveTo(this._firstIndex);
+      const result = pattern.parse(cursor);
 
-    if (!isLastPattern) {
-      this.patternIndex++;
-      cursor.resolveError();
-      cursor.moveToMark(this.mark);
-      return false;
-    } else {
-      if (this._isOptional) {
-        cursor.resolveError();
-        cursor.moveToMark(this.mark);
+      if (!cursor.hasError) {
+        return result;
       }
-      this.node = null;
-      return true;
+
+      cursor.resolveError();
     }
+
+    return null
   }
 
-  private processResult(node: Node) {
-    const cursor = this.safelyGetCursor();
+  getTokens(): string[] {
+    const tokens: string[] = [];
 
-    this.node = new Node(
-      "or",
-      this.name,
-      node.startIndex,
-      node.endIndex,
-      [node],
-      node.value
-    );
+    for (const child of this._children) {
+      tokens.push(...child.getTokens());
+    }
 
-    cursor.index = this.node.endIndex;
-    cursor.addMatch(this, this.node);
+    return tokens;
   }
 
-  clone(name?: string, isOptional?: boolean) {
-    if (name == null) {
-      name = this.name;
+  getNextTokens(_lastMatched: Pattern): string[] {
+    if (this._parent === null) {
+      return [];
     }
 
-    if (isOptional == null) {
-      isOptional = this._isOptional;
-    }
+    return this._parent.getNextTokens(this);
+  }
+
+  getNextPattern(): Pattern | null {
+    return getNextPattern(this)
+  }
 
-    return new Or(name, this._children, isOptional);
+  findPattern(isMatch: (p: Pattern)=>boolean): Pattern | null{
+    return findPattern(this, isMatch);
   }
 
-  getTokens() {
-    return this._children.reduce<string[]>(
-      (acc, c) => acc.concat(c.getTokens()),
-      []
-    );
+  clone(name = this._name, isOptional = this._isOptional): Pattern {
+    const or = new Or(name, this._children, isOptional);
+    return or;
   }
 }

package/src/patterns/ParseError.ts

@@ -1,14 +1,10 @@
-import Pattern from "./Pattern";
+import { Pattern } from "./Pattern";
 
-export default class ParseError {
-  public message: string;
-  public name: string;
+export class ParseError {
   public index: number;
   public pattern: Pattern;
 
-  constructor(message: string, index: number, pattern: Pattern) {
-    this.name = "ParseError";
-    this.message = message;
+  constructor(index: number, pattern: Pattern) {
     this.index = index;
     this.pattern = pattern;
   }

package/src/patterns/ParseResult.ts

@@ -0,0 +1,7 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+
+export interface ParseResult {
+    ast: Node | null;
+    cursor: Cursor;
+}

package/src/patterns/Pattern.ts

@@ -1,151 +1,19 @@
-import Cursor from "../Cursor";
-import Node from "../ast/Node";
-
-export default abstract class Pattern {
-  protected _type: string;
-  protected _name: string;
-  protected _children: Pattern[];
-  protected _parent: Pattern | null;
-  protected _isOptional = false;
-
-  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._isOptional = isOptional;
-    this.children = children;
-  }
-
-  abstract parse(cursor: Cursor): Node | null;
-
-  exec(text: string) {
-    const cursor = new Cursor(text);
-    const node = this.parse(cursor);
-
-    if (cursor.didSuccessfullyParse()) {
-      return node;
-    } else {
-      return null;
-    }
-  }
-
-  test(text: string) {
-    return this.exec(text) != null;
-  }
-
-  get name() {
-    return this._name;
-  }
-
-  get type() {
-    return this._type;
-  }
-
-  get parent() {
-    return this._parent;
-  }
-
-  set parent(value: Pattern | null) {
-    this._parent = value;
-  }
-
-  get children() {
-    return this._children;
-  }
-
-  set children(value) {
-    this._children = value;
-    this.cloneChildren();
-    this.assignAsParent();
-  }
-
-  abstract clone(name?: string): Pattern;
-  abstract getTokens(): string[];
-
-  getTokenValue(): string | null {
-    return null;
-  }
-
-  getNextTokens(): string[] {
-    const parent = this._parent;
-
-    if (parent != null) {
-      const siblings = parent.children;
-      const index = siblings.findIndex((c) => c === this);
-      const nextSibling = siblings[index + 1];
-
-      // I don't like this, so I think we need to rethink this.
-      if (parent.type.indexOf("repeat") === 0) {
-        const tokens = parent.getNextTokens();
-        if (index === 0 && siblings.length > 1) {
-          return nextSibling.getTokens().concat(tokens);
-        } else if (index === 1) {
-          return siblings[0].getTokens();
-        } else {
-          return this.getTokens().concat(tokens);
-        }
-      }
-
-      // Another thing I don't like.
-      if (
-        this._parent?.type?.indexOf("and") === 0 &&
-        nextSibling != null &&
-        nextSibling.isOptional
-      ) {
-        let tokens: string[] = [];
-
-        for (let x = index + 1; x < siblings.length; x++) {
-          const child = siblings[x];
-
-          if (child.isOptional) {
-            tokens = tokens.concat(child.getTokens());
-          } else {
-            tokens = tokens.concat(child.getTokens());
-            break;
-          }
-
-          if (x === siblings.length - 1) {
-            tokens = tokens.concat(this._parent.getNextTokens());
-          }
-        }
-
-        return tokens;
-      }
-
-      // If you are an or you have already qualified.
-      if (parent.type.indexOf("or") === 0) {
-        return parent.getNextTokens();
-      }
-
-      if (nextSibling != null) {
-        return nextSibling.getTokens();
-      } else {
-        return parent.getNextTokens();
-      }
-    }
-
-    return [];
-  }
-
-  private cloneChildren() {
-    this._children = this._children.map((pattern) => {
-      return pattern.clone();
-    });
-
-    Object.freeze(this._children);
-  }
-
-  private assignAsParent() {
-    this._children.forEach((child) => (child.parent = this));
-  }
+import { Cursor } from "./Cursor";
+import { Node } from "../ast/Node";
+import { ParseResult } from "./ParseResult"
+
+export interface Pattern {
+  type: string;
+  name: string;
+  parent: Pattern | null;
+  children: Pattern[];
+  isOptional: boolean;
+
+  parse(cursor: Cursor): Node | null;
+  parseText(text: string): ParseResult;
+  clone(name?: string, isOptional?: boolean): Pattern;
+  getTokens(): string[];
+  getNextTokens(lastMatched: Pattern): string[];
+  getNextPattern(): Pattern | null;
+  findPattern(isMatch:(p: Pattern)=>boolean): Pattern | null;
 }

package/src/patterns/Reference.test.ts

@@ -0,0 +1,104 @@
+import { Cursor, Repeat } from "..";
+import { Node } from "../ast/Node";
+import { And } from "./And";
+import { findPattern } from "./findPattern";
+import { Literal } from "./Literal";
+import { Or } from "./Or";
+import { Reference } from "./Reference";
+import { Regex } from "./Regex";
+
+function createValuePattern() {
+    const number = new Regex("number", "\\d+");
+    const openBracket = new Literal("open-bracket", "[");
+    const closeBracket = new Literal("close-bracket", "]");
+    const divider = new Regex("divider", "\\s*,\\s+");
+    const valueRef = new Reference("value");
+    const values = new Repeat("values", valueRef, divider);
+    const array = new And("array", [openBracket, values, closeBracket]);
+    const value = new Or("value", [number, array]);
+
+    number.setTokens(["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]);
+    divider.setTokens([", "])
+
+    return value;
+}
+
+describe("Reference", () => {
+    test("One Deep Successful Parse", () => {
+        const value = createValuePattern();
+        const cursor = new Cursor("[1, 2]");
+        const result = value.parse(cursor);
+
+        const expected = new Node("and", "array", 0, 5, [
+            new Node("literal", "open-bracket", 0, 0, [], "["),
+            new Node("repeat", "values", 1, 4, [
+                new Node("regex", "number", 1, 1, [], "1"),
+                new Node("regex", "divider", 2, 3, [], ", "),
+                new Node("regex", "number", 4, 4, [], "2")
+            ]),
+            new Node("literal", "close-bracket", 5, 5, [], "]"),
+        ])
+
+        expect(result).toEqual(expected);
+    });
+
+    test("No Reference Pattern", () => {
+        const ref = new Reference("bad-reference");
+
+        expect(() => {
+            ref.parse(new Cursor("text"))
+        }).toThrowError()
+    });
+
+    test("Get Tokens", () => {
+        const value = createValuePattern();
+        const ref = findPattern(value, (p) => p.type === "reference");
+        const tokens = ref?.getTokens();
+        const expected = ["["];
+
+        expect(tokens).toEqual(expected);
+    });
+
+    test("Get Next Tokens", () => {
+        const value = createValuePattern();
+        const ref = findPattern(value, (p) => p.type === "reference");
+
+        // The value passed to getNextTokens doesn't matter.
+        // I just needed it to be a pattern.
+        const tokens = ref?.getNextTokens(value);
+        const expected = ["]"];
+
+        expect(tokens).toEqual(expected);
+    });
+
+    test("Get Next Tokens With No Parent", () => {
+        const ref = new Reference("bad-reference");
+        const tokens = ref.getNextTokens(new Literal("bogus", "bogus"))
+
+        expect(tokens).toEqual([]);
+    });
+
+    test("Get Next Pattern", () => {
+        const ref = new Reference("ref");
+        const nextPattern = ref.getNextPattern();
+
+        expect(nextPattern).toBeNull()
+    });
+
+    test("Properties", () => {
+        const ref = new Reference("ref");
+
+        expect(ref.type).toBe("reference");
+        expect(ref.name).toBe("ref");
+        expect(ref.isOptional).toBeFalsy();
+        expect(ref.parent).toBe(null)
+        expect(ref.children).toEqual([])
+    });
+
+    test("Parse Text", () => {
+        const value = createValuePattern();
+        const reference = findPattern(value, p => p.type === "reference") as Reference
+        const { ast: result } = reference.parseText("B");
+        expect(result).toBeNull()
+    });
+});