clarity-pattern-parser 4.0.3 → 6.0.0

package/src/patterns/CursorHistory.test.ts

@@ -0,0 +1,54 @@
+import { Node } from "../ast/Node";
+import { CursorHistory } from "./CursorHistory"
+import { Literal } from "./Literal";
+
+describe("CursorHistory", () => {
+    test("Add Match", () => {
+        const history = new CursorHistory();
+        const pattern = new Literal("a", "A");
+        const node = new Node("literal", "a", 0, 0, [], "A");
+
+        history.startRecording();
+        history.recordMatch(pattern, node);
+
+        expect(history.isRecording).toBeTruthy();
+
+        expect(history.leafMatch.node).toBe(node);
+        expect(history.leafMatch.pattern).toBe(pattern);
+
+        expect(history.rootMatch.node).toBe(node);
+        expect(history.rootMatch.pattern).toBe(pattern);
+
+        expect(history.nodes[0]).toBe(node);
+        expect(history.patterns[0]).toBe(pattern);
+
+        history.stopRecording();
+
+        expect(history.isRecording).toBeFalsy();
+    });
+
+    test("Add Error At", () => {
+        const history = new CursorHistory();
+        const pattern = new Literal("a", "A");
+        
+        history.startRecording();
+        history.recordErrorAt(0, pattern);
+
+        expect(history.error?.index).toBe(0);
+        expect(history.error?.pattern).toBe(pattern);
+        expect(history.errors[0]?.index).toBe(0);
+        expect(history.errors[0]?.pattern).toBe(pattern);
+
+        history.stopRecording()
+        history.resolveError();
+
+        expect(history.isRecording).toBeFalsy();
+        expect(history.error).toBeNull();
+        
+        expect(history.errors[0]?.index).toBe(0);
+        expect(history.errors[0]?.pattern).toBe(pattern);
+
+        expect(history.furthestError?.index).toBe(0);
+        expect(history.furthestError?.pattern).toBe(pattern);
+    });
+});

package/src/patterns/CursorHistory.ts

@@ -0,0 +1,95 @@
+import { Node } from "../ast/Node";
+import { ParseError } from "./ParseError";
+import { Pattern } from "./Pattern";
+
+export interface Match {
+  pattern: Pattern | null;
+  node: Node | null;
+}
+
+export class CursorHistory {
+  private _isRecording: boolean = false;
+  private _leafMatch: Match = { pattern: null, node: null };
+  private _furthestError: ParseError | null = null;
+  private _currentError: ParseError | null = null;
+  private _rootMatch: Match = { pattern: null, node: null };
+  private _patterns: Pattern[] = [];
+  private _nodes: Node[] = [];
+  private _errors: ParseError[] = [];
+
+  get isRecording(): boolean {
+    return this._isRecording;
+  }
+
+  get rootMatch(): Match {
+    return this._rootMatch;
+  }
+
+  get leafMatch(): Match {
+    return this._leafMatch;
+  }
+
+  get furthestError(): ParseError | null {
+    return this._furthestError;
+  }
+
+  get errors(): ParseError[] {
+    return this._errors;
+  }
+
+  get error(): ParseError | null {
+    return this._currentError
+  }
+
+  get nodes(): Node[] {
+    return this._nodes;
+  }
+
+  get patterns(): Pattern[] {
+    return this._patterns;
+  }
+
+  recordMatch(pattern: Pattern, node: Node): void {
+    if (this._isRecording) {
+      this._patterns.push(pattern);
+      this._nodes.push(node);
+    }
+
+    this._rootMatch.pattern = pattern;
+    this._rootMatch.node = node;
+
+    const isFurthestMatch =
+      this._leafMatch.node === null || node.lastIndex > this._leafMatch.node.lastIndex;
+
+    if (isFurthestMatch) {
+      this._leafMatch.pattern = pattern;
+      this._leafMatch.node = node;
+    }
+  }
+
+  recordErrorAt(index: number, pattern: Pattern): void {
+    const error = new ParseError(index, pattern);
+    this._currentError = error;
+
+    if (this._furthestError === null || index > this._furthestError.index) {
+      this._furthestError = error;
+    }
+
+    if (this._isRecording) {
+      this._errors.push(error);
+    }
+  }
+
+  startRecording(): void {
+    this._isRecording = true;
+  }
+
+  stopRecording(): void {
+    this._isRecording = false;
+  }
+
+  resolveError() {
+    this._currentError = null;
+  }
+
+}

