clarity-pattern-parser 4.0.3 → 6.0.0

package/src/ast/Visitor.ts

@@ -1,271 +0,0 @@
-import Node from "./Node";
-
-export default class Visitor {
-  public root: Node | null;
-  public selectedNodes: Node[];
-
-  constructor(root: Node | null = null, selectedNodes: Node[] = []) {
-    this.root = root;
-    this.selectedNodes = selectedNodes;
-  }
-
-  flatten() {
-    this.selectedNodes.forEach((node) => {
-      if (node.children.length > 0) {
-        const children: Node[] = [];
-
-        Visitor.walkUp(node, (descendant: Node) => {
-          if (descendant.children.length === 0) {
-            children.push(descendant);
-          }
-        });
-
-        node.children = children;
-      }
-    });
-
-    return this;
-  }
-
-  remove() {
-    if (this.root == null) {
-      return this;
-    }
-
-    this.recursiveRemove(this.root);
-    return this;
-  }
-
-  private recursiveRemove(node: Node) {
-    const nodesToRemove = this.selectedNodes;
-    for (let x = 0; x < node.children.length; x++) {
-      if (nodesToRemove.indexOf(node.children[x]) > -1) {
-        node.children.splice(x, 1);
-        x--;
-      } else {
-        this.recursiveRemove(node.children[x]);
-      }
-    }
-  }
-
-  wrap(callback: (node: Node) => Node) {
-    const visitor = new Visitor(this.root);
-
-    visitor.selectRoot().transform((node) => {
-      if (this.selectedNodes.includes(node)) {
-        return callback(node);
-      }
-      return node;
-    });
-
-    return this;
-  }
-
-  unwrap() {
-    if (this.root == null) {
-      return this;
-    }
-
-    Visitor.walkDown(this.root, (node, stack) => {
-      if (this.selectedNodes.includes(node)) {
-        const parent = stack[stack.length - 1];
-        const grandParent = stack[stack.length - 2];
-
-        if (parent != null && grandParent != null) {
-          const index = grandParent.children.indexOf(parent);
-          if (index > -1) {
-            grandParent.children.splice(index, 1, ...parent.children);
-          }
-        }
-      }
-    });
-
-    return this;
-  }
-
-  prepend(callback: (node: Node) => Node) {
-    if (this.root == null) {
-      return this;
-    }
-
-    Visitor.walkUp(this.root, (node, stack) => {
-      if (this.selectedNodes.includes(node)) {
-        const parent = stack[stack.length - 1];
-
-        if (parent != null) {
-          const index = parent.children.indexOf(node);
-          if (index > -1) {
-            parent.children.splice(index, 0, callback(node));
-          }
-        }
-      }
-    });
-
-    return this;
-  }
-
-  append(callback: (node: Node) => Node) {
-    if (this.root == null) {
-      return this;
-    }
-
-    Visitor.walkDown(this.root, (node, stack) => {
-      if (this.selectedNodes.includes(node)) {
-        const parent = stack[stack.length - 1];
-
-        if (parent != null) {
-          const index = parent.children.indexOf(node);
-          if (index > -1) {
-            parent.children.splice(index + 1, 0, callback(node));
-          }
-        }
-      }
-    });
-
-    return this;
-  }
-
-  transform(callback: (node: Node) => Node) {
-    this.selectedNodes.forEach((node) => {
-      return this.recursiveTransform(node, callback);
-    });
-
-    return this;
-  }
-
-  private recursiveTransform(node: Node, callback: (node: Node) => Node) {
-    const length = node.children.length;
-
-    for (let x = 0; x < length; x++) {
-      node.children[x] = this.recursiveTransform(node.children[x], callback);
-    }
-
-    return callback(node);
-  }
-
-  selectAll() {
-    return this.select((n) => true);
-  }
-
-  selectNode(node: Node) {
-    return new Visitor(this.root, [...this.selectedNodes, node]);
-  }
-
-  deselectNode(node: Node) {
-    const visitor = new Visitor(this.root, this.selectedNodes.slice());
-    return visitor.filter((n) => n !== node);
-  }
-
-  select(callback: (node: Node) => boolean) {
-    if (this.root == null) {
-      return this;
-    }
-
-    const node = this.root;
-    const selectedNodes: Node[] = [];
-
-    if (node.children.length > 0) {
-      Visitor.walkDown(node, (descendant: Node) => {
-        if (callback(descendant)) {
-          selectedNodes.push(descendant);
-        }
-      });
-    }
-
-    return new Visitor(this.root, selectedNodes);
-  }
-
-  forEach(callback: (node: Node) => void) {
-    this.selectedNodes.forEach(callback);
-    return this;
-  }
-
-  filter(callback: (node: Node) => boolean) {
-    return new Visitor(this.root, this.selectedNodes.filter(callback));
-  }
-
-  map(callback: (node: Node) => Node) {
-    return new Visitor(this.root, this.selectedNodes.map(callback));
-  }
-
-  selectRoot() {
-    if (this.root == null) {
-      return this;
-    }
-
-    return new Visitor(this.root, [this.root]);
-  }
-
-  first() {
-    return this.get(0);
-  }
-
-  last() {
-    return this.get(this.selectedNodes.length - 1);
-  }
-
-  get(index: number) {
-    const node = this.selectedNodes[index];
-
-    if (node == null) {
-      throw new Error(
-        `Couldn't find node at index: ${index}, out of ${this.selectedNodes.length}.`
-      );
-    }
-
-    return new Visitor(node, []);
-  }
-
-  clear() {
-    this.selectedNodes = [];
-    return this;
-  }
-
-  setRoot(root: Node | null) {
-    this.root = root;
-    return this;
-  }
-
-  static select(root: Node, callback?: (node: Node) => boolean) {
-    if (callback != null) {
-      return new Visitor(root).select(callback);
-    } else {
-      return new Visitor(root);
-    }
-  }
-
-  static walkUp(
-    node: Node,
-    callback: (node: Node, ancestors: Node[]) => void,
-    ancestors: Node[] = []
-  ) {
-    ancestors.push(node);
-
-    if (node.children.length > 0) {
-      const children = node.children.slice();
-      children.forEach((c) => this.walkUp(c, callback, ancestors));
-    }
-
-    ancestors.pop();
-    callback(node, ancestors);
-
-    return this;
-  }
-
-  static walkDown(
-    node: Node,
-    callback: (node: Node, ancestors: Node[]) => void,
-    ancestors: Node[] = []
-  ) {
-    callback(node, ancestors);
-    ancestors.push(node);
-
-    if (node.children.length > 0) {
-      const children = node.children.slice();
-      children.forEach((c) => this.walkDown(c, callback, ancestors));
-    }
-
-    ancestors.pop();
-    return this;
-  }
-}

