clarity-pattern-parser 4.0.3 → 5.0.0

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 leafMatch(): Match {
+    return this._leafMatch;
+  }
+
+  get furthestError(): ParseError | null {
+    return this._furthestError;
+  }
+
+  get isRecording(): boolean {
+    return this._isRecording;
+  }
+
+  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;
+  }
+
+  get rootMatch(): Match {
+    return this._rootMatch;
+  }
+
+  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,134 @@
+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 parent = new And("parent", [
+            new Literal("a", "A"),
+            new Literal("b", "B")
+        ]);
+
+        const a = parent.children[0] as Literal;
+        const b = parent.children[1];
+
+        let tokens = a.getTokens();
+        let expectedTokens = ["A"];
+
+        expect(tokens).toEqual(expectedTokens);
+
+        a.enableContextualTokenAggregation();
+
+        tokens = a.getTokens();
+        expectedTokens = ["AB"];
+
+        expect(tokens).toEqual(expectedTokens);
+
+        a.disableContextualTokenAggregation();
+
+        tokens = a.getTokens();
+        expectedTokens = ["A"];
+
+        expect(tokens).toEqual(expectedTokens);
+    });
+
+    test("Get Next Tokens", () => {
+        const literal = new Literal("a", "A");
+        const tokens = literal.getNextTokens(new Literal("bogus", "bogus"));
+        const expected: string[] = [];
+
+        expect(tokens).toEqual(expected)
+    });
+
+    test("Get Next Pattern", () => {
+        const parent = new And("parent", [
+            new Literal("a", "A"),
+            new Literal("b", "B")
+        ]);
+
+        const nextPattern = parent.children[0].getNextPattern();
+
+        expect(nextPattern?.name).toBe("b")
+    });
+
+    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("Parse Text", () => {
+        const literal = new Literal("a", "A");
+        const { ast: result } = literal.parseText("B");
+        expect(result).toBeNull()
+    });
+});

package/src/patterns/Literal.ts

@@ -1,91 +1,181 @@
-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 { getNextPattern } from "./getNextPattern";
+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;
+  private _hasContextualTokenAggregation: boolean;
+  private _isRetrievingContextualTokens: boolean;
 
-  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;
+    this._hasContextualTokenAggregation = false;
+    this._isRetrievingContextualTokens = false;
   }
 
-  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;
+  parseText(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor)
+
+    return {
+      ast,
+      cursor
+    };
   }
 
-  private tryToParse() {
-    if (this.substring === this.literal) {
-      this.processResult();
-    } else {
-      this.processError();
+  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) {
+      cursor.recordErrorAt(cursor.index, this)
+      return null;
+    }
+
+    cursor.resolveError();
+    cursor.moveTo(this._firstIndex);
+    return null;
   }
 
-  private processError() {
-    this.node = null;
+  private _tryToParse(cursor: Cursor): boolean {
+    let passed = false;
+    const literalRuneLength = this._runes.length;
 
-    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);
+    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 processResult() {
-    this.node = new Node(
+  private _createNode(): Node {
+    return new Node(
       "literal",
-      this.name,
-      this.mark,
-      this.mark + this.literal.length - 1,
+      this._name,
+      this._firstIndex,
+      this._lastIndex,
       [],
-      this.substring
+      this._literal
     );
+  }
 
-    this.cursor.index = this.node.endIndex;
-    this.cursor.addMatch(this, this.node);
+  clone(name = this._name, isOptional = this._isOptional): Pattern {
+    const clone = new Literal(name, this._literal, isOptional);
+    clone._hasContextualTokenAggregation = this._hasContextualTokenAggregation;
+    return clone;
   }
+
+  getTokens(): string[] {
+    const parent = this._parent;
+
+    if (
+      this._hasContextualTokenAggregation &&
+      parent != null &&
+      !this._isRetrievingContextualTokens
+    ) {
+      this._isRetrievingContextualTokens = true;
+
+      const aggregateTokens: string[] = [];
+      const nextTokens = parent.getNextTokens(this);
+
+      for (const nextToken of nextTokens) {
+        aggregateTokens.push(this._literal + nextToken);
+      }
+
+      this._isRetrievingContextualTokens = false;
+      return aggregateTokens;
+    } else {
+      return [this._literal];
+    }
+  }
+
+  getNextTokens(_lastMatched: Pattern): string[] {
+    return [];
+  }
+
+  getNextPattern(): Pattern | null {
+    return getNextPattern(this)
+  }
+
+  findPattern(_isMatch: (p: Pattern) => boolean): Pattern | null {
+    return null;
+  }
+
+  enableContextualTokenAggregation(): void {
+    this._hasContextualTokenAggregation = true;
+  }
+
+  disableContextualTokenAggregation(): void {
+    this._hasContextualTokenAggregation = false;
+  }
+
 }

package/src/patterns/Not.test.ts

@@ -0,0 +1,88 @@
+import { And } from "./And";
+import { Cursor } from "./Cursor";
+import { Literal } from "./Literal";
+import { Not } from "./Not";
+
+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.getNextTokens(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("Parse Text", () => {
+        const a = new Literal("a", "A");
+        const notA = new Not("not-a", a);
+        const { ast: result } = notA.parseText("A");
+
+        expect(result).toBeNull();
+    });
+
+    test("Get Next Pattern", () => {
+        const a = new Literal("a", "A");
+        const b = new Literal("b", "B");
+        const notA = new Not("not-a", a);
+
+        const parent = new And("parent", [notA, b]);
+        const nextPattern = parent.children[0].getNextPattern();
+
+        expect(nextPattern?.name).toBe("b");
+    });
+});

package/src/patterns/Not.ts

@@ -1,50 +1,91 @@
-import Pattern from "./Pattern";
-import ParseError from "./ParseError";
-import Cursor from "../Cursor";
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { getNextPattern } from "./getNextPattern";
+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 isOptional(): boolean {
+    return false;
+  }
+
+  get parent(): Pattern | null {
+    return this._parent;
+  }
+
+  set parent(pattern: Pattern | null) {
+    this._parent = pattern;
+  }
+
+  get children(): Pattern[] {
+    return this._children;
+  }
+
+  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;
+  }
+
+  parseText(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor)
+
+    return {
+      ast,
+      cursor
+    };
   }
 
-  private tryToParse() {
-    const mark = this.cursor.mark();
-    this.children[0].parse(this.cursor);
+  parse(cursor: Cursor): Node | null {
+    const firstIndex = cursor.index;
+    this._children[0].parse(cursor);
 
-    if (this.cursor.hasUnresolvedError()) {
-      this.cursor.resolveError();
-      this.cursor.moveToMark(mark);
+    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?: string) {
-    if (name == null) {
-      name = this.name;
-    }
+  clone(name = this._name): Pattern {
+    const not = new Not(name, this._children[0]);
+    return not;
+  }
 
-    return new Not(this.children[0]);
+  getNextPattern(): Pattern | null {
+    return getNextPattern(this)
   }
 
-  getTokens() {
+  getTokens(): string[] {
     return [];
   }
+
+  getNextTokens(_lastMatched: Pattern): string[] {
+    return [];
+  }
+
+  findPattern(isMatch: (p: Pattern) => boolean): Pattern | null {
+    return isMatch(this._children[0]) ? this._children[0] : null;
+  }
+
 }