clarity-pattern-parser 4.0.3 → 6.0.0

package/src/patterns/Not.test.ts

@@ -0,0 +1,168 @@
+import { And } from "./And";
+import { Cursor } from "./Cursor";
+import { Literal } from "./Literal";
+import { Not } from "./Not";
+import { Pattern } from "./Pattern";
+
+describe("Not", () => {
+    test("Parse Successfully", () => {
+        const a = new Literal("a", "A");
+        const notA = new Not("not-a", a);
+        const cursor = new Cursor("B");
+        const result = notA.parse(cursor);
+
+        expect(result).toBeNull();
+        expect(cursor.hasError).toBeFalsy();
+    });
+
+    test("Parse Failed", () => {
+        const a = new Literal("a", "A");
+        const notA = new Not("not-a", a);
+        const cursor = new Cursor("A");
+        const result = notA.parse(cursor);
+
+        expect(result).toBeNull();
+        expect(cursor.hasError).toBeTruthy();
+    });
+
+    test("Clone", () => {
+        const a = new Literal("a", "A");
+        const notA = new Not("not-a", a);
+        const clone = notA.clone();
+
+        expect(clone.name).toBe("not-a");
+        expect(clone).not.toBe(notA)
+    });
+
+    test("Tokens", () => {
+        const a = new Literal("a", "A");
+        const notA = new Not("not-a", a);
+        const tokens = notA.getTokens();
+        const nextTokens = notA.getTokensAfter(new Literal("bogus", "bogus"))
+        const emptyArray: string[] = [];
+
+        expect(tokens).toEqual(emptyArray);
+        expect(nextTokens).toEqual(emptyArray);
+    });
+
+    test("Properties", () => {
+        const a = new Literal("a", "A");
+        const notA = new Not("not-a", a);
+
+        expect(notA.type).toBe("not");
+        expect(notA.name).toBe("not-a");
+        expect(notA.parent).toBeNull();
+        expect(notA.children[0].name).toBe("a");
+        expect(notA.isOptional).toBeFalsy();
+    });
+
+    test("Not A Not", () => {
+        const a = new Literal("a", "A");
+        const notA = new Not("not-a", a);
+        const notnotA = new Not("not-not-a", notA);
+
+        const cursor = new Cursor("A");
+        const result = notnotA.parse(cursor);
+
+        expect(result).toBeNull();
+        expect(cursor.hasError).toBeFalsy();
+    });
+
+    test("Exec", () => {
+        const a = new Literal("a", "A");
+        const notA = new Not("not-a", a);
+        const { ast: result } = notA.exec("A");
+
+        expect(result).toBeNull();
+    });
+
+    test("Test", () => {
+        const a = new Literal("a", "A");
+        const notA = new Not("not-a", a);
+        const result = notA.test("A");
+
+        expect(result).toBeFalsy();
+    });
+
+    test("Get Next Tokens", () => {
+        const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
+        const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
+
+        const cloneNotAboutUs = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
+        const nextTokens = cloneNotAboutUs.getNextTokens() || [];
+
+        expect(nextTokens[0]).toBe("About Them");
+    });
+
+    test("Get Next Tokens With No Parent", () => {
+        const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
+        const nextTokens = notAboutUs.getNextTokens() || [];
+
+        expect(nextTokens.length).toBe(0);
+    });
+
+    test("Get Tokens", () => {
+        const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
+        const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
+
+        const cloneNotAboutUs = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
+        const nextTokens = cloneNotAboutUs.getTokens() || [];
+
+        expect(nextTokens[0]).toBe("About Them");
+    });
+
+    test("Get Tokens After", () => {
+        const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
+        const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
+        const notAboutUsClone = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
+        const aboutUsClone = sequence.findPattern(p => p.name === "about-us") as Pattern;
+        const nextTokens = notAboutUsClone.getTokensAfter(aboutUsClone) || [];
+
+        expect(nextTokens[0]).toBe("About Them");
+    });
+
+    test("Find Pattern", () => {
+        const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
+        const child = notAboutUs.findPattern(p => p.name === "about-us")
+
+        expect(child).not.toBeNull();
+    });
+
+    test("Get Next Patterns", () => {
+        const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
+        const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
+
+        const cloneNotAboutUs = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
+        const patterns = cloneNotAboutUs.getNextPatterns() || [];
+
+        expect(patterns.length).toBe(1);
+        expect(patterns[0].name).toBe("about-them");
+    });
+
+    test("Get Next Patterns With No Parent", () => {
+        const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
+        const patterns = notAboutUs.getNextPatterns() || [];
+
+        expect(patterns.length).toBe(0);
+    });
+
+    test("Get Patterns After", () => {
+        const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
+        const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
+        const notAboutUsClone = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
+        const aboutUsClone = sequence.findPattern(p => p.name === "about-us") as Pattern;
+        const patterns = notAboutUsClone.getPatternsAfter(aboutUsClone) || [];
+
+        expect(patterns.length).toBe(1);
+        expect(patterns[0].name).toBe("about-them");
+    });
+
+    test("Get Patterns After With Null Parent", () => {
+        const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
+        const aboutUsClone = notAboutUs.findPattern(p => p.name === "about-us") as Pattern;
+        const patterns = notAboutUs.getPatternsAfter(aboutUsClone) || [];
+
+        expect(patterns.length).toBe(0);
+    });
+
+});

