clarity-pattern-parser 3.0.15 → 4.0.0

package/src/patterns/value/RegexValue.ts

@@ -1,103 +0,0 @@
-import ParseError from "../ParseError";
-import ValueNode from "../../ast/ValueNode";
-import ValuePattern from "./ValuePattern";
-import Cursor from "../../Cursor";
-
-export default class RegexValue extends ValuePattern {
-  public regexString: string;
-  public regex: RegExp;
-  public node: ValueNode | null = null;
-  public cursor!: Cursor;
-  public substring: string = "";
-
-  constructor(name: string, regex: string) {
-    super("regex-value", name);
-    this.regexString = regex;
-    this.regex = new RegExp(`^${regex}`, "g");
-    this._assertArguments();
-  }
-
-  private _assertArguments() {
-    if (typeof this.regexString !== "string") {
-      throw new Error(
-        "Invalid Arguments: The regex argument needs to be a string of regex."
-      );
-    }
-
-    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._reset(cursor);
-    this._tryPattern();
-
-    return this.node;
-  }
-
-  private _reset(cursor: Cursor) {
-    this.cursor = cursor;
-    this.regex.lastIndex = 0;
-    this.substring = this.cursor.text.substr(this.cursor.getIndex());
-    this.node = null;
-  }
-
-  private _tryPattern() {
-    const result = this.regex.exec(this.substring);
-
-    if (result != null && result.index === 0) {
-      const currentIndex = this.cursor.getIndex();
-      const newIndex = currentIndex + result[0].length - 1;
-
-      this.node = new ValueNode(
-        "regex-value",
-        this.name,
-        result[0],
-        currentIndex,
-        newIndex
-      );
-
-      this.cursor.index = newIndex;
-      this.cursor.addMatch(this, this.node);
-    } else {
-      this._processError();
-    }
-  }
-
-  private _processError() {
-    const message = `ParseError: Expected regex pattern of '${this.regexString}' but found '${this.substring}'.`;
-    const parseError = new ParseError(message, this.cursor.getIndex(), this);
-
-    this.cursor.throwError(parseError);
-  }
-
-  clone(name: string) {
-    if (typeof name !== "string") {
-      name = this.name;
-    }
-    return new RegexValue(name, this.regexString);
-  }
-
-  getTokenValue() {
-    return this.name;
-  }
-
-  getTokens() {
-    return [this.name];
-  }
-}

package/src/patterns/value/RepeatValue.ts

