clarity-pattern-parser 3.0.16 → 4.0.0

package/src/patterns/value/Literal.ts

@@ -1,92 +0,0 @@
-import ParseError from "../ParseError";
-import ValueNode from "../../ast/ValueNode";
-import ValuePattern from "./ValuePattern";
-import Cursor from "../../Cursor";
-
-export default class Literal extends ValuePattern {
-  public literal: string;
-  public node: ValueNode | null = null;
-  public cursor!: Cursor;
-  public mark: number = 0;
-  public substring: string = "";
-
-  constructor(name: string, literal: string) {
-    super("literal", name);
-    this.literal = literal;
-    this._assertArguments();
-  }
-
-  private _assertArguments() {
-    if (typeof this.literal !== "string") {
-      throw new Error(
-        "Invalid Arguments: The literal argument needs to be a string of characters."
-      );
-    }
-
-    if (this.literal.length < 1) {
-      throw new Error(
-        "Invalid Arguments: The literalString argument needs to be at least one character long."
-      );
-    }
-  }
-
-  parse(cursor: Cursor) {
-    this._reset(cursor);
-    this._tryPattern();
-
-    return this.node;
-  }
-
-  private _reset(cursor: Cursor) {
-    this.cursor = cursor;
-    this.mark = this.cursor.mark();
-    this.substring = this.cursor.text.substring(
-      this.mark,
-      this.mark + this.literal.length
-    );
-    this.node = null;
-  }
-
-  private _tryPattern() {
-    if (this.substring === this.literal) {
-      this._processMatch();
-    } else {
-      this._processError();
-    }
-  }
-
-  private _processError() {
-    const message = `ParseError: Expected '${this.literal}' but found '${this.substring}'.`;
-
-    const parseError = new ParseError(message, this.cursor.getIndex(), this);
-    this.cursor.throwError(parseError);
-  }
-
-  private _processMatch() {
-    this.node = new ValueNode(
-      "literal",
-      this.name,
-      this.substring,
-      this.mark,
-      this.mark + this.literal.length - 1
-    );
-
-    this.cursor.index = this.node.endIndex;
-    this.cursor.addMatch(this, this.node);
-  }
-
-  clone(name?: string) {
-    if (typeof name !== "string") {
-      name = this.name;
-    }
-    return new Literal(name, this.literal);
-  }
-
-  getTokenValue() {
-    return this.literal;
-  }
-
-  getTokens() {
-    return [this.getTokenValue()];
-  }
-}

package/src/patterns/value/NotValue.ts

@@ -1,95 +0,0 @@
-import ValuePattern from "./ValuePattern";
-import ValueNode from "../../ast/ValueNode";
-import ParseError from "../ParseError";
-import Pattern from "../Pattern";
-import Cursor from "../../Cursor";
-
-export default class NotValue extends ValuePattern {
-  public match: string = "";
-  public node: ValueNode | null = null;
-  public cursor!: Cursor;
-  public mark: number = 0;
-
-  constructor(name: string, pattern: ValuePattern) {
-    super("not-value", name, [pattern]);
-    this._assertArguments();
-  }
-
-  private _assertArguments() {
-    if (!(this.children[0] instanceof Pattern)) {
-      throw new Error(
-        "Invalid Arguments: Expected the pattern to be a ValuePattern."
-      );
-    }
-
-    if (typeof this.name !== "string") {
-      throw new Error("Invalid Arguments: Expected name to be a string.");
-    }
-  }
-
-  private _reset(cursor: Cursor) {
-    this.match = "";
-    this.node = null;
-    this.cursor = cursor;
-    this.mark = this.cursor.mark();
-  }
-
-  parse(cursor: Cursor) {
-    this._reset(cursor);
-    this._tryPattern();
-
-    return this.node;
-  }
-
-  private _tryPattern() {
-    while (true) {
-      const mark = this.cursor.mark();
-      this.children[0].parse(this.cursor);
-
-      if (this.cursor.hasUnresolvedError()) {
-        this.cursor.resolveError();
-        this.cursor.moveToMark(mark);
-        this.match += this.cursor.getChar();
-        break;
-      } else {
-        this.cursor.moveToMark(mark);
-        break;
-      }
-    }
-
-    this._processMatch();
-  }
-
-  private _processMatch() {
-    if (this.match.length === 0) {
-      const parseError = new ParseError(
-        `Didn't find any characters that didn't match the ${this.children[0].name} pattern.`,
-        this.mark,
-        this
-      );
-      this.cursor.throwError(parseError);
-    } else {
-      this.node = new ValueNode(
-        "not-value",
-        this.name,
-        this.match,
-        this.mark,
-        this.mark
-      );
-
-      this.cursor.index = this.node.endIndex;
-      this.cursor.addMatch(this, this.node);
-    }
-  }
-
-  clone(name?: string) {
-    if (typeof name !== "string") {
-      name = this.name;
-    }
-    return new NotValue(name, this.children[0] as ValuePattern);
-  }
-
-  getTokens() {
-    return [];
-  }
-}

