clarity-pattern-parser 3.0.15 → 4.0.0

package/src/patterns/composite/RepeatComposite.ts

@@ -1,130 +0,0 @@
-import CompositePattern from "./CompositePattern";
-import CompositeNode from "../../ast/CompositeNode";
-import ParseError from "../ParseError";
-import OptionalComposite from "./OptionalComposite";
-import Pattern from "../Pattern";
-import Cursor from "../../Cursor";
-import Node from "../../ast/Node";
-
-export default class RepeatComposite extends CompositePattern {
-  private _pattern: Pattern;
-  private _divider: Pattern;
-  public nodes: Node[] = [];
-  public cursor!: Cursor;
-  public mark: number = 0;
-  public node: CompositeNode | null = null;
-
-  constructor(name: string, pattern: Pattern, divider?: Pattern) {
-    super(
-      "repeat-composite",
-      name,
-      divider != null ? [pattern, divider] : [pattern]
-    );
-    this._pattern = this.children[0];
-    this._divider = this.children[1];
-    this._assertArguments();
-  }
-
-  private _assertArguments() {
-    if (this._pattern instanceof OptionalComposite) {
-      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);
-
-      if (this.cursor.hasUnresolvedError() || node == null) {
-        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);
-
-          if (this.cursor.hasUnresolvedError() || node == null) {
-            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) {
-      this.cursor.throwError(
-        new ParseError(
-          `Did not find a repeating match of ${this.name}.`,
-          this.mark,
-          this
-        )
-      );
-      this.node = null;
-    } else {
-      this.node = new CompositeNode(
-        "repeat-composite",
-        this.name,
-        this.nodes[0].startIndex,
-        this.nodes[this.nodes.length - 1].endIndex
-      );
-
-      this.node.children = this.nodes;
-      this.cursor.index = this.node.endIndex;
-
-      this.cursor.addMatch(this, this.node);
-    }
-  }
-
-  clone(name?: string) {
-    if (typeof name !== "string") {
-      name = this.name;
-    }
-    return new RepeatComposite(name, this._pattern, this._divider);
-  }
-
-  getTokens() {
-    return this._pattern.getTokens();
-  }
-}

package/src/patterns/value/AndValue.ts