package/src/patterns/Literal.test.ts

@@ -0,0 +1,166 @@
+import { Node } from "../ast/Node";
+import { And } from "./And";
+import { Cursor } from "./Cursor";
+import { Literal } from "./Literal"
+
+describe("Literal", () => {
+    test("Empty Value", () => {
+        expect(() => {
+            new Literal("empty", "")
+        }).toThrowError()
+    });
+
+    test("Successful Parse", () => {
+        const literal = new Literal("greeting", "Hello World!");
+
+        const cursor = new Cursor("Hello World!");
+        const result = literal.parse(cursor);
+        const expected = new Node("literal", "greeting", 0, 11, [], "Hello World!");
+
+        expect(result).toEqual(expected);
+        expect(cursor.index).toBe(11);
+        expect(cursor.error).toBeNull();
+        expect(cursor.leafMatch.node).toEqual(expected)
+        expect(cursor.leafMatch.pattern).toBe(literal)
+        expect(cursor.rootMatch.node).toEqual(expected)
+        expect(cursor.rootMatch.pattern).toBe(literal)
+    });
+
+    test("Failed Parse", () => {
+        const literal = new Literal("greeting", "Hello World!");
+
+        const cursor = new Cursor("Hello Saturn!");
+        const result = literal.parse(cursor);
+
+        expect(result).toEqual(null);
+        expect(cursor.index).toBe(6);
+        expect(cursor.error?.index).toBe(6);
+        expect(cursor.error?.pattern).toBe(literal)
+    });
+
+    test("Failed Parse Because End Of Text", () => {
+        const literal = new Literal("greeting", "Hello World!");
+
+        const cursor = new Cursor("Hello World");
+        const result = literal.parse(cursor);
+
+        expect(result).toEqual(null);
+        expect(cursor.index).toBe(10);
+        expect(cursor.error?.index).toBe(10);
+        expect(cursor.error?.pattern).toBe(literal)
+    });
+
+    test("Failed Parse (Optional)", () => {
+        const literal = new Literal("greeting", "Hello World!", true);
+
+        const cursor = new Cursor("Hello Saturn!");
+        const result = literal.parse(cursor);
+
+        expect(result).toEqual(null);
+        expect(cursor.index).toBe(0);
+        expect(cursor.error).toBeNull();
+    });
+
+    test("Clone", () => {
+        const literal = new Literal("greeting", "Hello World!");
+        const clone = literal.clone();
+
+        expect(clone.name).toBe("greeting");
+        expect(clone).not.toBe(literal);
+    });
+
+    test("Get Tokens", () => {
+        const a = new Literal("a", "A");
+
+        const tokens = a.getTokens();
+        const expectedTokens = ["A"];
+
+        expect(tokens).toEqual(expectedTokens);
+    });
+
+    test("Get Tokens After", () => {
+        const literal = new Literal("a", "A");
+        const tokens = literal.getTokensAfter(new Literal("bogus", "bogus"));
+        const expected: string[] = [];
+
+        expect(tokens).toEqual(expected)
+    });
+
+    test("Properties", () => {
+        const literal = new Literal("a", "A");
+
+        expect(literal.type).toBe("literal");
+        expect(literal.name).toBe("a");
+        expect(literal.parent).toBeNull();
+        expect(literal.children).toEqual([]);
+    });
+
+    test("Exec", () => {
+        const literal = new Literal("a", "A");
+        const { ast: result } = literal.exec("B");
+        expect(result).toBeNull()
+    });
+
+    test("Test With No Match", () => {
+        const literal = new Literal("a", "A");
+        const isMatch = literal.test("B");
+
+        expect(isMatch).toBeFalsy();
+    });
+
+    test("Test With Match", () => {
+        const literal = new Literal("a", "A");
+        const isMatch = literal.test("A");
+
+        expect(isMatch).toBeTruthy();
+    });
+
+    test("Get Next Tokens", () => {
+        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const parent = new And("parent", [sequence, new Literal("b", "B")]);
+
+        const a = parent.findPattern(p => p.name === "a");
+        const tokens = a?.getNextTokens() || [];
+
+        expect(tokens[0]).toBe("B");
+    });
+
+    test("Get Next Tokens With Null Parent", () => {
+        const a = new Literal("a", "A");
+        const tokens = a.getNextTokens();
+
+        expect(tokens.length).toBe(0);
+    });
+
+    test("Get Next Patterns", () => {
+        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const parent = new And("parent", [sequence, new Literal("b", "B")]);
+
+        const a = parent.findPattern(p => p.name === "a");
+        const nextPatterns = a?.getNextPatterns() || [];
+        const b = parent.findPattern(p => p.name === "b")
+
+        expect(nextPatterns[0]).toBe(b);
+    });
+
+    test("Get Next Patterns With Null Parent", () => {
+        const a = new Literal("a", "A");
+        const nextPatterns = a.getNextPatterns();
+
+        expect(nextPatterns.length).toBe(0);
+    });
+
+    test("Get Patterns After", () => {
+        const a = new Literal("a", "A");
+        const patterns = a.getPatternsAfter();
+
+        expect(patterns.length).toBe(0);
+    });
+
+    test("Find Pattern", () => {
+        const a = new Literal("a", "A");
+        const pattern = a.findPattern(p => p.name === "nada");
+
+        expect(pattern).toBeNull();
+    });
+});