@@ -1,131 +0,0 @@
-import ValuePattern from "./ValuePattern";
-import ValueNode from "../../ast/ValueNode";
-import ParseError from "../ParseError";
-import OptionalValue from "./OptionalValue";
-import Pattern from "../Pattern";
-import Cursor from "../../Cursor";
-
-export default class RepeatValue extends ValuePattern {
-  public _pattern: ValuePattern;
-  public _divider: ValuePattern;
-  public nodes: ValueNode[] = [];
-  public cursor!: Cursor;
-  public mark: number = 0;
-  public node: ValueNode | null = null;
-
-  constructor(name: string, pattern: ValuePattern, divider?: ValuePattern) {
-    super(
-      "repeat-value",
-      name,
-      divider != null ? [pattern, divider] : [pattern]
-    );
-
-    this._pattern = this.children[0] as ValuePattern;
-    this._divider = this.children[1] as ValuePattern;
-
-    this._assertArguments();
-  }
-
-  private _assertArguments() {
-    if (this._pattern instanceof OptionalValue) {
-      throw new Error(
-        "Invalid Arguments: The pattern cannot be a optional pattern."
-      );
-    }
-  }
-
-  private _reset(cursor: Cursor) {
-    this.nodes = [];
-    this.cursor = cursor;
-    this.mark = this.cursor.mark();
-  }
-
-  parse(cursor: Cursor) {
-    this._reset(cursor);
-    this._tryPattern();
-
-    return this.node;
-  }
-
-  private _tryPattern() {
-    while (true) {
-      const node = this._pattern.parse(this.cursor) as ValueNode;
-
-      if (this.cursor.hasUnresolvedError()) {
-        this._processMatch();
-        break;
-      } else {
-        this.nodes.push(node);
-
-        if (node.endIndex === this.cursor.lastIndex()) {
-          this._processMatch();
-          break;
-        }
-
-        this.cursor.next();
-
-        if (this._divider != null) {
-          const mark = this.cursor.mark();
-          const node = this._divider.parse(this.cursor) as ValueNode;
-
-          if (this.cursor.hasUnresolvedError()) {
-            this.cursor.moveToMark(mark);
-            this._processMatch();
-            break;
-          } else {
-            this.nodes.push(node);
-
-            if (node.endIndex === this.cursor.lastIndex()) {
-              this._processMatch();
-              break;
-            }
-
-            this.cursor.next();
-          }
-        }
-      }
-    }
-  }
-
-  private _processMatch() {
-    const endsOnDivider = this.nodes.length % 2 === 0;
-    const noMatch = this.nodes.length === 0;
-    const hasDivider = this._divider != null;
-
-    this.cursor.resolveError();
-
-    if ((hasDivider && endsOnDivider) || noMatch) {
-      const parseError = new ParseError(
-        `Did not find a repeating match of ${this.name}.`,
-        this.mark,
-        this
-      );
-      this.cursor.throwError(parseError);
-      this.node = null;
-    } else {
-      const value = this.nodes.map((node) => node.value).join("");
-
-      this.node = new ValueNode(
-        "repeat-value",
-        this.name,
-        value,
-        this.nodes[0].startIndex,
-        this.nodes[this.nodes.length - 1].endIndex
-      );
-
-      this.cursor.index = this.node.endIndex;
-      this.cursor.addMatch(this, this.node);
-    }
-  }
-
-  clone(name?: string) {
-    if (typeof name !== "string") {
-      name = this.name;
-    }
-    return new RepeatValue(name, this._pattern, this._divider);
-  }
-
-  getTokens() {
-    return this._pattern.getTokens();
-  }
-}

package/src/patterns/value/ValuePattern.ts

@@ -1,8 +0,0 @@
-import Pattern from "../Pattern";
-
-export default abstract class ValuePattern extends Pattern {
-  constructor(type: string, name: string, children: ValuePattern[] = []) {
-    super(type, name, children);
-  }
-  abstract clone(name?: string): ValuePattern;
-}

package/src/tests/AndComposite.test.ts