@@ -1,153 +0,0 @@
-import ValuePattern from "./ValuePattern";
-import ValueNode from "../../ast/ValueNode";
-import ParseError from "../../patterns/ParseError";
-import OptionalValue from "./OptionalValue";
-import Permutor from "../../Permutor";
-import Pattern from "../Pattern";
-import Cursor from "../../Cursor";
-
-const permutor = new Permutor();
-
-export default class AndValue extends ValuePattern {
-  public index: number = 0;
-  public nodes: ValueNode[] = [];
-  public node: ValueNode | null = null;
-  public cursor!: Cursor;
-  public mark: number = 0;
-
-  constructor(name: string, patterns: ValuePattern[]) {
-    super("and-value", name, patterns);
-    this._assertArguments();
-  }
-
-  private _assertArguments() {
-    if (this._children.length < 2) {
-      throw new Error(
-        "Invalid Argument: AndValue needs to have more than one value pattern."
-      );
-    }
-  }
-
-  private _reset(cursor: Cursor) {
-    this.index = 0;
-    this.nodes = [];
-    this.node = null;
-    this.cursor = cursor;
-    this.mark = this.cursor.mark();
-  }
-
-  parse(cursor: Cursor) {
-    this._reset(cursor);
-    this._tryPatterns();
-
-    return this.node;
-  }
-
-  private _tryPatterns() {
-    while (true) {
-      const pattern = this._children[this.index];
-      const node = pattern.parse(this.cursor) as ValueNode;
-
-      if (this.cursor.hasUnresolvedError()) {
-        break;
-      } else {
-        this.nodes.push(node);
-      }
-
-      if (!this._next()) {
-        this._processValue();
-        break;
-      }
-    }
-  }
-
-  private _next() {
-    if (this._hasMorePatterns()) {
-      if (this.cursor.hasNext()) {
-        // If the last result was a failed optional, then don't increment the cursor.
-        if (this.nodes[this.nodes.length - 1] != null) {
-          this.cursor.next();
-        }
-
-        this.index++;
-        return true;
-      } else if (this.nodes[this.nodes.length - 1] == null) {
-        this.index++;
-        return true;
-      }
-
-      this._assertRestOfPatternsAreOptional();
-      return false;
-    } else {
-      return false;
-    }
-  }
-
-  private _hasMorePatterns() {
-    return this.index + 1 < this._children.length;
-  }
-
-  private _assertRestOfPatternsAreOptional() {
-    const areTheRestOptional = this.children.every((pattern, index) => {
-      return index <= this.index || pattern instanceof OptionalValue;
-    });
-
-    if (!areTheRestOptional) {
-      const parseError = new ParseError(
-        `Could not match ${this.name} before string ran out.`,
-        this.index,
-        this
-      );
-
-      this.cursor.throwError(parseError);
-    }
-  }
-
-  private _processValue() {
-    if (this.cursor.hasUnresolvedError()) {
-      this.node = null;
-    } else {
-      this.nodes = this.nodes.filter((node) => node != null);
-
-      const lastNode = this.nodes[this.nodes.length - 1];
-      const startIndex = this.mark;
-      const endIndex = lastNode.endIndex;
-      const value = this.nodes.map((node) => node.value).join("");
-
-      this.node = new ValueNode(
-        "and-value",
-        this.name,
-        value,
-        startIndex,
-        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 AndValue(name, this._children as ValuePattern[]);
-  }
-
-  getTokens() {
-    let tokens: string[] = [];
-
-    for (let x = 0; x < this._children.length; x++) {
-      const child = this._children[x];
-
-      if (child instanceof OptionalValue) {
-        tokens = tokens.concat(child.getTokens());
-      } else {
-        tokens = tokens.concat(child.getTokens());
-        break;
-      }
-    }
-
-    return tokens;
-  }
-}

package/src/patterns/value/AnyOfThese.ts

@@ -1,81 +0,0 @@
-import ValuePattern from "./ValuePattern";
-import ParseError from "../ParseError";
-import ValueNode from "../../ast/ValueNode";
-import Pattern from "../Pattern";
-import Cursor from "../../Cursor";
-
-export default class AnyOfThese extends ValuePattern {
-  public characters: string;
-  public node: ValueNode | null = null;
-  public cursor!: Cursor;
-  public mark: number = 0;
-
-  constructor(name: string, characters: string) {
-    super("any-of-these", name);
-    this.characters = characters;
-    this._assertArguments();
-  }
-
-  private _assertArguments() {
-    if (typeof this.characters !== "string") {
-      throw new Error(
-        "Invalid Arguments: The characters argument needs to be a string of characters."
-      );
-    }
-
-    if (this.characters.length < 1) {
-      throw new Error(
-        "Invalid Arguments: The characters 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.node = null;
-  }
-
-  private _tryPattern() {
-    if (this._isMatch()) {
-      const value = this.cursor.getChar();
-      const index = this.cursor.getIndex();
-
-      this.node = new ValueNode("any-of-these", this.name, value, index, index);
-
-      this.cursor.addMatch(this, this.node);
-    } else {
-      this._processError();
-    }
-  }
-
-  private _isMatch() {
-    return this.characters.indexOf(this.cursor.getChar()) > -1;
-  }
-
-  private _processError() {
-    const message = `ParseError: Expected one of these characters, '${
-      this.characters
-    }' but found '${this.cursor.getChar()}' while parsing for '${this.name}'.`;
-
-    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 AnyOfThese(name, this.characters);
-  }
-
-  getTokens() {
-    return this.characters.split("");
-  }
-}

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