package/src/patterns/Not.ts

@@ -1,50 +1,131 @@
-import Pattern from "./Pattern";
-import ParseError from "./ParseError";
-import Cursor from "../Cursor";
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { Pattern } from "./Pattern";
 
-export default class Not extends Pattern {
-  public cursor!: Cursor;
-  public mark: number = 0;
+export class Not implements Pattern {
+  private _type: string;
+  private _name: string;
+  private _parent: Pattern | null;
+  private _children: Pattern[];
 
-  constructor(pattern: Pattern) {
-    super("not", `not-${pattern.name}`, [pattern]);
-    this._isOptional = true;
+  get type(): string {
+    return this._type;
   }
 
-  parse(cursor: Cursor) {
-    this.cursor = cursor;
-    this.mark = cursor.mark();
-    this.tryToParse();
-    return null;
+  get name(): string {
+    return this._name;
+  }
+
+  get parent(): Pattern | null {
+    return this._parent;
+  }
+
+  set parent(pattern: Pattern | null) {
+    this._parent = pattern;
+  }
+
+  get children(): Pattern[] {
+    return this._children;
+  }
+
+  get isOptional(): boolean {
+    return false;
+  }
+
+  constructor(name: string, pattern: Pattern) {
+    this._type = "not";
+    this._name = name;
+    this._parent = null;
+    this._children = [pattern.clone(pattern.name, false)];
+    this._children[0].parent = this;
   }
 
-  private tryToParse() {
-    const mark = this.cursor.mark();
-    this.children[0].parse(this.cursor);
+  test(text: string) {
+    const cursor = new Cursor(text);
+    this.parse(cursor);
 
-    if (this.cursor.hasUnresolvedError()) {
-      this.cursor.resolveError();
-      this.cursor.moveToMark(mark);
+    return !cursor.hasError;
+  }
+
+  exec(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor);
+
+    return {
+      ast,
+      cursor
+    };
+  }
+
+  parse(cursor: Cursor): Node | null {
+    const firstIndex = cursor.index;
+    this._children[0].parse(cursor);
+
+    if (cursor.hasError) {
+      cursor.resolveError();
+      cursor.moveTo(firstIndex);
     } else {
-      this.cursor.moveToMark(mark);
-      const parseError = new ParseError(
-        `Match invalid pattern: ${this.children[0].name}.`,
-        this.mark,
-        this
-      );
-      this.cursor.throwError(parseError);
+      cursor.moveTo(firstIndex);
+      cursor.resolveError();
+      cursor.recordErrorAt(firstIndex, this);
     }
+
+    return null;
+  }
+
+  clone(name = this._name): Pattern {
+    const not = new Not(name, this._children[0]);
+    return not;
   }
 
-  clone(name?: string) {
-    if (name == null) {
-      name = this.name;
+  getTokens(): string[] {
+    const parent = this._parent;
+
+    if (parent != null) {
+      return parent.getTokensAfter(this);
     }
 
-    return new Not(this.children[0]);
+    return [];
   }
 
-  getTokens() {
+  getTokensAfter(_childReference: Pattern): string[] {
+    const parent = this._parent;
+
+    if (parent != null) {
+      return parent.getTokensAfter(this);
+    }
+
     return [];
   }
+
+  getNextTokens(): string[] {
+    if (this.parent == null) {
+      return []
+    }
+
+    return this.parent.getTokensAfter(this);
+  }
+
+  getPatternsAfter(_childReference: Pattern): Pattern[] {
+    const parent = this._parent;
+
+    if (parent != null) {
+      return parent.getPatternsAfter(this);
+    }
+
+    return []
+  }
+
+  getNextPatterns(): Pattern[] {
+    if (this.parent == null) {
+      return [];
+    }
+
+    return this.parent.getPatternsAfter(this)
+  }
+
+  findPattern(predicate: (p: Pattern) => boolean): Pattern | null {
+    return predicate(this._children[0]) ? this._children[0] : null;
+  }
+
 }

package/src/patterns/Or.test.ts

@@ -0,0 +1,209 @@
+import { Cursor } from "./Cursor";
+import { Node } from "../ast/Node";
+import { Literal } from "./Literal";
+import { Or } from "./Or";
+import { And } from "./And";
+import { Pattern } from "./Pattern";
+
+describe("Or", () => {
+    test("Empty Options", () => {
+        expect(() => {
+            new Or("bad", []);
+        }).toThrowError();
+    });
+
+    test("One Option Successful", () => {
+        const a = new Or("a", [new Literal("a", "A")]);
+        const cursor = new Cursor("A");
+        const result = a.parse(cursor);
+        const expected = new Node("literal", "a", 0, 0, [], "A")
+
+        expect(result).toEqual(expected);
+    });
+
+    test("One Option Failed", () => {
+        const a = new Or("a", [new Literal("a", "A")]);
+        const cursor = new Cursor("B");
+        const result = a.parse(cursor);
+
+        expect(result).toEqual(null);
+        expect(cursor.index).toBe(0);
+        expect(cursor.hasError).toBeTruthy();
+    });
+
+    test("Two Option", () => {
+        const a = new Or("a-b", [new Literal("a", "A"), new Literal("b", "B")]);
+        const cursor = new Cursor("AB");
+        let result = a.parse(cursor);
+        let expected = new Node("literal", "a", 0, 0, [], "A")
+
+        expect(result).toEqual(expected);
+
+        cursor.next();
+
+        result = a.parse(cursor);
+        expected = new Node("or", "a-b", 0, 0, [
+            new Node("literal", "b", 0, 0, [], "B")
+        ], "B");
+    });
+
+    test("Failed (Optional)", () => {
+        const a = new Or("a", [new Literal("a", "A")], true);
+        const cursor = new Cursor("B");
+        const result = a.parse(cursor);
+
+        expect(result).toBeNull();
+        expect(cursor.hasError).toBeFalsy();
+    });
+
+    test("Get Tokens", () => {
+        const aOrB = new Or("a-b", [new Literal("a", "A"), new Literal("b", "B")]);
+        const tokens = aOrB.getTokens();
+        const expected = ["A", "B"];
+
+        expect(tokens).toEqual(expected);
+    });
+
+    test("Get Tokens After", () => {
+        const a = new Or("a", [new Literal("a", "A")]);
+        const parent = new And("parent", [a, new Literal("b", "B")]);
+        const tokens = parent.children[0].getTokensAfter(parent.children[0].children[0]);
+        const expected = ["B"];
+
+        expect(tokens).toEqual(expected);
+    });
+
+    test("Get Tokens After Without A Parent", () => {
+        const a = new Or("a", [new Literal("a", "A")]);
+        const tokens = a.getTokensAfter(a.children[0]);
+        const expected: string[] = [];
+
+        expect(tokens).toEqual(expected);
+    });
+
+    test("Properties", () => {
+        const a = new Or("a", [new Literal("a", "A")]);
+
+        expect(a.type).toBe("or");
+        expect(a.name).toBe("a");
+        expect(a.isOptional).toBeFalsy();
+        expect(a.parent).toBeNull();
+        expect(a.children[0].name).toBe("a");
+    });
+
+    test("Exec", () => {
+        const a = new Or("a", [new Literal("a", "A")]);
+        const { ast: result } = a.exec("B");
+        expect(result).toBeNull();
+    });
+
+    test("Test No Match", () => {
+        const a = new Or("a", [new Literal("a", "A")]);
+        const result = a.test("B");
+        expect(result).toBeFalsy();
+    });
+
+    test("Test With Match", () => {
+        const a = new Or("a", [new Literal("a", "A")]);
+        const result = a.test("A");
+        expect(result).toBeTruthy();
+    });
+
+    test("Get Next Tokens", () => {
+        const sequence = new And("sequence", [
+            new Or("a-or-b", [
+                new Literal("a", "A"),
+                new Literal("b", "B")
+            ]),
+            new Literal("c", "C")
+        ]);
+
+        const orClone = sequence.findPattern(p => p.name === "a-or-b") as Pattern;
+        const tokens = orClone.getNextTokens();
+
+        expect(tokens.length).toBe(1);
+        expect(tokens[0]).toBe("C");
+    });
+
+    test("Get Next Tokens With Null Parent", () => {
+        const or = new Or("a-or-b", [
+            new Literal("a", "A"),
+            new Literal("b", "B")
+        ])
+
+        const tokens = or.getNextTokens();
+        expect(tokens.length).toBe(0);
+    });
+
+
+    test("Get Tokens After", () => {
+        const sequence = new And("sequence", [
+            new Or("a-or-b", [
+                new Literal("a", "A"),
+                new Literal("b", "B")
+            ]),
+            new Literal("c", "C")
+        ]);
+
+        const aClone = sequence.findPattern(p => p.name === "a") as Pattern;
+        const orClone = sequence.findPattern(p => p.name === "a-or-b") as Pattern;
+        const tokens = orClone.getTokensAfter(aClone);
+
+        expect(tokens.length).toBe(1);
+        expect(tokens[0]).toBe("C");
+    });
+
+    test("Get Patterns After", () => {
+        const sequence = new And("sequence", [
+            new Or("a-or-b", [
+                new Literal("a", "A"),
+                new Literal("b", "B")
+            ]),
+            new Literal("c", "C")
+        ]);
+
+        const aClone = sequence.findPattern(p => p.name === "a") as Pattern;
+        const orClone = sequence.findPattern(p => p.name === "a-or-b") as Pattern;
+        const patterns = orClone.getPatternsAfter(aClone);
+
+        expect(patterns.length).toBe(1);
+        expect(patterns[0].name).toBe("c");
+    });
+
+    test("Get Patterns After With Null Parent", () => {
+        const or = new Or("a-or-b", [
+            new Literal("a", "A"),
+            new Literal("b", "B")
+        ])
+        const aClone = or.findPattern(p => p.name === "a") as Pattern;
+        const patterns = or.getPatternsAfter(aClone);
+
+        expect(patterns.length).toBe(0);
+    });
+
+    test("Get Next Patterns", () => {
+        const sequence = new And("sequence", [
+            new Or("a-or-b", [
+                new Literal("a", "A"),
+                new Literal("b", "B")
+            ]),
+            new Literal("c", "C")
+        ]);
+
+        const orClone = sequence.findPattern(p => p.name === "a-or-b") as Pattern;
+        const patterns = orClone.getNextPatterns();
+
+        expect(patterns.length).toBe(1);
+        expect(patterns[0].name).toBe("c");
+    });
+
+    test("Get Next Patterns With Null Parent", () => {
+        const or = new Or("a-or-b", [
+            new Literal("a", "A"),
+            new Literal("b", "B")
+        ])
+        const patterns = or.getNextPatterns();
+
+        expect(patterns.length).toBe(0);
+    });
+});