@@ -1,102 +0,0 @@
-/** @jest-environment node */
-import AndComposite from "../patterns/composite/AndComposite";
-import Literal from "../patterns/value/Literal";
-import OptionalValue from "../patterns/value/OptionalValue";
-import Cursor from "../Cursor";
-
-describe("AndComposite", () => {
-  test("Match", () => {
-    const john = new Literal("john", "John");
-    const doe = new Literal("doe", "Doe");
-    const cursor = new Cursor("JohnDoe");
-    const name = new AndComposite("name", [john, doe]);
-
-    const node = name.parse(cursor);
-
-    expect(node?.name).toBe("name");
-    expect(node?.children[0].name).toBe("john");
-    expect(node?.children[1].name).toBe("doe");
-    expect(node?.children[0].value).toBe("John");
-    expect(node?.children[1].value).toBe("Doe");
-  });
-
-  test("AndComposite: No Match", () => {
-    const john = new Literal("john", "John");
-    const doe = new Literal("doe", "Doe");
-    const cursor = new Cursor("JohnSmith");
-    const name = new AndComposite("name", [john, doe]);
-
-    const node = name.parse(cursor);
-
-    expect(node).toBe(null);
-    expect(cursor.getIndex()).toBe(0);
-    expect(cursor.hasUnresolvedError()).toBe(true);
-    expect(cursor.parseError?.message).toBe(
-      "ParseError: Expected 'Doe' but found 'Smi'."
-    );
-  });
-
-  test("AndComposite: test.", () => {
-    const john = new Literal("john", "John");
-    const doe = new Literal("doe", "Doe");
-    const name = new AndComposite("name", [john, doe]);
-    const isMatch = name.test("JohnDoe");
-
-    expect(isMatch).toBe(true);
-  });
-
-  test("AndComposite: no children.", () => {
-    expect(() => {
-      new AndComposite("name");
-    }).toThrow();
-  });
-
-  test("AndComposite: string runs out before match is done.", () => {
-    const first = new Literal("first", "John");
-    const last = new Literal("last", "Doe");
-    const name = new AndComposite("name", [first, last]);
-    const cursor = new Cursor("JohnDo");
-    const result = name.parse(cursor);
-  });
-
-  test("AndComposite: last name is optional.", () => {
-    const first = new Literal("first", "John");
-    const last = new OptionalValue(new Literal("last", "Boe"));
-    const name = new AndComposite("name", [first, last]);
-    const cursor = new Cursor("JohnDo");
-    const result = name.parse(cursor);
-
-    expect(result?.name).toBe("name");
-    expect(result?.type).toBe("and-composite");
-    expect(result?.children[0].value).toBe("John");
-    expect(result?.children[0].name).toBe("first");
-    expect(result?.children[0].type).toBe("literal");
-  });
-
-  test("AndComposite: three non-optional patterns.", () => {
-    const first = new Literal("first", "John");
-    const middle = new Literal("middle", "Smith");
-    const last = new Literal("last", "Doe");
-    const name = new AndComposite("name", [first, middle, last]);
-    const cursor = new Cursor("JohnDoe");
-    const result = name.parse(cursor);
-  });
-
-  test("AndComposite: full name, middle optional, and last name isn't.", () => {
-    const first = new Literal("first", "John");
-    const middle = new OptionalValue(new Literal("middle", "Smith"));
-    const last = new Literal("last", "Doe");
-    const name = new AndComposite("name", [first, middle, last]);
-    const cursor = new Cursor("JohnDoe");
-    const result = name.parse(cursor);
-  });
-
-  test("AndComposite: clone.", () => {
-    const john = new Literal("john", "John");
-    const doe = new Literal("doe", "Doe");
-    const name = new AndComposite("name", [john, doe]);
-    const clone = name.clone("name2");
-
-    expect(clone.name).toBe("name2");
-  });
-});

package/src/tests/AnyOfThese.test.ts

@@ -1,74 +0,0 @@
-/** @jest-environment node */
-import AnyOfThese from "../patterns/value/AnyOfThese";
-import Cursor from "../Cursor";
-
-describe("AnyOfThese", () => {
-  test("Empty string provided as characters.", () => {
-    expect(() => {
-      new AnyOfThese("no-characters", "");
-    }).toThrow();
-  });
-
-  test("Single character.", () => {
-    const lowerCaseA = new AnyOfThese("lower-case-a", "a");
-    const cursor = new Cursor("a");
-    const node = lowerCaseA.parse(cursor);
-
-    expect(node?.name).toBe("lower-case-a");
-    expect(node?.value).toBe("a");
-    expect(node?.startIndex).toBe(0);
-    expect(node?.endIndex).toBe(0);
-    expect(cursor.isAtEnd()).toBe(true);
-    expect(cursor.getChar()).toBe("a");
-  });
-
-  test("Uppercase A and lowercase A.", () => {
-    const letterA = new AnyOfThese("letter-a", "Aa");
-    const lowerCaseCursor = new Cursor("a");
-    const upperCaseCursor = new Cursor("A");
-    const lowerCaseNode = letterA.parse(lowerCaseCursor);
-    const upperCaseNode = letterA.parse(upperCaseCursor);
-
-    expect(lowerCaseNode?.name).toBe("letter-a");
-    expect(lowerCaseNode?.value).toBe("a");
-    expect(lowerCaseNode?.startIndex).toBe(0);
-    expect(lowerCaseNode?.endIndex).toBe(0);
-
-    expect(upperCaseNode?.name).toBe("letter-a");
-    expect(upperCaseNode?.value).toBe("A");
-    expect(upperCaseNode?.startIndex).toBe(0);
-    expect(upperCaseNode?.endIndex).toBe(0);
-
-    expect(upperCaseCursor.getChar()).toBe("A");
-    expect(upperCaseCursor.isAtEnd()).toBe(true);
-
-    expect(lowerCaseCursor.getChar()).toBe("a");
-    expect(lowerCaseCursor.isAtEnd()).toBe(true);
-  });
-
-  test("Match with long cursor.", () => {
-    const letterA = new AnyOfThese("letter-a", "Aa");
-    const cursor = new Cursor("a12345");
-    const node = letterA.parse(cursor);
-
-    expect(node?.name).toBe("letter-a");
-    expect(node?.value).toBe("a");
-    expect(cursor.getChar()).toBe("a");
-    expect(cursor.getIndex()).toBe(0);
-  });
-
-  test("No match.", () => {
-    const letterA = new AnyOfThese("letter-a", "Aa");
-    const cursor = new Cursor("12345");
-    const node = letterA.parse(cursor);
-
-    expect(node).toBe(null);
-  });
-
-  test("Pattern Methods.", () => {
-    const letterA = new AnyOfThese("letter-a", "Aa");
-
-    expect(letterA.name).toBe("letter-a");
-    expect(letterA.children.length).toBe(0);
-  });
-});

