clarity-pattern-parser 10.0.8 → 10.1.0

package/dist/patterns/Cursor.d.ts

@@ -19,6 +19,7 @@ export declare class Cursor {
     get furthestError(): ParseError | null;
     get error(): ParseError | null;
     get errors(): ParseError[];
+    get records(): import("./CursorHistory").HistoryRecord[];
     get index(): number;
     get length(): number;
     get hasError(): boolean;

package/dist/patterns/CursorHistory.d.ts

@@ -5,6 +5,11 @@ export interface Match {
     pattern: Pattern | null;
     node: Node | null;
 }
+export interface HistoryRecord {
+    pattern: Pattern;
+    error: ParseError | null;
+    ast: Node | null;
+}
 export declare class CursorHistory {
     private _isRecording;
     private _leafMatches;
@@ -14,6 +19,7 @@ export declare class CursorHistory {
     private _patterns;
     private _nodes;
     private _errors;
+    private _records;
     get isRecording(): boolean;
     get rootMatch(): Match;
     get leafMatch(): Match;
@@ -21,6 +27,7 @@ export declare class CursorHistory {
     get furthestError(): ParseError | null;
     get errors(): ParseError[];
     get error(): ParseError | null;
+    get records(): HistoryRecord[];
     get nodes(): Node[];
     get patterns(): Pattern[];
     recordMatch(pattern: Pattern, node: Node): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "10.0.8",
+  "version": "10.1.0",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",

package/src/patterns/Cursor.test.ts

@@ -1,6 +1,21 @@
 import { Cursor } from "./Cursor";
 import { Literal } from "./Literal";
-import { Node } from "../ast/Node"
+import { Node } from "../ast/Node";
+import { patterns } from "../grammar/patterns";
+
+const { name } = patterns`
+    john = "John"
+    jane = "Jane"
+    first-names = john | jane
+
+    doe = "Doe"
+    smith = "Smith"
+    last-names = doe | smith
+
+    space = " " 
+
+    name = first-names + space + last-names
+`;
 
 describe("Cursor", () => {
     test("Empty Text", () => {
@@ -20,7 +35,7 @@ describe("Cursor", () => {
         const cursor = new Cursor("Hello World!");
         cursor.moveTo(6);
 
-        expect(cursor.currentChar).toBe("W")
+        expect(cursor.currentChar).toBe("W");
 
         cursor.moveToFirstChar();
         cursor.previous();
@@ -35,7 +50,7 @@ describe("Cursor", () => {
         cursor.moveToLastChar();
         cursor.next();
 
-        expect(cursor.isOnLast).toBeTruthy()
+        expect(cursor.isOnLast).toBeTruthy();
         expect(cursor.currentChar).toBe("!");
 
         cursor.previous();
@@ -69,7 +84,7 @@ describe("Cursor", () => {
 
         const cursor = new Cursor("Hello World!");
 
-        cursor.recordMatch(pattern, node)
+        cursor.recordMatch(pattern, node);
 
         expect(cursor.leafMatch.node).toBe(node);
         expect(cursor.leafMatch.pattern).toBe(pattern);
@@ -96,7 +111,46 @@ describe("Cursor", () => {
 
         expect(hello).toBe("Hello");
         expect(cursor.length).toBe(12);
-        expect(cursor.text).toBe("Hello World!")
+        expect(cursor.text).toBe("Hello World!");
         expect(cursor.index).toBe(0);
     });
+
+    test("Records All matches", () => {
+        const { ast, cursor } = name.exec("John Doe", true);
+        const records = cursor.records;
+
+        expect(ast?.toString()).toBe("John Doe");
+        expect(records[0].ast?.toString()).toBe("John");
+        expect(records[1].ast?.toString()).toBe(" ");
+        expect(records[2].ast?.toString()).toBe("Doe");
+        expect(records[3].ast?.toString()).toBe("John Doe");
+    });
+
+    test("Records Some Error Some Matches", () => {
+        const { ast, cursor } = name.exec("John Smith", true);
+        const records = cursor.records;
+
+        expect(ast?.toString()).toBe("John Smith");
+        expect(records[0].ast?.toString()).toBe("John");
+        expect(records[1].ast?.toString()).toBe(" ");
+        expect(records[2].error?.pattern.name).toBe("doe");
+        expect(records[2].error?.startIndex).toBe(5);
+        expect(records[2].error?.endIndex).toBe(5);
+        expect(records[3].ast?.toString()).toBe("Smith");
+        expect(records[4].ast?.toString()).toBe("John Smith");
+    });
+
+    test("Records All Errors", () => {
+        const { ast, cursor } = name.exec("Jack Smith", true);
+        const records = cursor.records;
+
+        expect(ast).toBeNull();
+        expect(records[0].error).not.toBeNull();
+        expect(records[0].pattern.name).toBe("john");
+        expect(records[1].error).not.toBeNull();
+        expect(records[1].pattern.name).toBe("jane");
+        expect(records[2].error).not.toBeNull();
+        expect(records[2].pattern.name).toBe("first-names");
+    });
+
 });

package/src/patterns/Cursor.ts

@@ -57,6 +57,10 @@ export class Cursor {
     return this._history.errors;
   }
 
+  get records() {
+    return this._history.records;
+  }
+
   get index(): number {
     return this._index;
   }

package/src/patterns/CursorHistory.ts

@@ -7,6 +7,12 @@ export interface Match {
   node: Node | null;
 }
 
+export interface HistoryRecord {
+  pattern: Pattern;
+  error: ParseError | null;
+  ast: Node | null;
+}
+
 export class CursorHistory {
   private _isRecording = false;
   private _leafMatches: Match[] = [{ pattern: null, node: null }];
@@ -16,6 +22,7 @@ export class CursorHistory {
   private _patterns: Pattern[] = [];
   private _nodes: Node[] = [];
   private _errors: ParseError[] = [];
+  private _records: HistoryRecord[] = [];
 
   get isRecording(): boolean {
     return this._isRecording;
@@ -45,6 +52,10 @@ export class CursorHistory {
     return this._currentError;
   }
 
+  get records(): HistoryRecord[] {
+    return this._records;
+  }
+
   get nodes(): Node[] {
     return this._nodes;
   }
@@ -57,6 +68,11 @@ export class CursorHistory {
     if (this._isRecording) {
       this._patterns.push(pattern);
       this._nodes.push(node);
+      this._records.push({
+        pattern,
+        ast: node,
+        error: null
+      });
     }
 
     this._rootMatch.pattern = pattern;
@@ -106,6 +122,11 @@ export class CursorHistory {
 
     if (this._isRecording) {
       this._errors.push(error);
+      this.records.push({
+        pattern,
+        ast: null,
+        error
+      });
     }
   }