package/src/patterns/LookAhead.ts

@@ -1,32 +0,0 @@
-import Cursor from "../Cursor";
-import ParseError from "./ParseError";
-import Pattern from "./Pattern";
-
-export default class LookAhead extends Pattern {
-  constructor(pattern: Pattern) {
-    super("look-ahead", "look-ahead", [pattern]);
-  }
-
-  parse(cursor: Cursor) {
-    const mark = cursor.mark();
-    const node = this.children[0].parse(cursor);
-
-    if (cursor.hasUnresolvedError() || node == null) {
-      cursor.resolveError();
-      cursor.throwError(
-        new ParseError("Couldn't find look ahead pattern.", mark, this.children[0])
-      );
-      cursor.moveToMark(mark);
-    }
-
-    return null;
-  }
-
-  clone() {
-    return new LookAhead(this.children[0].clone());
-  }
-
-  getTokens() {
-    return [];
-  }
-}

package/src/patterns/Recursive.ts

@@ -1,92 +0,0 @@
-import Pattern from "./Pattern";
-import ParserError from "./ParseError";
-import Cursor from "../Cursor";
-
-export default class Recursive extends Pattern {
-  public isRecursing: boolean;
-  public pattern: Pattern | null = null;
-
-  constructor(name: string, isOptional = false) {
-    super("recursive", name, [], isOptional);
-    this.isRecursing = false;
-  }
-
-  getPattern() {
-    return this.climb(this.parent, (pattern: Pattern | null) => {
-      if (pattern == null) {
-        return false;
-      }
-      return (
-        pattern.type !== "recursive" &&
-        pattern.name === this.name
-      );
-    });
-  }
-
-  private climb(
-    pattern: Pattern | null,
-    isMatch: (pattern: Pattern | null) => boolean
-  ): Pattern | null {
-    if (isMatch(pattern)) {
-      return pattern;
-    } else {
-      if (pattern && pattern.parent != null) {
-        return this.climb(pattern.parent, isMatch);
-      }
-      return null;
-    }
-  }
-
-  parse(cursor: Cursor) {
-    if (this.pattern == null) {
-      const pattern = this.getPattern();
-
-      if (pattern == null) {
-        if (!this._isOptional) {
-          cursor.throwError(
-            new ParserError(
-              `Couldn't find parent pattern to recursively parse, with the name ${this.name}.`,
-              cursor.index,
-              this
-            )
-          );
-        }
-
-        return null;
-      }
-
-      this.pattern = pattern.clone();
-      this.pattern.parent = this;
-    }
-
-    const mark = cursor.mark();
-    const node = this.pattern.parse(cursor);
-
-    if (!cursor.hasUnresolvedError() && node != null) {
-      cursor.addMatch(this, node);
-    }
-
-    if (cursor.hasUnresolvedError() && this._isOptional) {
-      cursor.resolveError();
-      cursor.moveToMark(mark);
-    }
-
-    return node;
-  }
-
-  clone(name?: string, isOptional?: boolean) {
-    if (name == null) {
-      name = this.name;
-    }
-
-    if (isOptional == null) {
-      isOptional = this._isOptional;
-    }
-
-    return new Recursive(name, isOptional);
-  }
-
-  getTokens() {
-    return this.getPattern()?.getTokens() || [];
-  }
-}

