clarity-pattern-parser 4.0.2 → 5.0.0

package/src/patterns/And.ts

@@ -1,178 +1,281 @@
-import ParseError from "../patterns/ParseError";
-import Cursor from "../Cursor";
-import Pattern from "./Pattern";
-import Node from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { Pattern } from "./Pattern";
+import { Node } from "../ast/Node";
+import { clonePatterns } from "./clonePatterns";
+import { filterOutNull } from "./filterOutNull";
+import { getNextPattern } from "./getNextPattern";
+import { findPattern } from "./findPattern";
+
+export class And implements Pattern {
+  private _type: string;
+  private _name: string;
+  private _parent: Pattern | null;
+  private _children: Pattern[];
+  private _isOptional: boolean;
+  private _nodes: (Node | null)[];
+  private _firstIndex: number;
+  private _shouldReduceAst: boolean;
+
+  get type(): string {
+    return this._type;
+  }
 
-export default class And extends Pattern {
-  public onPatternIndex: number = 0;
-  public nodes: (Node | null)[] = [];
-  public node: Node | null = null;
-  public cursor: Cursor | null = null;
-  public mark: number = 0;
+  get name(): string {
+    return this._name;
+  }
 
-  constructor(name: string, patterns: Pattern[], isOptional = false) {
-    super("and", name, patterns, isOptional);
+  get parent(): Pattern | null {
+    return this._parent;
   }
 
-  parse(cursor: Cursor) {
-    this.resetState(cursor);
-    this.tryToParse();
+  set parent(pattern: Pattern | null) {
+    this._parent = pattern;
+  }
 
-    return this.node;
+  get children(): Pattern[] {
+    return this._children;
   }
 
-  clone(name?: string, isOptional?: boolean) {
-    if (name == null) {
-      name = this.name;
+  get isOptional(): boolean {
+    return this._isOptional;
+  }
+
+  constructor(name: string, sequence: Pattern[], isOptional = false) {
+    if (sequence.length === 0) {
+      throw new Error("Need at least one pattern with an 'and' pattern.");
     }
 
-    if (isOptional == null){
-      isOptional = this._isOptional;
+    const children = clonePatterns(sequence);
+    this._assignChildrenToParent(children)
+
+    this._type = "and";
+    this._name = name;
+    this._isOptional = isOptional;
+    this._parent = null;
+    this._children = children;
+    this._firstIndex = -1
+    this._shouldReduceAst = false;
+    this._nodes = [];
+  }
+
+  private _assignChildrenToParent(children: Pattern[]): void {
+    for (const child of children) {
+      child.parent = this;
     }
+  }
+
+  parseText(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor)
 
-    return new And(name, this._children, isOptional);
+    return {
+      ast,
+      cursor
+    };
   }
 
-  getTokens() {
-    let tokens: string[] = [];
+  parse(cursor: Cursor): Node | null {
+    this._firstIndex = cursor.index;
+    this._nodes = [];
+
+    const passed = this.tryToParse(cursor);
+
+    if (passed) {
+      const node = this.createNode(cursor);
+
+      if (node !== null) {
+        cursor.recordMatch(this, node);
+      }
+
+      return node;
+    }
 
-    for (let x = 0; x < this._children.length; x++) {
-      const child = this._children[x];
+    if (this._isOptional) {
+      cursor.resolveError();
+    }
 
-      if (child.isOptional) {
-        tokens = tokens.concat(child.getTokens());
+    return null;
+  }
+
+  private tryToParse(cursor: Cursor): boolean {
+    let passed = false;
+
+    for (let i = 0; i < this._children.length; i++) {
+      const runningCursorIndex = cursor.index;
+      const nextPatternIndex = i + 1;
+      const hasMorePatterns = nextPatternIndex < this._children.length;
+
+      const node = this._children[i].parse(cursor);
+      const hasNoError = !cursor.hasError;
+      const hadMatch = node !== null;
+
+      if (hasNoError) {
+        this._nodes.push(node);
+
+        if (hasMorePatterns) {
+          if (hadMatch) {
+            if (cursor.hasNext()) {
+              cursor.next();
+              continue;
+            } else {
+              if (this.areRemainingPatternsOptional(i)) {
+                passed = true;
+                break;
+              }
+
+              cursor.recordErrorAt(cursor.index + 1, this);
+              break;
+            }
+          } else {
+            cursor.moveTo(runningCursorIndex);
+            continue;
+          }
+        } else {
+          const lastNode = this.getLastValidNode();
+          if (lastNode === null) {
+            cursor.recordErrorAt(cursor.index, this);
+            break;
+          }
+
+          passed = true;
+          break;
+        }
       } else {
-        tokens = tokens.concat(child.getTokens());
+        cursor.moveTo(this._firstIndex);
         break;
       }
     }
 
-    return tokens;
+    return passed;
   }
 
-  private resetState(cursor: Cursor) {
-    this.onPatternIndex = 0;
-    this.nodes = [];
-    this.node = null;
-    this.cursor = cursor;
-    this.mark = this.cursor.mark();
-  }
+  private getLastValidNode(): Node | null {
+    const nodes = filterOutNull(this._nodes);
 
-  private tryToParse() {
-    const cursor = this.safelyGetCursor();
+    if (nodes.length === 0) {
+      return null;
+    }
 
-    while (true) {
-      const pattern = this._children[this.onPatternIndex];
-      const node = pattern.parse(cursor);
+    return nodes[nodes.length - 1];
+  }
 
-      if (cursor.hasUnresolvedError()) {
-        this.processError();
-        break;
-      } else {
-        this.nodes.push(node);
-      }
+  private areRemainingPatternsOptional(fromIndex: number): boolean {
+    const startOnIndex = fromIndex + 1;
+    const length = this._children.length;
 
-      if (!this.shouldProceed()) {
-        this.processResult();
-        break;
+    for (let i = startOnIndex; i < length; i++) {
+      const pattern = this._children[i];
+      if (!pattern.isOptional) {
+        return false;
       }
     }
+
+    return true;
   }
 
-  private safelyGetCursor() {
-    const cursor = this.cursor;
+  private createNode(cursor: Cursor): Node | null {
+    const children = filterOutNull(this._nodes);
+
+    const lastIndex = children[children.length - 1].lastIndex;
+    const value = cursor.getChars(this._firstIndex, lastIndex);
 
-    if (cursor == null) {
-      throw new Error("Couldn't find cursor.");
+    cursor.moveTo(lastIndex)
+
+    if (this._shouldReduceAst) {
+      children.length = 0;
     }
-    return cursor;
+
+    return new Node(
+      "and",
+      this._name,
+      this._firstIndex,
+      lastIndex,
+      children,
+      this._shouldReduceAst ? value : undefined
+    );
   }
 
-  private processResult() {
-    const cursor = this.safelyGetCursor();
+  enableAstReduction(): void {
+    this._shouldReduceAst = true;
+  }
 
-    if (cursor.hasUnresolvedError()) {
-      this.processError();
-    } else {
-      this.processSuccess();
-    }
+  disableAstReduction(): void {
+    this._shouldReduceAst = false;
   }
 
-  private processError() {
-    const cursor = this.safelyGetCursor();
+  getTokens(): string[] {
+    const tokens: string[] = [];
 
-    if (this.isOptional) {
-      cursor.moveToMark(this.mark);
-      cursor.resolveError();
+    for (const child of this._children) {
+      tokens.push(...child.getTokens());
+
+      if (!child.isOptional) {
+        break;
+      }
     }
-    this.node = null;
-  }
 
-  private shouldProceed() {
-    const cursor = this.safelyGetCursor();
+    return tokens;
+  }
 
-    if (this.hasMorePatterns()) {
-      const lastNode = this.nodes[this.nodes.length - 1];
-      const wasOptional = lastNode == null;
+  getNextTokens(lastMatched: Pattern): string[] {
+    let nextSibling: Pattern | null = null;
+    let nextSiblingIndex = -1;
+    let index = -1;
+    const tokens: string[] = [];
 
-      if (cursor.hasNext()) {
-        if (!wasOptional) {
-          cursor.next();
+    for (let i = 0; i < this._children.length; i++) {
+      if (this._children[i] === lastMatched) {
+        if (i + 1 < this._children.length) {
+          nextSibling = this._children[i + 1];
         }
-
-        this.onPatternIndex++;
-        return true;
-      } else if (wasOptional) {
-        this.onPatternIndex++;
-        return true;
+        nextSiblingIndex = i + 1;
+        index = i;
+        break;
       }
+    }
 
-      this.assertRestOfPatternsAreOptional();
-      return false;
-    } else {
-      return false;
+    if (index === -1) {
+      return [];
     }
-  }
 
-  private hasMorePatterns() {
-    return this.onPatternIndex + 1 < this._children.length;
-  }
+    if (nextSiblingIndex === this._children.length && this._parent !== null) {
+      return this._parent.getNextTokens(this);
+    }
+
+    if (nextSibling !== null && !nextSibling.isOptional) {
+      return nextSibling.getTokens();
+    }
 
-  private assertRestOfPatternsAreOptional() {
-    const cursor = this.safelyGetCursor();
-    const areTheRestOptional = this.areTheRemainingPatternsOptional();
+    if (nextSibling !== null && nextSibling.isOptional) {
+      for (let i = nextSiblingIndex; i < this._children.length; i++) {
+        const child = this._children[i];
+        tokens.push(...child.getTokens());
 
-    if (!areTheRestOptional) {
-      const parseError = new ParseError(
-        `Could not match ${this.name} before string ran out.`,
-        this.onPatternIndex,
-        this
-      );
+        if (!child.isOptional) {
+          break;
+        }
 
-      cursor.throwError(parseError);
+        if (i === this._children.length - 1 && this._parent !== null) {
+          tokens.push(...this._parent.getNextTokens(this));
+        }
+      }
     }
-  }
 
-  private areTheRemainingPatternsOptional() {
-    return this.children
-      .slice(this.onPatternIndex + 1)
-      .map((p) => p.isOptional)
-      .every((r) => r);
+    return tokens;
   }
 
-  private processSuccess() {
-    const cursor = this.safelyGetCursor();
-    const nodes = this.nodes.filter((node) => node != null) as Node[];
-    this.nodes = nodes;
+  getNextPattern(): Pattern | null {
+    return getNextPattern(this)
+  }
 
-    const lastNode = nodes[this.nodes.length - 1];
-    const startIndex = this.mark;
-    const endIndex = lastNode.endIndex;
-    const value = nodes.map((node) => node.value).join("");
+  findPattern(isMatch: (p: Pattern)=>boolean): Pattern | null{
+    return findPattern(this, isMatch);
+  }
 
-    this.node = new Node("and", this.name, startIndex, endIndex, nodes, value);
+  clone(name = this._name, isOptional = this._isOptional): Pattern {
+    const and = new And(name, this._children, isOptional)
+    and._shouldReduceAst = this._shouldReduceAst;
 
-    cursor.index = this.node.endIndex;
-    cursor.addMatch(this, this.node);
+    return and
   }
 }

package/src/patterns/Cursor.test.ts

@@ -0,0 +1,93 @@
+import { Cursor } from "./Cursor";
+import { Literal } from "./Literal";
+import { Node } from "../ast/Node"
+
+describe("Cursor", () => {
+    test("Empty Text", () => {
+        expect(() => {
+            new Cursor("");
+        }).toThrowError()
+    });
+
+    test("Move Cursor", () => {
+        const cursor = new Cursor("Hello World!");
+        cursor.moveTo(6);
+
+        expect(cursor.currentChar).toBe("W")
+
+        cursor.moveToFirstChar();
+        cursor.previous();
+
+        expect(cursor.isOnFirst).toBeTruthy();
+        expect(cursor.currentChar).toBe("H");
+
+        cursor.next();
+
+        expect(cursor.currentChar).toBe("e");
+
+        cursor.moveToLastChar();
+        cursor.next();
+
+        expect(cursor.isOnLast).toBeTruthy()
+        expect(cursor.currentChar).toBe("!");
+
+        cursor.previous();
+
+        expect(cursor.currentChar).toBe("d");
+    });
+
+    test("Error Handling", () => {
+        const pattern = new Literal("a", "A");
+        const cursor = new Cursor("Hello World!");
+
+        cursor.recordErrorAt(0, pattern);
+
+        expect(cursor.hasError).toBeTruthy();
+        expect(cursor.error?.index).toBe(0);
+        expect(cursor.error?.pattern).toBe(pattern);
+
+        cursor.resolveError();
+
+        expect(cursor.hasError).toBeFalsy();
+        expect(cursor.error).toBe(null);
+        expect(cursor.furthestError?.index).toBe(0);
+        expect(cursor.furthestError?.pattern).toBe(pattern);
+    });
+
+    test("Error Handling", () => {
+        const pattern = new Literal("h", "H");
+        const node = new Node("literal", "h", 0, 0, [], "H");
+
+        const cursor = new Cursor("Hello World!");
+
+        cursor.recordMatch(pattern, node)
+
+        expect(cursor.leafMatch.node).toBe(node);
+        expect(cursor.leafMatch.pattern).toBe(pattern);
+
+        expect(cursor.rootMatch.node).toBe(node);
+        expect(cursor.rootMatch.pattern).toBe(pattern);
+    });
+
+    test("Recording", () => {
+        const cursor = new Cursor("Hello World!");
+        cursor.startRecording();
+
+        expect(cursor.isRecording).toBeTruthy();
+
+        cursor.stopRecording();
+
+        expect(cursor.isRecording).toBeFalsy();
+    });
+
+
+    test("Text Information", () => {
+        const cursor = new Cursor("Hello World!");
+        const hello = cursor.getChars(0, 4);
+
+        expect(hello).toBe("Hello");
+        expect(cursor.length).toBe(12);
+        expect(cursor.text).toBe("Hello World!")
+        expect(cursor.index).toBe(0);
+    });
+});

package/src/patterns/Cursor.ts

@@ -0,0 +1,130 @@
+import { Pattern, Node, ParseError } from "..";
+import { CursorHistory, Match } from "./CursorHistory";
+
+export class Cursor {
+  private _text: string;
+  private _index: number;
+  private _length: number;
+  private _history: CursorHistory;
+
+  get text(): string {
+    return this._text;
+  }
+
+  get isOnFirst(): boolean {
+    return this._index === 0;
+  }
+
+  get isOnLast(): boolean {
+    return this._index === this._getLastIndex();
+  }
+
+  get isRecording(): boolean {
+    return this._history.isRecording;
+  }
+
+  get leafMatch(): Match {
+    return this._history.leafMatch;
+  }
+
+  get rootMatch(): Match {
+    return this._history.rootMatch;
+  }
+
+  get furthestError(): ParseError | null {
+    return this._history.furthestError;
+  }
+
+  get error() {
+    return this._history.error;
+  }
+
+  get index(): number {
+    return this._index;
+  }
+
+  get length(): number {
+    return this._length;
+  }
+
+  get hasError(): boolean {
+    return this._history.error != null
+  }
+
+  get currentChar(): string {
+    return this._text[this._index]
+  }
+
+  constructor(text: string) {
+    if (text.length === 0) {
+      throw new Error("Cannot have a empty string.");
+    }
+
+    this._text = text;
+    this._index = 0;
+    this._length = text.length;
+    this._history = new CursorHistory();
+  }
+
+  hasNext(): boolean {
+    return this._index + 1 < this._length;
+  }
+
+  hasPrevious(): boolean {
+    return this._index - 1 >= 0;
+  }
+
+  next(): void {
+    if (this.hasNext()) {
+      this._index++;
+    }
+  }
+
+  previous(): void {
+    if (this.hasPrevious()) {
+      this._index--;
+    }
+  }
+
+  moveTo(position: number): void {
+    if (position >= 0 && position < this._length) {
+      this._index = position;
+    }
+  }
+
+  moveToFirstChar(): void {
+    this._index = 0;
+  }
+
+  moveToLastChar(): void {
+    this._index = this._getLastIndex();
+  }
+
+  getChars(first: number, last: number): string {
+    return this._text.slice(first, last + 1);
+  }
+
+  recordMatch(pattern: Pattern, node: Node): void {
+    this._history.recordMatch(pattern, node);
+  }
+
+  recordErrorAt(index: number, onPattern: Pattern): void {
+    this._history.recordErrorAt(index, onPattern);
+  }
+
+  resolveError(): void {
+    this._history.resolveError()
+  }
+
+  startRecording(): void {
+    this._history.startRecording();
+  }
+
+  stopRecording(): void {
+    this._history.stopRecording();
+  }
+
+  private _getLastIndex(): number {
+    return this._length - 1;
+  }
+}

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);
+    });
+});