package/src/patterns/value/OptionalValue.ts

@@ -1,39 +0,0 @@
-import ValuePattern from "./ValuePattern";
-import Pattern from "../Pattern";
-import Cursor from "../../Cursor";
-
-export default class OptionalValue extends ValuePattern {
-  constructor(pattern: ValuePattern) {
-    super("optional-value", "optional-value", [pattern]);
-    this._assertArguments();
-  }
-
-  private _assertArguments() {
-    if (!(this.children[0] instanceof ValuePattern)) {
-      throw new Error("Invalid Arguments: Expected a ValuePattern.");
-    }
-  }
-
-  parse(cursor: Cursor) {
-    const mark = cursor.mark();
-
-    const node = this.children[0].parse(cursor);
-
-    if (cursor.hasUnresolvedError() || node == null) {
-      cursor.resolveError();
-      cursor.moveToMark(mark);
-      return null;
-    } else {
-      cursor.addMatch(this, node);
-      return node;
-    }
-  }
-
-  clone() {
-    return new OptionalValue(this.children[0] as ValuePattern);
-  }
-
-  getTokens() {
-    return this._children[0].getTokens();
-  }
-}

package/src/patterns/value/OrValue.ts

@@ -1,103 +0,0 @@
-import ValuePattern from "./ValuePattern";
-import ValueNode from "../../ast/ValueNode";
-import OptionalValue from "./OptionalValue";
-import Pattern from "../Pattern";
-import ParseError from "../ParseError";
-import Cursor from "../../Cursor";
-
-export default class OrValue extends ValuePattern {
-  public index: number = 0;
-  public errors: ParseError[] = [];
-  public node: ValueNode | null = null;
-  public cursor!: Cursor;
-  public mark: number = 0;
-  public parseError: ParseError | null = null;
-
-  constructor(name: string, patterns: ValuePattern[]) {
-    super("or-value", name, patterns);
-    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 instanceof OptionalValue
-    );
-
-    if (hasOptionalChildren) {
-      throw new Error("OrValues cannot have optional values.");
-    }
-  }
-
-  private _reset(cursor: Cursor) {
-    this.index = 0;
-    this.errors = [];
-    this.node = null;
-    this.cursor = cursor;
-    this.mark = cursor.mark();
-  }
-
-  parse(cursor: Cursor) {
-    this._reset(cursor);
-    this._tryPattern();
-
-    return this.node;
-  }
-
-  private _tryPattern() {
-    while (true) {
-      const pattern = this._children[this.index];
-      const node = pattern.parse(this.cursor) as ValueNode;
-
-      if (this.cursor.hasUnresolvedError()) {
-        if (this.index + 1 < this._children.length) {
-          this.cursor.resolveError();
-          this.index++;
-          this.cursor.moveToMark(this.mark);
-        } else {
-          this.node = null;
-          break;
-        }
-      } else {
-        this.node = new ValueNode(
-          "or-value",
-          this.name,
-          node.value,
-          node.startIndex,
-          node.endIndex
-        );
-
-        this.cursor.index = this.node.endIndex;
-        this.cursor.addMatch(this, this.node);
-
-        break;
-      }
-    }
-  }
-
-  clone(name: string) {
-    if (typeof name !== "string") {
-      name = this.name;
-    }
-    return new OrValue(name, this._children as ValuePattern[]);
-  }
-
-  getTokens() {
-    const tokens = this._children.map((c) => c.getTokens());
-
-    const hasPrimitiveTokens = tokens.every((t) =>
-      t.every((value) => typeof value === "string")
-    );
-
-    if (hasPrimitiveTokens && tokens.length > 0) {
-      return tokens.reduce((acc, t) => acc.concat(t), []);
-    }
-
-    return this._children[0].getTokens();
-  }
-}

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");
-  });
-});