package/src/tests/And.test.ts

@@ -1,180 +0,0 @@
-/** @jest-environment node */
-import And from "../patterns/And";
-import Literal from "../patterns/Literal";
-import Cursor from "../Cursor";
-
-describe("And", () => {
-  test("Success", () => {
-    const firstName = new Literal("first-name", "John");
-    const lastName = new Literal("last-name", "Doe");
-    const fullName = new And("full-name", [firstName, lastName]);
-    const cursor = new Cursor("JohnDoe");
-    const node = fullName.parse(cursor);
-
-    expect(node?.name).toBe("full-name");
-    expect(node?.value).toBe("JohnDoe");
-    expect(node?.startIndex).toBe(0);
-    expect(node?.endIndex).toBe(6);
-  });
-
-  test("First Part Match with optional Second part.", () => {
-    const firstName = new Literal("first-name", "John");
-    const lastName = new Literal("last-name", "Doe", true);
-    const fullName = new And("full-name", [firstName, lastName]);
-    const cursor = new Cursor("John");
-    const node = fullName.parse(cursor);
-
-    expect(node?.name).toBe("full-name");
-    expect(node?.value).toBe("John");
-    expect(node?.startIndex).toBe(0);
-    expect(node?.endIndex).toBe(3);
-  });
-
-  test("First Part Match, but run out for second part.", () => {
-    const firstName = new Literal("first-name", "John");
-    const lastName = new Literal("last-name", "Doe");
-    const fullName = new And("full-name", [firstName, lastName]);
-    const cursor = new Cursor("John");
-    const node = fullName.parse(cursor);
-
-    expect(node).toBe(null);
-  });
-
-  test("No Match", () => {
-    const firstName = new Literal("first-name", "John");
-    const lastName = new Literal("last-name", "Doe");
-    const fullName = new And("full-name", [firstName, lastName]);
-    const cursor = new Cursor("JaneDoe");
-    const node = fullName.parse(cursor);
-
-    expect(node).toBe(null);
-  });
-
-  test("Partial Match without optional siblings.", () => {
-    const firstName = new Literal("first-name", "John");
-    const lastName = new Literal("last-name", "Doe");
-    const fullName = new And("full-name", [firstName, lastName]);
-    const cursor = new Cursor("JohnSmith");
-    const node = fullName.parse(cursor);
-
-    expect(node).toBe(null);
-  });
-
-  test("Success with more to parse", () => {
-    const firstName = new Literal("first-name", "John");
-    const lastName = new Literal("last-name", "Doe");
-    const fullName = new And("full-name", [firstName, lastName]);
-    const cursor = new Cursor("JohnDoe JaneDoe");
-    const node = fullName.parse(cursor);
-
-    expect(node?.name).toBe("full-name");
-    expect(node?.value).toBe("JohnDoe");
-    expect(node?.startIndex).toBe(0);
-    expect(node?.endIndex).toBe(6);
-  });
-
-  test("Clone.", () => {
-    const firstName = new Literal("first-name", "John");
-    const lastName = new Literal("last-name", "Doe");
-    const fullName = new And("full-name", [firstName, lastName]);
-    const clone = fullName.clone();
-
-    const fullNamePatterns = fullName.children;
-    const _cloneChildren = clone.children;
-
-    expect(fullNamePatterns[0]).not.toBe(_cloneChildren[0]);
-    expect(fullNamePatterns[1]).not.toBe(_cloneChildren[1]);
-    expect(fullName.name).toBe(clone.name);
-  });
-
-  test("Clone with custom name.", () => {
-    const firstName = new Literal("first-name", "John");
-    const lastName = new Literal("last-name", "Doe");
-    const fullName = new And("full-name", [firstName, lastName]);
-    const clone = fullName.clone("full-name-2");
-
-    const fullNamePatterns = fullName.children;
-    const _cloneChildren = clone.children;
-
-    expect(fullNamePatterns[0]).not.toBe(_cloneChildren[0]);
-    expect(fullNamePatterns[1]).not.toBe(_cloneChildren[1]);
-    expect(clone.name).toBe("full-name-2");
-  });
-
-  test("Partial Match.", () => {
-    const firstName = new Literal("first-name", "John");
-    const lastName = new Literal("last-name", "Doe", true);
-    const fullName = new And("full-name", [
-      firstName,
-      lastName,
-    ]);
-    const result = fullName.parse(new Cursor("JohnBo"));
-
-    expect(result?.type).toBe("and");
-    expect(result?.name).toBe("full-name");
-    expect(result?.value).toBe("John");
-  });
-
-  test("Partial Match with string running out, and optional last name.", () => {
-    const firstName = new Literal("first-name", "John");
-    const lastName = new Literal("last-name", "Doe", true);
-    const fullName = new And("full-name", [
-      firstName,
-      lastName,
-    ]);
-    const result = fullName.parse(new Cursor("JohnDo"));
-
-    expect(result?.type).toBe("and");
-    expect(result?.name).toBe("full-name");
-    expect(result?.value).toBe("John");
-  });
-
-  test("Three parts first optional.", () => {
-    const firstName = new Literal("first-name", "John", true);
-    const middle = new Literal("middle", "Smith");
-    const lastName = new Literal("last-name", "Doe");
-
-    const fullName = new And("full-name", [
-      firstName,
-      middle,
-      lastName,
-    ]);
-    const result = fullName.parse(new Cursor("SmithDoe"));
-
-    expect(result?.value).toBe("SmithDoe");
-    expect(result?.type).toBe("and");
-    expect(result?.name).toBe("full-name");
-  });
-
-  test("Three parts middle optional.", () => {
-    const firstName = new Literal("first-name", "John");
-    const middle = new Literal("middle", "Smith", true);
-    const lastName = new Literal("last-name", "Doe");
-
-    const fullName = new And("full-name", [
-      firstName,
-      middle,
-      lastName,
-    ]);
-    const result = fullName.parse(new Cursor("JohnDo"));
-
-    expect(result).toBe(null);
-  });
-
-  test("Three parts third optional.", () => {
-    const firstName = new Literal("first-name", "John");
-    const middle = new Literal("middle", "Smith");
-    const lastName = new Literal("last-name", "Doe", true);
-
-    const fullName = new And("full-name", [
-      firstName,
-      middle,
-      lastName,
-    ]);
-    const result = fullName.parse(new Cursor("JohnSmith"));
-
-    expect(result?.value).toBe("JohnSmith");
-    expect(result?.type).toBe("and");
-    expect(result?.name).toBe("full-name");
-  });
-});

