clarity-pattern-parser 3.0.16 → 4.0.0

package/src/patterns/composite/AndComposite.ts

@@ -1,159 +0,0 @@
-import CompositePattern from "./CompositePattern";
-import CompositeNode from "../../ast/CompositeNode";
-import ParseError from "../../patterns/ParseError";
-import OptionalValue from "../value/OptionalValue";
-import OptionalComposite from "./OptionalComposite";
-import Pattern from "../Pattern";
-import Cursor from "../../Cursor";
-
-
-export default class AndComposite extends CompositePattern {
-  public index!: number;
-  public nodes!: CompositeNode[];
-  public node!: CompositeNode | null;
-  public cursor!: Cursor;
-  public mark!: number;
-
-  constructor(name: string, patterns: Pattern[] = []) {
-    super("and-composite", 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 CompositeNode;
-
-      if (this.cursor.hasUnresolvedError()) {
-        this.cursor.moveToMark(this.mark);
-        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 ||
-        pattern instanceof OptionalComposite
-      );
-    });
-
-    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.nodes = this.nodes.filter((node) => node != null);
-
-      const lastNode = this.nodes[this.nodes.length - 1];
-      const startIndex = this.mark;
-      const endIndex = lastNode.endIndex;
-
-      this.node = new CompositeNode(
-        "and-composite",
-        this.name,
-        startIndex,
-        endIndex
-      );
-
-      this.node.children = this.nodes;
-
-      this.cursor.index = this.node.endIndex;
-      this.cursor.addMatch(this, this.node);
-    } else {
-      this.node = null;
-    }
-  }
-
-  clone(name?: string) {
-    if (typeof name !== "string") {
-      name = this.name;
-    }
-    return new AndComposite(name, this._children);
-  }
-
-  getTokens() {
-    let tokens: string[] = [];
-
-    for (let x = 0; x < this._children.length; x++) {
-      const child = this._children[x];
-
-      if (
-        child instanceof OptionalValue ||
-        child instanceof OptionalComposite
-      ) {
-        tokens = tokens.concat(child.getTokens());
-      } else {
-        tokens = tokens.concat(child.getTokens());
-        break;
-      }
-    }
-
-    return tokens;
-  }
-}

package/src/patterns/composite/CompositePattern.ts

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

package/src/patterns/composite/OptionalComposite.ts

@@ -1,37 +0,0 @@
-import CompositePattern from "./CompositePattern";
-import Pattern from "../Pattern";
-import Cursor from "../../Cursor";
-
-export default class OptionalComposite extends CompositePattern {
-	public mark: any;
-
-  constructor(pattern: Pattern) {
-    super("optional-composite", "optional-composite", [pattern]);
-  }
-
-  parse(cursor: Cursor) {
-    const mark = cursor.mark();
-    this.mark = mark;
-
-    const node = this.children[0].parse(cursor);
-
-    if (cursor.hasUnresolvedError()) {
-      cursor.resolveError();
-      cursor.moveToMark(mark);
-      return null;
-    } else {
-      if (node != null){
-        cursor.addMatch(this, node);
-      }
-      return node;
-    }
-  }
-
-  clone() {
-    return new OptionalComposite(this.children[0]);
-  }
-
-  getTokens() {
-    return this._children[0].getTokens();
-  }
-}

package/src/patterns/composite/OrComposite.ts

@@ -1,96 +0,0 @@
-import CompositePattern from "./CompositePattern";
-import OptionalValue from "../value/OptionalValue";
-import OptionalComposite from "./OptionalComposite";
-import Pattern from "../Pattern";
-import Cursor from "../../Cursor";
-
-export default class OrComposite extends CompositePattern {
-  public cursor: any;
-  public mark: any;
-  public index: any;
-  public node: any;
-
-  constructor(name: string, patterns: Pattern[]) {
-    super("or-composite", 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 || pattern instanceof OptionalComposite
-    );
-
-    if (hasOptionalChildren) {
-      throw new Error("OrComposite cannot have optional values.");
-    }
-  }
-
-  private _reset(cursor: Cursor) {
-    this.cursor = cursor;
-    this.mark = null;
-    this.index = 0;
-    this.node = null;
-    this.mark = cursor.mark();
-  }
-
-  parse(cursor: Cursor) {
-    this._reset(cursor);
-    this._tryPattern();
-
-    if (this.node != null) {
-      this.cursor.addMatch(this, this.node);
-    }
-
-    return this.node;
-  }
-
-  private _tryPattern() {
-    while (true) {
-      const pattern = this._children[this.index];
-
-      this.node = pattern.parse(this.cursor);
-
-      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.cursor.index = this.node.endIndex;
-        break;
-      }
-    }
-  }
-
-  clone(name?: string) {
-    if (typeof name !== "string") {
-      name = this.name;
-    }
-    return new OrComposite(name, this._children);
-  }
-
-  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/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,152 +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 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("");
-  }
-}