clarity-pattern-parser 3.0.15 → 3.0.16

package/src/patterns/ReferencePattern.ts

@@ -0,0 +1,123 @@
+import Pattern from "./Pattern";
+import ParserError from "./ParseError";
+import Cursor from "../Cursor";
+
+export default class ReferencePattern extends Pattern {
+  private isRecursing: boolean;
+
+  constructor(name: string) {
+    super("reference", name);
+    this.isRecursing = false;
+  }
+
+  private getRoot() {
+    let node = this.parent;
+    while (node != null) {
+      if (node.parent == null) {
+        return node;
+      }
+      node = node.parent;
+    }
+    return node;
+  }
+
+  private findPattern(): Pattern | null {
+    const root = this.getRoot();
+    let result: Pattern | null = null;
+
+    if (root == null) {
+      return null;
+    }
+
+    this.walkTheTree(root, (pattern) => {
+      if (
+        pattern.name === this.name &&
+        pattern != this &&
+        pattern.type != "reference"
+      ) {
+        result = pattern;
+        return false;
+      }
+      return true;
+    });
+
+    return result;
+  }
+
+  private walkTheTree(
+    pattern: Pattern,
+    callback: (pattern: Pattern) => boolean
+  ) {
+    for (let x = 0; x < pattern.children.length; x++) {
+      const p = pattern.children[x];
+      const continueWalking = this.walkTheTree(p, callback);
+
+      if (!continueWalking) {
+        return false;
+      }
+    }
+
+    return callback(pattern);
+  }
+
+  parse(cursor: Cursor) {
+    try {
+      const node = this.safelyGetPattern().parse(cursor);
+
+      if (!cursor.hasUnresolvedError() && node != null) {
+        cursor.addMatch(this, node);
+      }
+
+      return node;
+    } catch (error) {
+      cursor.throwError(
+        new ParserError(
+          `Couldn't find reference pattern to parse, with the name ${this.name}.`,
+          cursor.index,
+          this as Pattern
+        )
+      );
+
+      return null;
+    }
+  }
+
+  clone(name?: string): Pattern {
+    if (typeof name !== "string") {
+      name = this.name;
+    }
+    return new ReferencePattern(name);
+  }
+
+  getTokenValue() {
+    return this.safelyGetPattern().getTokenValue();
+  }
+
+  private safelyGetPattern() {
+    let pattern = this.children[0];
+    const hasNoPattern = pattern == null;
+
+    if (hasNoPattern) {
+      const reference = this.findPattern();
+      if (reference == null) {
+        throw new Error(
+          `Couldn't find reference pattern, with the name ${this.name}.`
+        );
+      }
+
+      return reference;
+    }
+    return pattern;
+  }
+
+  getTokens() {
+    if (!this.isRecursing) {
+      this.isRecursing = true;
+      let pattern = this.safelyGetPattern();
+      const tokens = pattern.getTokens();
+      this.isRecursing = false;
+      return tokens;
+    }
+    return [];
+  }
+}

package/src/patterns/value/AndValue.ts

@@ -3,7 +3,6 @@ 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();

package/src/tests/LookAhead.test.ts

@@ -0,0 +1,93 @@
+/** @jest-environment node */
+import Literal from "../patterns/value/Literal";
+import Cursor from "../Cursor";
+import LookAhead from "../patterns/LookAhead";
+import NotValue from "../patterns/value/NotValue";
+import OrValue from "../patterns/value/OrValue";
+import RegexValue from "../patterns/value/RegexValue";
+import AndValue from "../patterns/value/AndValue";
+
+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 LookAhead(new NotValue("not-john", 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);
+  });
+
+  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 OrValue("operator", [lessThan, greaterThan]);
+    const keywords = new AndValue("keywords-with-space", [
+      new OrValue("keywords", [from, table]),
+      new Literal("space", " "),
+    ]);
+    const identFirstPart = new RegexValue(
+      "ident-first-part",
+      "[a-zA-Z_$][a-zA-Z0-9_]*"
+    );
+    const identity = new AndValue("identity", [
+      new LookAhead(new NotValue("not-keywords", keywords)),
+      new LookAhead(new NotValue("not-operator", 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/NotValue.test.ts

@@ -2,6 +2,10 @@
 import NotValue from "../patterns/value/NotValue";
 import Literal from "../patterns/value/Literal";
 import Cursor from "../Cursor";
+import OrValue from "../patterns/value/OrValue";
+import AndValue from "../patterns/value/AndValue";
+import RepeatValue from "../patterns/value/RepeatValue";
+import RegexValue from "../patterns/value/RegexValue";
 
 describe("NotValue", () => {
   test("Empty Constructor.", () => {
@@ -66,4 +70,7 @@ describe("NotValue", () => {
 
     expect(notJohn.name).toBe(clone.name);
   });
+
+  
+
 });

package/src/tests/Pattern.test.ts

@@ -211,9 +211,8 @@ describe("ValuePattern", () => {
     expect(tokens[1]).toBe("Doe");
 
     tokens = fullName.children[1].children[1].getNextTokens();
-    expect(tokens.length).toBe(2);
+    expect(tokens.length).toBe(1);
     expect(tokens[0]).toBe("Edward");
-    expect(tokens[1]).toBe("Doe");
   });
 
   test("getNextTokens, has child and at the beginning.", () => {

package/src/tests/ReferencePattern.test.ts

@@ -0,0 +1,24 @@
+import Cursor from "../Cursor";
+import ReferencePattern from "../patterns/ReferencePattern";
+import AndValue from "../patterns/value/AndValue";
+import Literal from "../patterns/value/Literal";
+import OrValue from "../patterns/value/OrValue";
+
+describe("ReferencePattern", () => {
+  test("Reference to node in different branch.", () => {
+    const a = new Literal("a", "a");
+    const b = new Literal("b", "b");
+    const c = new Literal("c", "c");
+    const a_b_c = new AndValue("a-and-b-and-c", [
+      a,
+      b,
+      new ReferencePattern("c"),
+    ]);
+    const b_c = new AndValue("b-and-c", [b, c]);
+    const main = new OrValue("main", [a_b_c, b_c]);
+
+    const result = main.parse(new Cursor("abc"));
+
+    expect(result).not.toBeNull();
+  });
+});

package/src/tests/javascriptPatterns/json.ts

@@ -75,3 +75,5 @@ const json = new OrComposite("literals", [
 ]);
 
 export default json;
+
+