package/src/tests/ComplexExamples.test.ts

@@ -1,86 +0,0 @@
-/** @jest-environment node */
-import whitespace from "./javascriptPatterns/whitespace";
-import name from "./javascriptPatterns/name";
-import number from "./javascriptPatterns/number";
-import Cursor from "../Cursor";
-import filter from "./naturalLanguage/filter";
-import string from "./javascriptPatterns/string";
-import cssValue from "./cssPatterns/cssValue";
-
-describe("Complex Examples", () => {
-  test("Complex Examples: A Comment", () => {
-    const cursor = new Cursor(`/*
-          This is the comment!
-      */`);
-
-    const node = whitespace.parse(cursor);
-  });
-
-  test("Complex Examples: name", () => {
-    const validName = new Cursor("firstName1_2");
-    const invalidName = new Cursor("1_firstName");
-    const validNode = name.parse(validName);
-
-    expect(validNode?.name).toBe("name");
-    expect(validNode?.value).toBe("firstName1_2");
-
-    name.parse(invalidName);
-    expect(invalidName.hasUnresolvedError()).toBe(true);
-  });
-
-  test("Complex Examples: number", () => {
-    const validNumber = new Cursor("1234");
-    const invalidNumber = new Cursor("01234");
-    const validFraction = new Cursor("0.1");
-    const validExponent = new Cursor("1.23e+5");
-    const singleNumber = new Cursor("1");
-
-    const validNumberNode = number.parse(validNumber);
-    const validFractionNode = number.parse(validFraction);
-    const validExponentNode = number.parse(validExponent);
-    const singleNumberNode = number.parse(singleNumber);
-
-    expect(validNumberNode?.name).toBe("number");
-    expect(validNumberNode?.value).toBe("1234");
-
-    expect(validFractionNode?.name).toBe("number");
-    expect(validFractionNode?.value).toBe("0.1");
-
-    expect(validExponentNode?.name).toBe("number");
-    expect(validExponentNode?.value).toBe("1.23e+5");
-    expect(validExponent.didSuccessfullyParse()).toBe(true);
-
-    expect(singleNumberNode?.name).toBe("number");
-    expect(singleNumberNode?.value).toBe("1");
-
-    name.parse(invalidNumber);
-    expect(invalidNumber.hasUnresolvedError()).toBe(true);
-  });
-
-  test("Complex Examples: string", () => {
-    const testString = `"This is a string!."`;
-    const validString = new Cursor(testString);
-    const validStringNode = string.parse(validString);
-
-    expect(validStringNode?.name).toBe("string");
-    expect(validStringNode?.value).toBe(testString);
-  });
-
-  test("Complex Examples: Natural Language.", () => {
-    const validCursor = new Cursor(
-      "Match records where firstName is 'John' and lastName is 'Barnes'."
-    );
-    const invalidCursor = new Cursor("Match records where firstName ");
-    const node = filter.parse(validCursor);
-
-    try {
-      filter.parse(invalidCursor);
-    } catch (error) {}
-  });
-
-  test("Complex Examples: cssMethod", () => {
-    const result = cssValue.exec(
-      "linear-gradient(to left, #333, #333 50%, #eee 75%, #333 75%)"
-    );
-  });
-});