clarity-pattern-parser 5.0.0 → 6.0.0

package/src/patterns/And.ts

@@ -3,7 +3,6 @@ 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 {
@@ -14,7 +13,6 @@ export class And implements Pattern {
   private _isOptional: boolean;
   private _nodes: (Node | null)[];
   private _firstIndex: number;
-  private _shouldReduceAst: boolean;
 
   get type(): string {
     return this._type;
@@ -54,7 +52,6 @@ export class And implements Pattern {
     this._parent = null;
     this._children = children;
     this._firstIndex = -1
-    this._shouldReduceAst = false;
     this._nodes = [];
   }
 
@@ -64,12 +61,19 @@ export class And implements Pattern {
     }
   }
 
-  parseText(text: string) {
+  test(text: string) {
     const cursor = new Cursor(text);
-    const ast = this.parse(cursor)
+    const ast = this.parse(cursor);
+
+    return ast?.value === text;
+  }
+
+  exec(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor);
 
     return {
-      ast,
+      ast: ast?.value === text ? ast : null,
       cursor
     };
   }
@@ -115,32 +119,41 @@ export class And implements Pattern {
         if (hasMorePatterns) {
           if (hadMatch) {
             if (cursor.hasNext()) {
+              // We had a match. Increment the cursor and use the next pattern.
               cursor.next();
               continue;
             } else {
+              // We are at the end of the text, it may still be valid, if all the
+              // following patterns are optional.
               if (this.areRemainingPatternsOptional(i)) {
                 passed = true;
                 break;
               }
 
+              // We didn't finish the parsing sequence.
               cursor.recordErrorAt(cursor.index + 1, this);
               break;
             }
           } else {
+            // An optional pattern did not matched, try from the same spot on the next
+            // pattern.
             cursor.moveTo(runningCursorIndex);
             continue;
           }
         } else {
+          // If we don't have any results from what we parsed then record error.
           const lastNode = this.getLastValidNode();
           if (lastNode === null) {
             cursor.recordErrorAt(cursor.index, this);
             break;
           }
 
+          // The sequence was parsed fully.
           passed = true;
           break;
         }
       } else {
+        // The pattern failed.
         cursor.moveTo(this._firstIndex);
         break;
       }
@@ -181,28 +194,15 @@ export class And implements Pattern {
 
     cursor.moveTo(lastIndex)
 
-    if (this._shouldReduceAst) {
-      children.length = 0;
-    }
-
     return new Node(
       "and",
       this._name,
       this._firstIndex,
       lastIndex,
-      children,
-      this._shouldReduceAst ? value : undefined
+      children
     );
   }
 
-  enableAstReduction(): void {
-    this._shouldReduceAst = true;
-  }
-
-  disableAstReduction(): void {
-    this._shouldReduceAst = false;
-  }
-
   getTokens(): string[] {
     const tokens: string[] = [];
 
@@ -217,14 +217,31 @@ export class And implements Pattern {
     return tokens;
   }
 
-  getNextTokens(lastMatched: Pattern): string[] {
+  getTokensAfter(childReference: Pattern): string[] {
+    const patterns = this.getPatternsAfter(childReference);
+    const tokens: string[] = [];
+
+    patterns.forEach(p => tokens.push(...p.getTokens()));
+
+    return tokens;
+  }
+
+  getNextTokens(): string[] {
+    if (this.parent == null) {
+      return []
+    }
+
+    return this.parent.getTokensAfter(this);
+  }
+
+  getPatternsAfter(childReference: Pattern): Pattern[] {
     let nextSibling: Pattern | null = null;
     let nextSiblingIndex = -1;
     let index = -1;
-    const tokens: string[] = [];
+    const patterns: Pattern[] = [];
 
     for (let i = 0; i < this._children.length; i++) {
-      if (this._children[i] === lastMatched) {
+      if (this._children[i] === childReference) {
         if (i + 1 < this._children.length) {
           nextSibling = this._children[i + 1];
         }
@@ -234,48 +251,53 @@ export class And implements Pattern {
       }
     }
 
+    // The child reference isn't one of the child patterns.
     if (index === -1) {
       return [];
     }
 
+    // The reference pattern is the last child. So ask the parent for the next pattern.
     if (nextSiblingIndex === this._children.length && this._parent !== null) {
-      return this._parent.getNextTokens(this);
+      return this._parent.getPatternsAfter(this);
     }
 
+    // Next pattern isn't optional so send it back as the next patterns.
     if (nextSibling !== null && !nextSibling.isOptional) {
-      return nextSibling.getTokens();
+      return [nextSibling];
     }
 
+    // Send back as many optional patterns as possible.
     if (nextSibling !== null && nextSibling.isOptional) {
       for (let i = nextSiblingIndex; i < this._children.length; i++) {
         const child = this._children[i];
-        tokens.push(...child.getTokens());
+        patterns.push(child);
 
         if (!child.isOptional) {
           break;
         }
 
         if (i === this._children.length - 1 && this._parent !== null) {
-          tokens.push(...this._parent.getNextTokens(this));
+          patterns.push(...this._parent.getPatternsAfter(this));
         }
       }
     }
 
-    return tokens;
+    return patterns;
   }
 
-  getNextPattern(): Pattern | null {
-    return getNextPattern(this)
+  getNextPatterns(): Pattern[] {
+    if (this.parent == null) {
+      return [];
+    }
+
+    return this.parent.getPatternsAfter(this)
   }
 
-  findPattern(isMatch: (p: Pattern)=>boolean): Pattern | null{
-    return findPattern(this, isMatch);
+  findPattern(predicate: (p: Pattern) => boolean): Pattern | null {
+    return findPattern(this, predicate);
   }
 
   clone(name = this._name, isOptional = this._isOptional): Pattern {
-    const and = new And(name, this._children, isOptional)
-    and._shouldReduceAst = this._shouldReduceAst;
-
-    return and
+    return new And(name, this._children, isOptional)
   }
 }

package/src/patterns/Cursor.ts

@@ -1,5 +1,7 @@
-import { Pattern, Node, ParseError } from "..";
+import { Node } from "../ast/Node";
 import { CursorHistory, Match } from "./CursorHistory";
+import { ParseError } from "./ParseError";
+import { Pattern } from "./Pattern";
 
 export class Cursor {
   private _text: string;
@@ -16,21 +18,21 @@ export class Cursor {
   }
 
   get isOnLast(): boolean {
-    return this._index === this._getLastIndex();
+    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 leafMatch(): Match {
+    return this._history.leafMatch;
+  }
+
   get furthestError(): ParseError | null {
     return this._history.furthestError;
   }
@@ -70,16 +72,16 @@ export class Cursor {
     return this._index + 1 < this._length;
   }
 
-  hasPrevious(): boolean {
-    return this._index - 1 >= 0;
-  }
-
   next(): void {
     if (this.hasNext()) {
       this._index++;
     }
   }
 
+  hasPrevious(): boolean {
+    return this._index - 1 >= 0;
+  }
+
   previous(): void {
     if (this.hasPrevious()) {
       this._index--;
@@ -97,7 +99,11 @@ export class Cursor {
   }
 
   moveToLastChar(): void {
-    this._index = this._getLastIndex();
+    this._index = this.getLastIndex();
+  }
+
+  getLastIndex(): number {
+    return this._length - 1;
   }
 
   getChars(first: number, last: number): string {
@@ -124,7 +130,4 @@ export class Cursor {
     this._history.stopRecording();
   }
 
-  private _getLastIndex(): number {
-    return this._length - 1;
-  }
 }

package/src/patterns/CursorHistory.ts

@@ -17,6 +17,14 @@ export class CursorHistory {
   private _nodes: Node[] = [];
   private _errors: ParseError[] = [];
 
+  get isRecording(): boolean {
+    return this._isRecording;
+  }
+
+  get rootMatch(): Match {
+    return this._rootMatch;
+  }
+
   get leafMatch(): Match {
     return this._leafMatch;
   }
@@ -25,10 +33,6 @@ export class CursorHistory {
     return this._furthestError;
   }
 
-  get isRecording(): boolean {
-    return this._isRecording;
-  }
-
   get errors(): ParseError[] {
     return this._errors;
   }
@@ -45,10 +49,6 @@ export class CursorHistory {
     return this._patterns;
   }
 
-  get rootMatch(): Match {
-    return this._rootMatch;
-  }
-
   recordMatch(pattern: Pattern, node: Node): void {
     if (this._isRecording) {
       this._patterns.push(pattern);

package/src/patterns/Literal.test.ts

@@ -70,53 +70,22 @@ describe("Literal", () => {
     });
 
     test("Get Tokens", () => {
-        const parent = new And("parent", [
-            new Literal("a", "A"),
-            new Literal("b", "B")
-        ]);
+        const a = new Literal("a", "A");
 
-        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"];
+        const tokens = a.getTokens();
+        const expectedTokens = ["A"];
 
         expect(tokens).toEqual(expectedTokens);
     });
 
-    test("Get Next Tokens", () => {
+    test("Get Tokens After", () => {
         const literal = new Literal("a", "A");
-        const tokens = literal.getNextTokens(new Literal("bogus", "bogus"));
+        const tokens = literal.getTokensAfter(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");
 
@@ -126,9 +95,72 @@ describe("Literal", () => {
         expect(literal.children).toEqual([]);
     });
 
-    test("Parse Text", () => {
+    test("Exec", () => {
         const literal = new Literal("a", "A");
-        const { ast: result } = literal.parseText("B");
+        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,6 +1,5 @@
 import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
-import { getNextPattern } from "./getNextPattern";
 import { Pattern } from "./Pattern";
 
 export class Literal implements Pattern {
@@ -12,8 +11,6 @@ export class Literal implements Pattern {
   private _runes: string[];
   private _firstIndex: number;
   private _lastIndex: number;
-  private _hasContextualTokenAggregation: boolean;
-  private _isRetrievingContextualTokens: boolean;
 
   get type(): string {
     return this._type;
@@ -40,10 +37,10 @@ export class Literal implements Pattern {
   }
 
   constructor(name: string, value: string, isOptional = false) {
-    if (value.length === 0){
+    if (value.length === 0) {
       throw new Error("Value Cannot be empty.");
     }
-    
+
     this._type = "literal";
     this._name = name;
     this._literal = value;
@@ -52,16 +49,21 @@ export class Literal implements Pattern {
     this._parent = null;
     this._firstIndex = 0;
     this._lastIndex = 0;
-    this._hasContextualTokenAggregation = false;
-    this._isRetrievingContextualTokens = false;
   }
 
-  parseText(text: string) {
+  test(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor);
+
+    return ast?.value === text;
+  }
+
+  exec(text: string) {
     const cursor = new Cursor(text);
-    const ast = this.parse(cursor)
+    const ast = this.parse(cursor);
 
     return {
-      ast,
+      ast: ast?.value === text ? ast : null,
       cursor
     };
   }
@@ -123,59 +125,46 @@ export class Literal implements Pattern {
       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);
-    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];
-    }
+    return [this._literal];
   }
 
-  getNextTokens(_lastMatched: Pattern): string[] {
+  getTokensAfter(_lastMatched: Pattern): string[] {
     return [];
   }
 
-  getNextPattern(): Pattern | null {
-    return getNextPattern(this)
+  getNextTokens(): string[] {
+    if (this.parent == null) {
+      return []
+    }
+
+    return this.parent.getTokensAfter(this);
   }
 
-  findPattern(_isMatch: (p: Pattern) => boolean): Pattern | null {
-    return null;
+  getPatternsAfter(): Pattern[] {
+    return []
   }
 
-  enableContextualTokenAggregation(): void {
-    this._hasContextualTokenAggregation = true;
+  getNextPatterns(): Pattern[] {
+    if (this.parent == null) {
+      return [];
+    }
+
+    return this.parent.getPatternsAfter(this)
   }
 
-  disableContextualTokenAggregation(): void {
-    this._hasContextualTokenAggregation = false;
+  findPattern(_predicate: (p: Pattern) => boolean): Pattern | null {
+    return null;
   }
 
 }