clarity-pattern-parser 3.0.15 → 4.0.0

package/src/patterns/Repeat.ts

@@ -0,0 +1,155 @@
+import Pattern from "./Pattern";
+import Node from "../ast/Node";
+import ParseError from "./ParseError";
+import Cursor from "../Cursor";
+
+export default class Repeat extends Pattern {
+  public _pattern: Pattern;
+  public _divider: Pattern;
+  public nodes: Node[] = [];
+  public cursor!: Cursor;
+  public mark: number = 0;
+  public node: Node | null = null;
+
+  constructor(
+    name: string,
+    pattern: Pattern,
+    divider?: Pattern,
+    isOptional = false
+  ) {
+    super(
+      "repeat",
+      name,
+      divider != null ? [pattern, divider] : [pattern],
+      isOptional
+    );
+
+    this._pattern = this.children[0];
+    this._divider = this.children[1];
+    this.assertArguments();
+  }
+
+  private assertArguments() {
+    if (this._pattern.isOptional) {
+      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.tryToParse();
+
+    return this.node;
+  }
+
+  private tryToParse() {
+    const cursor = this.safelyGetCursor();
+
+    while (true) {
+      const node = this._pattern.parse(cursor);
+
+      if (cursor.hasUnresolvedError()) {
+        this.processResult();
+        break;
+      } else if (node != null) {
+        this.nodes.push(node);
+
+        if (node.endIndex === cursor.lastIndex()) {
+          this.processResult();
+          break;
+        }
+
+        cursor.next();
+
+        if (this._divider != null) {
+          const mark = cursor.mark();
+          const node = this._divider.parse(cursor);
+
+          if (cursor.hasUnresolvedError()) {
+            cursor.moveToMark(mark);
+            this.processResult();
+            break;
+          } else if (node != null) {
+            this.nodes.push(node);
+
+            if (node.endIndex === cursor.lastIndex()) {
+              this.processResult();
+              break;
+            }
+
+            cursor.next();
+          }
+        }
+      }
+    }
+  }
+
+  private processResult() {
+    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) {
+      if (this._isOptional) {
+        this.cursor.moveToMark(this.mark);
+      } else  {
+        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 Node(
+        "repeat",
+        this.name,
+        this.nodes[0].startIndex,
+        this.nodes[this.nodes.length - 1].endIndex,
+        this.nodes,
+        value
+      );
+
+      this.cursor.index = this.node.endIndex;
+      this.cursor.addMatch(this, this.node);
+    }
+  }
+
+  private safelyGetCursor() {
+    const cursor = this.cursor;
+
+    if (cursor == null) {
+      throw new Error("Couldn't find cursor.");
+    }
+    return cursor;
+  }
+
+  clone(name?: string, isOptional?: boolean) {
+    if (name == null) {
+      name = this.name;
+    }
+
+    if (isOptional == null) {
+      isOptional = this._isOptional;
+    }
+
+    return new Repeat(name, this._pattern, this._divider, isOptional);
+  }
+
+  getTokens() {
+    return this._pattern.getTokens();
+  }
+}

package/src/tests/{AndValue.test.ts → And.test.ts}

@@ -1,20 +1,13 @@
 /** @jest-environment node */
-import AndValue from "../patterns/value/AndValue";
-import Literal from "../patterns/value/Literal";
-import OptionalValue from "../patterns/value/OptionalValue";
+import And from "../patterns/And";
+import Literal from "../patterns/Literal";
 import Cursor from "../Cursor";
 
-describe("AndValue", () => {
-  test("One Pattern", () => {
-    expect(() => {
-      new AndValue("and-value", [new Literal("literal", "LITERAL")]);
-    }).toThrow();
-  });
-
+describe("And", () => {
   test("Success", () => {
     const firstName = new Literal("first-name", "John");
     const lastName = new Literal("last-name", "Doe");
-    const fullName = new AndValue("full-name", [firstName, lastName]);
+    const fullName = new And("full-name", [firstName, lastName]);
     const cursor = new Cursor("JohnDoe");
     const node = fullName.parse(cursor);
 
@@ -26,11 +19,8 @@ describe("AndValue", () => {
 
   test("First Part Match with optional Second part.", () => {
     const firstName = new Literal("first-name", "John");
-    const lastName = new Literal("last-name", "Doe");
-    const fullName = new AndValue("full-name", [
-      firstName,
-      new OptionalValue(lastName),
-    ]);
+    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);
 
@@ -43,7 +33,7 @@ describe("AndValue", () => {
   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 AndValue("full-name", [firstName, lastName]);
+    const fullName = new And("full-name", [firstName, lastName]);
     const cursor = new Cursor("John");
     const node = fullName.parse(cursor);
 
@@ -53,7 +43,7 @@ describe("AndValue", () => {
   test("No Match", () => {
     const firstName = new Literal("first-name", "John");
     const lastName = new Literal("last-name", "Doe");
-    const fullName = new AndValue("full-name", [firstName, lastName]);
+    const fullName = new And("full-name", [firstName, lastName]);
     const cursor = new Cursor("JaneDoe");
     const node = fullName.parse(cursor);
 
@@ -63,7 +53,7 @@ describe("AndValue", () => {
   test("Partial Match without optional siblings.", () => {
     const firstName = new Literal("first-name", "John");
     const lastName = new Literal("last-name", "Doe");
-    const fullName = new AndValue("full-name", [firstName, lastName]);
+    const fullName = new And("full-name", [firstName, lastName]);
     const cursor = new Cursor("JohnSmith");
     const node = fullName.parse(cursor);
 
@@ -73,7 +63,7 @@ describe("AndValue", () => {
   test("Success with more to parse", () => {
     const firstName = new Literal("first-name", "John");
     const lastName = new Literal("last-name", "Doe");
-    const fullName = new AndValue("full-name", [firstName, lastName]);
+    const fullName = new And("full-name", [firstName, lastName]);
     const cursor = new Cursor("JohnDoe JaneDoe");
     const node = fullName.parse(cursor);
 
@@ -86,7 +76,7 @@ describe("AndValue", () => {
   test("Clone.", () => {
     const firstName = new Literal("first-name", "John");
     const lastName = new Literal("last-name", "Doe");
-    const fullName = new AndValue("full-name", [firstName, lastName]);
+    const fullName = new And("full-name", [firstName, lastName]);
     const clone = fullName.clone();
 
     const fullNamePatterns = fullName.children;
@@ -100,7 +90,7 @@ describe("AndValue", () => {
   test("Clone with custom name.", () => {
     const firstName = new Literal("first-name", "John");
     const lastName = new Literal("last-name", "Doe");
-    const fullName = new AndValue("full-name", [firstName, lastName]);
+    const fullName = new And("full-name", [firstName, lastName]);
     const clone = fullName.clone("full-name-2");
 
     const fullNamePatterns = fullName.children;
@@ -113,57 +103,57 @@ describe("AndValue", () => {
 
   test("Partial Match.", () => {
     const firstName = new Literal("first-name", "John");
-    const lastName = new Literal("last-name", "Doe");
-    const fullName = new AndValue("full-name", [
+    const lastName = new Literal("last-name", "Doe", true);
+    const fullName = new And("full-name", [
       firstName,
-      new OptionalValue(lastName),
+      lastName,
     ]);
     const result = fullName.parse(new Cursor("JohnBo"));
 
-    expect(result?.type).toBe("and-value");
+    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");
-    const fullName = new AndValue("full-name", [
+    const lastName = new Literal("last-name", "Doe", true);
+    const fullName = new And("full-name", [
       firstName,
-      new OptionalValue(lastName),
+      lastName,
     ]);
     const result = fullName.parse(new Cursor("JohnDo"));
 
-    expect(result?.type).toBe("and-value");
+    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");
+    const firstName = new Literal("first-name", "John", true);
     const middle = new Literal("middle", "Smith");
     const lastName = new Literal("last-name", "Doe");
 
-    const fullName = new AndValue("full-name", [
-      new OptionalValue(firstName),
+    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-value");
+    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");
+    const middle = new Literal("middle", "Smith", true);
     const lastName = new Literal("last-name", "Doe");
 
-    const fullName = new AndValue("full-name", [
+    const fullName = new And("full-name", [
       firstName,
-      new OptionalValue(middle),
+      middle,
       lastName,
     ]);
     const result = fullName.parse(new Cursor("JohnDo"));
@@ -174,17 +164,17 @@ describe("AndValue", () => {
   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");
+    const lastName = new Literal("last-name", "Doe", true);
 
-    const fullName = new AndValue("full-name", [
+    const fullName = new And("full-name", [
       firstName,
       middle,
-      new OptionalValue(lastName),
+      lastName,
     ]);
     const result = fullName.parse(new Cursor("JohnSmith"));
 
     expect(result?.value).toBe("JohnSmith");
-    expect(result?.type).toBe("and-value");
+    expect(result?.type).toBe("and");
     expect(result?.name).toBe("full-name");
   });
 });

package/src/tests/CursorHistory.test.ts

@@ -1,12 +1,12 @@
 /** @jest-environment node */
 import CursorHistory from "../CursorHistory";
-import { Literal, ValueNode, Cursor, ParseError } from "../index";
+import { Literal, Node, Cursor, ParseError } from "../index";
 import sentence from "./patterns/sentence";
 describe("CursorHistory", () => {
   test("addMatch", () => {
     const cursorHistory = new CursorHistory();
     const pattern = new Literal("T", "T");
-    const node = new ValueNode("T", "T", "T", 0, 1);
+    const node = new Node("T", "T", 0, 1, [], "T");
 
     cursorHistory.addMatch(pattern, node);
     expect(cursorHistory.getFurthestMatch().pattern).toBe(pattern);
@@ -16,7 +16,7 @@ describe("CursorHistory", () => {
   test("addMatch with Recording", () => {
     const cursorHistory = new CursorHistory();
     const pattern = new Literal("T", "T");
-    const node = new ValueNode("T", "T", "T", 0, 1);
+    const node = new Node("T", "T", 0, 1, [], "T");
 
     cursorHistory.startRecording();
     cursorHistory.addMatch(pattern, node);
@@ -98,10 +98,10 @@ describe("CursorHistory", () => {
     const stack = cursor.history.getLastParseStack();
 
     expect(stack.length).toBe(5);
-    expect(stack[0].name).toBe("pat");
+    expect(stack[0].name).toBe("noun");
     expect(stack[1].name).toBe("space");
-    expect(stack[2].name).toBe("went-to");
+    expect(stack[2].name).toBe("verb");
     expect(stack[3].name).toBe("space");
-    expect(stack[4].name).toBe("the");
+    expect(stack[4].name).toBe("article");
   });
 });

package/src/tests/Cusor.test.ts

@@ -1,13 +1,10 @@
 /** @jest-environment node */
-import Cursor from "../Cursor";
-import ValueNode from "../ast/ValueNode";
-import Literal from "../patterns/value/Literal";
-import ParseError from "../patterns/ParseError";
+import { Cursor, Literal, ParseError, Node } from "../index";
 
 describe("Cursor", () => {
   test("addMatch.", () => {
     const cursor = new Cursor("Text");
-    const node = new ValueNode("text-node", "Text", "Text", 0, 3);
+    const node = new Node("text-node", "Text", 0, 3, [], "Text");
     const pattern = new Literal("text", "Text");
 
     cursor.setIndex(3);
@@ -19,10 +16,10 @@ describe("Cursor", () => {
 
   test("addMatch that isn't as far.", () => {
     const cursor = new Cursor("Text");
-    const node = new ValueNode("text-node", "Text", "Text", 0, 3);
+    const node = new Node("text-node", "Text", 0, 3, [], "Text");
     const pattern = new Literal("text", "Text Node");
 
-    const shorterNode = new ValueNode("tex-node", "Tex", "Tex", 0, 2);
+    const shorterNode = new Node("tex-node", "Tex", 0, 2, [], "Tex2");
     const shorterPattern = new Literal("tex", "Tex");
 
     cursor.setIndex(3);
@@ -80,13 +77,13 @@ describe("Cursor", () => {
 
   test("recording history.", () => {
     const cursor = new Cursor("Text");
-    const tNode = new ValueNode("T", "T", "T", 0, 0);
+    const tNode = new Node("T", "T", 0, 0, [], "T");
     const tPattern = new Literal("T", "T");
 
-    const eNode = new ValueNode("e", "e", "e", 1, 1);
+    const eNode = new Node("e", "e", 1, 1, [], "e");
     const ePattern = new Literal("e", "e");
 
-    const xNode = new ValueNode("x", "x", "x", 2, 2);
+    const xNode = new Node("x", "x", 2, 2, [], "x");
     const xPattern = new Literal("x", "x");
 
     cursor.startRecording();

package/src/tests/Literal.test.ts

@@ -1,6 +1,5 @@
 /** @jest-environment node */
-import Literal from "../patterns/value/Literal";
-import Cursor from "../Cursor";
+import { Literal, Cursor } from "../index";
 
 describe("Literal", () => {
   test("Empty literal.", () => {
@@ -16,13 +15,12 @@ describe("Literal", () => {
     const result2 = john.exec("Jane");
 
     const expectedValue = {
-      children: [],
-      value: "John",
       type: "literal",
       name: "john",
       startIndex: 0,
       endIndex: 3,
-      isComposite: false,
+      children: [],
+      value: "John",
     };
 
     expect(JSON.stringify(result)).toBe(JSON.stringify(expectedValue));

package/src/tests/LookAhead.test.ts

@@ -0,0 +1,44 @@
+/** @jest-environment node */
+import { Literal, Cursor, LookAhead, Not } from "../index";
+
+describe("LookAheadValue", () => {
+  test("Look for pattern.", () => {
+    const john = new Literal("john", "John");
+    const lookAheadValue = new LookAhead(john);
+    const cursor = new Cursor("John");
+    const node = lookAheadValue.parse(cursor);
+
+    expect(node).toBe(null);
+    expect(cursor.hasUnresolvedError()).toBe(false);
+  });
+
+  test("Look for a not pattern.", () => {
+    const john = new Literal("john", "John");
+    const lookAheadValue = new Not(new LookAhead(john));
+    const cursor = new Cursor("Joel");
+    const node = lookAheadValue.parse(cursor);
+
+    expect(node).toBe(null);
+    expect(cursor.hasUnresolvedError()).toBe(false);
+  });
+
+  test("Fail looking for a pattern.", () => {
+    const john = new Literal("john", "John");
+    const lookAheadValue = new LookAhead(john);
+    const cursor = new Cursor("Joel");
+    const node = lookAheadValue.parse(cursor);
+
+    expect(node).toBe(null);
+    expect(cursor.hasUnresolvedError()).toBe(true);
+  });
+
+  test("And a look ahead together.", () => {
+    const john = new Literal("john", "John");
+    const lookAheadValue = new LookAhead(john);
+    const cursor = new Cursor("Joel");
+    const node = lookAheadValue.parse(cursor);
+
+    expect(node).toBe(null);
+    expect(cursor.hasUnresolvedError()).toBe(true);
+  });
+});

package/src/tests/Not.test.ts

@@ -0,0 +1,51 @@
+import Cursor from "../Cursor";
+import And from "../patterns/And";
+import Literal from "../patterns/Literal";
+import Not from "../patterns/Not";
+import Or from "../patterns/Or";
+import Regex from "../patterns/Regex";
+
+describe("Not", () => {
+  test("Negate pattern with literal.", () => {
+    const greaterThan = new Literal("greater-than", ">");
+    const lessThan = new Literal("less-than", "<");
+    const from = new Literal("from", "FROM");
+    const table = new Literal("table", "Table");
+    const operator = new Or("operator", [lessThan, greaterThan]);
+    const keywords = new And("keywords-with-space", [
+      new Or("keywords", [from, table]),
+      new Literal("space", " "),
+    ]);
+    const identFirstPart = new Regex(
+      "ident-first-part",
+      "[a-zA-Z_$][a-zA-Z0-9_]*"
+    );
+    const identity = new And("identity", [
+      new Not(keywords),
+      new Not(operator),
+      identFirstPart,
+    ]);
+
+    const result = identity.parse(new Cursor("_goodName"));
+
+    expect(result).not.toBeNull();
+
+    const cursor1 = new Cursor("<badName");
+    const result1 = identity.parse(cursor1);
+
+    expect(result1).toBe(null);
+    expect(cursor1.hasUnresolvedError()).toBe(true);
+
+    const cursor2 = new Cursor("FROM_IS_OKAY");
+    const result2 = identity.parse(cursor2);
+
+    expect(result2).not.toBe(null);
+    expect(cursor2.hasUnresolvedError()).toBe(false);
+
+    const cursor3 = new Cursor("FROM ISBAD");
+    const result3 = identity.parse(cursor3);
+
+    expect(result3).toBe(null);
+    expect(cursor3.hasUnresolvedError()).toBe(true);
+  });
+});

package/src/tests/Or.test.ts

@@ -0,0 +1,113 @@
+/** @jest-environment node */
+import Or from "../patterns/Or";
+import Literal from "../patterns/Literal";
+import Cursor from "../Cursor";
+
+describe("Or", () => {
+  test("Or: Empty array parser.", () => {
+    expect(() => {
+      new Or("name", []);
+    }).toThrow();
+  });
+
+  test("Or: One Pattern.", () => {
+    expect(() => {
+      new Or("name", [new Literal("some-value", "")]);
+    }).toThrow();
+  });
+
+  test("Or: Name and patterns.", () => {
+    const letter = new Literal("a", "a");
+    const number = new Literal("1", "1");
+    const alphaNumeric = new Or("alpha-numeric", [letter, number]);
+
+    const letterCursor = new Cursor("a");
+    const numberCursor = new Cursor("1");
+
+    const letterNode = alphaNumeric.parse(letterCursor);
+    const numberNode = alphaNumeric.parse(numberCursor);
+
+    expect(letterNode?.name).toBe("alpha-numeric");
+    expect(letterNode?.value).toBe("a");
+
+    expect(numberNode?.name).toBe("alpha-numeric");
+    expect(numberNode?.value).toBe("1");
+  });
+
+  test("Or: Fail.", () => {
+    const letter = new Literal("a", "a");
+    const number = new Literal("1", "1");
+    const alphaNumeric = new Or("alpha-numeric", [letter, number]);
+
+    const letterCursor = new Cursor("b");
+    const numberCursor = new Cursor("2");
+
+    const letterNode = alphaNumeric.parse(letterCursor);
+    const numberNode = alphaNumeric.parse(numberCursor);
+
+    expect(letterNode).toBe(null);
+    expect(numberNode).toBe(null);
+  });
+
+  test("Or: Clone.", () => {
+    const letter = new Literal("a", "a");
+    const number = new Literal("1", "1");
+    const alphaNumeric = new Or("alpha-numeric", [letter, number]);
+
+    const clone = alphaNumeric.clone();
+
+    expect(alphaNumeric.children.length).toBe(clone.children.length);
+    expect(alphaNumeric.name).toBe(clone.name);
+  });
+
+  test("Or: Invalid patterns.", () => {
+    expect(() => {
+      new (Or as any)("some-alpha-numeric", [{}, null]);
+    });
+  });
+
+  test("Or: Not enough patterns.", () => {
+    expect(() => {
+      new (Or as any)("some-alpha-numeric", [{}]);
+    });
+  });
+
+  test("Or: Bad name.", () => {
+    expect(() => {
+      new (Or as any)({}, [new Literal("a", "a"), new Literal("a", "a")]);
+    });
+  });
+
+  test("Or: Bad cursor.", () => {
+    expect(() => {
+      new (Or as any)("A", [
+        new Literal("a", "a"),
+        new Literal("a", "a"),
+      ]).parse();
+    });
+  });
+
+  test("Or: Furthest Parse Error.", () => {
+    const longer = new Literal("longer", "Longer");
+    const bang = new Literal("bang", "Bang");
+    const orValue = new (Or as any)("test", [longer, bang]);
+    const cursor = new Cursor("Longed");
+
+    orValue.parse(cursor);
+
+    expect(cursor.getIndex()).toBe(0);
+    expect(cursor.hasUnresolvedError()).toBe(true);
+  });
+
+  test("Or: Last pattern matches.", () => {
+    const longer = new Literal("longer", "Longer");
+    const bang = new Literal("bang", "Bang");
+    const orValue = new (Or as any)("test", [longer, bang]);
+    const cursor = new Cursor("Bang");
+
+    const node = orValue.parse(cursor);
+
+    expect(node.name).toBe("test");
+    expect(node.value).toBe("Bang");
+  });
+});