package/src/tests/CompositeNode.test.ts

@@ -1,33 +0,0 @@
-/** @jest-environment node */
-import CompositeNode from "../ast/CompositeNode";
-import { ValueNode } from "../index";
-
-describe("CompositeNode", () => {
-  test("CompositeNode: clone", () => {
-    const node = new CompositeNode("type", "name", 0, 0);
-    const valueNode = new ValueNode("value-type", "value-name", "t", 0, 0);
-
-    node.children.push(valueNode);
-
-    const clone = node.clone();
-
-    expect(clone.type).toBe("type");
-    expect(clone.name).toBe("name");
-    expect(clone.children.length).toBe(1);
-    expect(clone.children[0].type).toBe("value-type");
-    expect(clone.children[0].name).toBe("value-name");
-  });
-
-  test("CompositeNode: constructor without default indexes.", () => {
-    const node = new CompositeNode("type", "name");
-    const valueNode = new ValueNode("value-type", "value-name", "t", 0, 0);
-
-    node.children.push(valueNode);
-
-    expect(node.type).toBe("type");
-    expect(node.name).toBe("name");
-    expect(node.children.length).toBe(1);
-    expect(node.children[0].type).toBe("value-type");
-    expect(node.children[0].name).toBe("value-name");
-  });
-});

package/src/tests/NotValue.test.ts

@@ -1,69 +0,0 @@
-/** @jest-environment node */
-import NotValue from "../patterns/value/NotValue";
-import Literal from "../patterns/value/Literal";
-import Cursor from "../Cursor";
-
-describe("NotValue", () => {
-  test("Empty Constructor.", () => {
-    expect(() => {
-      new (NotValue as any)();
-    }).toThrow();
-  });
-
-  test("Invalid name.", () => {
-    expect(() => {
-      new (NotValue as any)([], new Literal("blah", "Blah"));
-    }).toThrow();
-  });
-
-  test("No patterns", () => {
-    expect(() => {
-      new (NotValue as any)("and-value");
-    }).toThrow();
-  });
-
-  test("Empty patterns", () => {
-    expect(() => {
-      new (NotValue as any)("and-value", null);
-    }).toThrow();
-  });
-
-  test("Invalid patterns", () => {
-    expect(() => {
-      new (NotValue as any)("and-value", {});
-    }).toThrow();
-  });
-
-  test("No Match", () => {
-    const john = new Literal("john", "John");
-    const notJohn = new NotValue("not-john", john);
-    const cursor = new Cursor("John");
-
-    notJohn.parse(cursor);
-    expect(cursor.hasUnresolvedError()).toBe(true);
-    expect(cursor.parseError?.message).toBe(
-      "Didn't find any characters that didn't match the john pattern."
-    );
-  });
-
-  test("Success", () => {
-    const john = new Literal("john", "John");
-    const notJohn = new NotValue("not-john", john);
-    const cursor = new Cursor("Jane");
-    const node = notJohn.parse(cursor);
-
-    expect(node?.name).toBe("not-john");
-    expect(node?.value).toBe("J");
-    expect(node?.startIndex).toBe(0);
-    expect(node?.endIndex).toBe(0);
-    expect(cursor.getIndex()).toBe(0);
-  });
-
-  test("Clone.", () => {
-    const john = new Literal("john", "John");
-    const notJohn = new NotValue("not-john", john);
-    const clone = notJohn.clone();
-
-    expect(notJohn.name).toBe(clone.name);
-  });
-});