package/src/patterns/Literal.ts

@@ -1,91 +1,170 @@
-import ParseError from "./ParseError";
-import Node from "../ast/Node";
-import Pattern from "./Pattern";
-import Cursor from "../Cursor";
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { Pattern } from "./Pattern";
 
-export default class Literal extends Pattern {
-  public literal: string;
-  public node: Node | null = null;
-  public cursor!: Cursor;
-  public mark: number = 0;
-  public substring: string = "";
+export class Literal implements Pattern {
+  private _type: string;
+  private _name: string;
+  private _parent: Pattern | null;
+  private _isOptional: boolean;
+  private _literal: string;
+  private _runes: string[];
+  private _firstIndex: number;
+  private _lastIndex: number;
 
-  constructor(name: string, literal: string, isOptional = false) {
-    super("literal", name, [], isOptional);
-    this.literal = literal;
-    this.assertArguments();
+  get type(): string {
+    return this._type;
   }
 
-  parse(cursor: Cursor) {
-    this.resetState(cursor);
-    this.tryToParse();
+  get name(): string {
+    return this._name;
+  }
 
-    return this.node;
+  get parent(): Pattern | null {
+    return this._parent;
   }
 
-  clone(name?: string, isOptional?: boolean) {
-    if (name == null) {
-      name = this.name;
-    }
+  set parent(pattern: Pattern | null) {
+    this._parent = pattern;
+  }
 
-    if (isOptional == null) {
-      isOptional = this._isOptional;
-    }
-    
-    return new Literal(name, this.literal, isOptional);
+  get children(): Pattern[] {
+    return [];
   }
 
-  getTokens() {
-    return [this.literal];
+  get isOptional(): boolean {
+    return this._isOptional;
   }
 
-  private assertArguments() {
-    if (this.literal.length < 1) {
-      throw new Error(
-        "Invalid Arguments: The `literal` argument needs to be at least one character long."
-      );
+  constructor(name: string, value: string, isOptional = false) {
+    if (value.length === 0) {
+      throw new Error("Value Cannot be empty.");
     }
+
+    this._type = "literal";
+    this._name = name;
+    this._literal = value;
+    this._runes = Array.from(value);
+    this._isOptional = isOptional;
+    this._parent = null;
+    this._firstIndex = 0;
+    this._lastIndex = 0;
   }
 
-  private resetState(cursor: Cursor) {
-    this.cursor = cursor;
-    this.mark = this.cursor.mark();
-    this.substring = this.cursor.text.substring(
-      this.mark,
-      this.mark + this.literal.length
-    );
-    this.node = null;
+  test(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor);
+
+    return ast?.value === text;
   }
 
-  private tryToParse() {
-    if (this.substring === this.literal) {
-      this.processResult();
-    } else {
-      this.processError();
-    }
+  exec(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor);
+
+    return {
+      ast: ast?.value === text ? ast : null,
+      cursor
+    };
   }
 
-  private processError() {
-    this.node = null;
+  parse(cursor: Cursor): Node | null {
+    this._firstIndex = cursor.index;
+
+    const passed = this._tryToParse(cursor);
+
+    if (passed) {
+      cursor.resolveError();
+      const node = this._createNode();
+      cursor.recordMatch(this, node);
+
+      return node;
+    }
 
     if (!this._isOptional) {
-      const message = `ParseError: Expected '${this.literal}' but found '${this.substring}'.`;
-      const parseError = new ParseError(message, this.cursor.getIndex(), this);
-      this.cursor.throwError(parseError);
+      cursor.recordErrorAt(cursor.index, this)
+      return null;
     }
+
+    cursor.resolveError();
+    cursor.moveTo(this._firstIndex);
+    return null;
   }
 
-  private processResult() {
-    this.node = new Node(
+  private _tryToParse(cursor: Cursor): boolean {
+    let passed = false;
+    const literalRuneLength = this._runes.length;
+
+    for (let i = 0; i < literalRuneLength; i++) {
+      const literalRune = this._runes[i];
+      const cursorRune = cursor.currentChar;
+
+      if (literalRune !== cursorRune) {
+        break
+      }
+
+      if (i + 1 === literalRuneLength) {
+        this._lastIndex = this._firstIndex + this._literal.length - 1;
+        passed = true;
+        break;
+      }
+
+      if (!cursor.hasNext()) {
+        break;
+      }
+
+      cursor.next();
+    }
+
+    return passed
+  }
+
+  private _createNode(): Node {
+    return new Node(
       "literal",
-      this.name,
-      this.mark,
-      this.mark + this.literal.length - 1,
-      [],
-      this.substring
+      this._name,
+      this._firstIndex,
+      this._lastIndex,
+      undefined,
+      this._literal
     );
+  }
+
+  clone(name = this._name, isOptional = this._isOptional): Pattern {
+    const clone = new Literal(name, this._literal, isOptional);
+    return clone;
+  }
+
+  getTokens(): string[] {
+    return [this._literal];
+  }
+
+  getTokensAfter(_lastMatched: Pattern): string[] {
+    return [];
+  }
+
+  getNextTokens(): string[] {
+    if (this.parent == null) {
+      return []
+    }
+
+    return this.parent.getTokensAfter(this);
+  }
+
+  getPatternsAfter(): Pattern[] {
+    return []
+  }
 
-    this.cursor.index = this.node.endIndex;
-    this.cursor.addMatch(this, this.node);
+  getNextPatterns(): Pattern[] {
+    if (this.parent == null) {
+      return [];
+    }
+
+    return this.parent.getPatternsAfter(this)
   }
+
+  findPattern(_predicate: (p: Pattern) => boolean): Pattern | null {
+    return null;
+  }
+
 }