package/src/tests/OptionalValue.test.ts

@@ -1,50 +0,0 @@
-/** @jest-environment node */
-import Literal from "../patterns/value/Literal";
-import OptionalValue from "../patterns/value/OptionalValue";
-import Cursor from "../Cursor";
-
-describe("OptionalValue", () => {
-  test("Empty constructor.", () => {
-    expect(() => {
-      new (OptionalValue as any)();
-    }).toThrow();
-  });
-
-  test("Empty pattern.", () => {
-    expect(() => {
-      new (OptionalValue as any)();
-    }).toThrow();
-  });
-
-  test("Invalid pattern.", () => {
-    expect(() => {
-      new (OptionalValue as any)({});
-    }).toThrow();
-  });
-
-  test("Match pattern.", () => {
-    const john = new Literal("john", "John");
-    const optionalValue = new OptionalValue(john);
-    const cursor = new Cursor("John");
-    const node = optionalValue.parse(cursor);
-
-    expect(node?.name).toBe("john");
-    expect(node?.value).toBe("John");
-  });
-
-  test("No Match pattern.", () => {
-    const john = new Literal("john", "John");
-    const optionalValue = new OptionalValue(john);
-    const cursor = new Cursor("Jane");
-    const node = optionalValue.parse(cursor);
-
-    expect(node).toBe(null);
-  });
-
-  test("Name", () => {
-    const john = new Literal("john", "John");
-    const optionalValue = new OptionalValue(john);
-
-    expect(optionalValue.name).toBe("optional-value");
-  });
-});

package/src/tests/OrComposite.test.ts

@@ -1,75 +0,0 @@
-/** @jest-environment node */
-import OrComposite from "../patterns/composite/OrComposite";
-import Literal from "../patterns/value/Literal";
-import OptionalValue from "../patterns/value/OptionalValue";
-import { Cursor } from "../index";
-
-describe("OrComposite", ()=>{
-  test("Match.", () => {
-    const john = new Literal("john", "John");
-    const jane = new Literal("jane", "Jane");
-    const cursor = new Cursor("John");
-    const name = new OrComposite("name", [john, jane]);
-  
-    const node = name.parse(cursor);
-  
-    expect(node.name).toBe("john");
-    expect(node.value).toBe("John");
-  });
-  
-  test("No Match", () => {
-    const john = new Literal("john", "John");
-    const jane = new Literal("jane", "Jane");
-    const cursor = new Cursor("Jeffrey");
-    const name = new OrComposite("name", [john, jane]);
-  
-    const node = name.parse(cursor);
-  
-    expect(node).toBe(null);
-    expect(cursor.getIndex()).toBe(0);
-    expect(cursor.hasUnresolvedError()).toBe(true);
-  });
-  
-  test("Supplied only one option.", () => {
-    const john = new Literal("john", "John");
-  
-    expect(() => {
-      new OrComposite("name", [john]);
-    }).toThrow();
-  });
-  
-  test("Optional Children.", () => {
-    const john = new Literal("john", "John");
-    const jane = new Literal("jane", "Jane");
-  
-    expect(() => {
-      new OrComposite("name", [new OptionalValue(john), new OptionalValue(jane)]);
-    }).toThrow();
-  });
-  
-  test("parse with null cursor.", () => {
-    const john = new Literal("john", "John");
-    const jane = new Literal("jane", "Jane");
-    const cursor = new Cursor("John");
-    const name = new OrComposite("name", [john, jane]);
-  
-    const node = name.parse(cursor);
-  
-    expect(node.name).toBe("john");
-    expect(node.value).toBe("John");
-  });
-  
-  test("clone.", () => {
-    const john = new Literal("john", "John");
-    const jane = new Literal("jane", "Jane");
-  
-    const name = new OrComposite("name", [john, jane]);
-    const clone = name.clone("name2");
-  
-    expect(clone.name).toBe("name2");
-    expect(clone.children.length).toBe(2);
-    expect(clone.children[0].name).toBe("john");
-    expect(clone.children[1].name).toBe("jane");
-  });
-  
-});