clarity-pattern-parser 11.2.2 → 11.3.0

package/dist/patterns/Cursor.d.ts

@@ -19,7 +19,7 @@ export declare class Cursor {
     get furthestError(): ParseError | null;
     get error(): ParseError | null;
     get errors(): ParseError[];
-    get records(): import("./CursorHistory").HistoryRecord[];
+    get records(): import("./HistoryRecord").HistoryRecord[];
     get index(): number;
     get length(): number;
     get hasError(): boolean;
@@ -35,7 +35,7 @@ export declare class Cursor {
     getLastIndex(): number;
     getChars(first: number, last: number): string;
     recordMatch(pattern: Pattern, node: Node): void;
-    recordErrorAt(startIndex: number, endIndex: number, onPattern: Pattern): void;
+    recordErrorAt(startIndex: number, lastIndex: number, onPattern: Pattern): void;
     resolveError(): void;
     startRecording(): void;
     stopRecording(): void;

package/dist/patterns/CursorHistory.d.ts

@@ -1,15 +1,11 @@
 import { Node } from "../ast/Node";
 import { ParseError } from "./ParseError";
 import { Pattern } from "./Pattern";
+import { HistoryRecord } from "./HistoryRecord";
 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;
@@ -32,7 +28,7 @@ export declare class CursorHistory {
     get patterns(): Pattern[];
     recordMatch(pattern: Pattern, node: Node): void;
     recordErrorAt(startIndex: number, lastIndex: number, pattern: Pattern): void;
+    resolveError(): void;
     startRecording(): void;
     stopRecording(): void;
-    resolveError(): void;
 }

package/dist/patterns/HistoryRecord.d.ts

@@ -0,0 +1,8 @@
+import { Node } from "../ast/Node";
+import { ParseError } from "./ParseError";
+import { Pattern } from "./Pattern";
+export interface HistoryRecord {
+    pattern: Pattern;
+    error: ParseError | null;
+    ast: Node | null;
+}

package/package.json

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

package/src/ast/Node.test.ts

@@ -295,7 +295,7 @@ describe("Node", () => {
         const parent = new Node("parent", "parent", 0, 0, [a, b]);
         const clone = parent.clone();
 
-        expect(clone).toEqual(parent);
+        expect(clone.isEqual(parent)).toBeTruthy();
     });
 
     test("Turn Into JSON", () => {
@@ -304,12 +304,14 @@ describe("Node", () => {
         const parent = new Node("parent", "parent", 0, 0, [a, b]);
         const result = parent.toJson();
         const expected = JSON.stringify({
+            id: parent.id,
             type: "parent",
             name: "parent",
             value: "AB",
             startIndex: 0,
             endIndex: 1,
             children: [{
+                id: parent.children[0].id,
                 type: "a",
                 name: "a",
                 value: "A",
@@ -317,6 +319,7 @@ describe("Node", () => {
                 endIndex: 1,
                 children: [],
             }, {
+                id: parent.children[1].id,
                 type: "b",
                 name: "b",
                 value: "B",
@@ -471,7 +474,7 @@ describe("Node", () => {
             Node.createValueNode("family", "aunt", "aunt")
         ]);
 
-        expect(result.toJson()).toBe(expected.toJson());
+        expect(result.isEqual(expected)).toBeTruthy();
     });
 
 });

package/src/ast/Node.ts

@@ -2,7 +2,10 @@ function defaultVisitor(node: Node) {
   return node;
 }
 
+let idIndex = 0;
+
 export interface CycleFreeNode {
+  id: string;
   type: string;
   name: string;
   startIndex: number;
@@ -12,6 +15,7 @@ export interface CycleFreeNode {
 }
 
 export class Node {
+  private _id: string;
   private _type: string;
   private _name: string;
   private _firstIndex: number;
@@ -20,6 +24,10 @@ export class Node {
   private _children: Node[];
   private _value: string;
 
+  get id() {
+    return this._id;
+  }
+
   get type() {
     return this._type;
   }
@@ -72,6 +80,7 @@ export class Node {
     children: Node[] = [],
     value = ""
   ) {
+    this._id = String(idIndex++);
     this._type = type;
     this._name = name;
     this._firstIndex = firstIndex;
@@ -280,7 +289,7 @@ export class Node {
   }
 
   clone(): Node {
-    return new Node(
+    const node = new Node(
       this._type,
       this._name,
       this._firstIndex,
@@ -288,6 +297,8 @@ export class Node {
       this._children.map((c) => c.clone()),
       this._value
     );
+
+    return node;
   }
 
   normalize(startIndex = this._firstIndex): number {
@@ -320,6 +331,7 @@ export class Node {
 
   toCycleFreeObject(): CycleFreeNode {
     return {
+      id: this._id,
       type: this._type,
       name: this._name,
       value: this.toString(),
@@ -333,8 +345,13 @@ export class Node {
     return JSON.stringify(this.toCycleFreeObject(), null, space);
   }
 
-  isEqual(node: Node) {
-    return node.toJson(0) === this.toJson(0);
+  isEqual(node: Node): boolean {
+    return node._type === this._type &&
+      node._name === this._name &&
+      node._firstIndex === this._firstIndex &&
+      node._lastIndex === this._lastIndex &&
+      node._value === this._value &&
+      this._children.every((child, index) => child.isEqual(node._children[index]));
   }
 
   static createValueNode(type: string, name: string, value = "") {

package/src/patterns/Cursor.ts

@@ -130,8 +130,8 @@ export class Cursor {
     this._history.recordMatch(pattern, node);
   }
 
-  recordErrorAt(startIndex: number, endIndex: number, onPattern: Pattern): void {
-    this._history.recordErrorAt(startIndex, endIndex, onPattern);
+  recordErrorAt(startIndex: number, lastIndex: number, onPattern: Pattern): void {
+    this._history.recordErrorAt(startIndex, lastIndex, onPattern);
   }
 
   resolveError(): void {

package/src/patterns/CursorHistory.ts

@@ -1,18 +1,13 @@
 import { Node } from "../ast/Node";
 import { ParseError } from "./ParseError";
 import { Pattern } from "./Pattern";
+import { HistoryRecord } from "./HistoryRecord";
 
 export interface Match {
   pattern: Pattern | null;
   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 }];
@@ -65,14 +60,16 @@ export class CursorHistory {
   }
 
   recordMatch(pattern: Pattern, node: Node): void {
+    const record: HistoryRecord = {
+      pattern,
+      ast: node,
+      error: null
+    };
+
     if (this._isRecording) {
       this._patterns.push(pattern);
       this._nodes.push(node);
-      this._records.push({
-        pattern,
-        ast: node,
-        error: null
-      });
+      this._records.push(record);
     }
 
     this._rootMatch.pattern = pattern;
@@ -114,6 +111,12 @@ export class CursorHistory {
 
   recordErrorAt(startIndex: number, lastIndex: number, pattern: Pattern): void {
     const error = new ParseError(startIndex, lastIndex, pattern);
+    const record: HistoryRecord = {
+      pattern,
+      ast: null,
+      error
+    };
+
     this._currentError = error;
 
     if (this._furthestError === null || lastIndex > this._furthestError.lastIndex) {
@@ -122,14 +125,14 @@ export class CursorHistory {
 
     if (this._isRecording) {
       this._errors.push(error);
-      this.records.push({
-        pattern,
-        ast: null,
-        error
-      });
+      this.records.push(record);
     }
   }
 
+  resolveError() {
+    this._currentError = null;
+  }
+
   startRecording(): void {
     this._isRecording = true;
   }
@@ -138,8 +141,4 @@ export class CursorHistory {
     this._isRecording = false;
   }
 
-  resolveError() {
-    this._currentError = null;
-  }
-
 }

package/src/patterns/FiniteRepeat.test.ts

@@ -26,7 +26,7 @@ describe("BoundedRepeat", () => {
             new Node("regex", "number", 1, 1, [], "2"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
 
         cursor = new Cursor("123");
@@ -37,7 +37,7 @@ describe("BoundedRepeat", () => {
             new Node("regex", "number", 2, 2, [], "3"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
 
         cursor = new Cursor("1234");
@@ -48,7 +48,7 @@ describe("BoundedRepeat", () => {
             new Node("regex", "number", 2, 2, [], "3"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
         expect(cursor.index).toBe(2);
 
@@ -59,7 +59,7 @@ describe("BoundedRepeat", () => {
             new Node("regex", "number", 1, 1, [], "2"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
     });
 
@@ -87,7 +87,7 @@ describe("BoundedRepeat", () => {
             new Node("regex", "number", 2, 2, [], "3"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
 
         cursor = new Cursor("1234");
@@ -98,7 +98,7 @@ describe("BoundedRepeat", () => {
             new Node("regex", "number", 2, 2, [], "3"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
         expect(cursor.index).toBe(2);
 
@@ -122,7 +122,7 @@ describe("BoundedRepeat", () => {
             new Node("regex", "number", 2, 2, [], "2"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
 
         cursor = new Cursor("1,2,3,");
@@ -135,7 +135,7 @@ describe("BoundedRepeat", () => {
             new Node("regex", "number", 4, 4, [], "3"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
 
         cursor = new Cursor("1,2,3,4");
@@ -148,7 +148,7 @@ describe("BoundedRepeat", () => {
             new Node("regex", "number", 4, 4, [], "3"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
     });
 
@@ -171,7 +171,7 @@ describe("BoundedRepeat", () => {
             new Node("regex", "divider", 4, 4, [], "\n"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
     });
 
@@ -202,7 +202,7 @@ describe("BoundedRepeat", () => {
             new Node("regex", "number", 4, 4, [], "3"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
 
         cursor = new Cursor("1,2,3,4");
@@ -215,7 +215,7 @@ describe("BoundedRepeat", () => {
             new Node("regex", "number", 4, 4, [], "3"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
     });
 

package/src/patterns/HistoryRecord.ts

@@ -0,0 +1,9 @@
+import { Node } from "../ast/Node";
+import { ParseError } from "./ParseError";
+import { Pattern } from "./Pattern";
+
+export interface HistoryRecord {
+    pattern: Pattern;
+    error: ParseError | null;
+    ast: Node | null;
+}

package/src/patterns/InfiniteRepeat.test.ts

@@ -20,7 +20,7 @@ describe("InfiniteRepeat", () => {
             new Node("regex", "digit", 2, 2, [], "7"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
     });
 
@@ -32,7 +32,7 @@ describe("InfiniteRepeat", () => {
         let result = integer.parse(cursor);
         let expected: Node | null = null;
 
-        expect(result).toEqual(expected);
+        expect(result).toBeNull();
         expect(cursor.hasError).toBeTruthy();
 
         cursor = new Cursor("33");
@@ -42,7 +42,7 @@ describe("InfiniteRepeat", () => {
             new Node("regex", "digit", 1, 1, [], "3")
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
     });
 
@@ -70,7 +70,7 @@ describe("InfiniteRepeat", () => {
             new Node("regex", "digit", 4, 4, [], "7"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
     });
 
@@ -88,7 +88,7 @@ describe("InfiniteRepeat", () => {
             new Node("regex", "digit", 4, 4, [], "7"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
     });
 
@@ -106,7 +106,7 @@ describe("InfiniteRepeat", () => {
             new Node("regex", "digit", 4, 4, [], "7"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.hasError).toBeFalsy();
     });
 

package/src/patterns/Literal.test.ts

@@ -17,12 +17,12 @@ describe("Literal", () => {
         const result = literal.parse(cursor);
         const expected = new Node("literal", "greeting", 0, 11, [], "Hello World!");
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
         expect(cursor.index).toBe(11);
         expect(cursor.error).toBeNull();
-        expect(cursor.leafMatch.node).toEqual(expected);
+        expect(cursor.leafMatch.node?.isEqual(expected)).toBeTruthy();
         expect(cursor.leafMatch.pattern).toBe(literal);
-        expect(cursor.rootMatch.node).toEqual(expected);
+        expect(cursor.rootMatch.node?.isEqual(expected)).toBeTruthy();
         expect(cursor.rootMatch.pattern).toBe(literal);
     });
 

package/src/patterns/Not.test.ts

@@ -31,7 +31,7 @@ describe("Not", () => {
         const clone = notA.clone();
 
         expect(clone.name).toBe("not-a");
-        expect(clone).not.toBe(notA)
+        expect(clone).not.toBe(notA);
     });
 
     test("Tokens", () => {

package/src/patterns/Options.test.ts

@@ -22,7 +22,7 @@ describe("Options", () => {
         const result = a.parse(cursor);
         const expected = new Node("literal", "a", 0, 0, [], "A")
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
     });
 
     test("One Option Failed", () => {
@@ -39,9 +39,9 @@ describe("Options", () => {
         const a = new Options("a-b", [new Literal("a", "A"), new Literal("b", "B")]);
         const cursor = new Cursor("AB");
         let result = a.parse(cursor);
-        let expected = new Node("literal", "a", 0, 0, [], "A")
+        let expected = new Node("literal", "a", 0, 0, [], "A");
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected)).toBeTruthy();
 
         cursor.next();
 

package/src/patterns/PrecedenceTree.test.ts

@@ -40,7 +40,7 @@ describe("Precedence Tree", () => {
 
 
         expect(result?.toString()).toBe("a+b*c||d+e");
-        expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
+        expect(result?.isEqual(expected));
     });
 
     test("add Prefix", () => {
@@ -64,7 +64,7 @@ describe("Precedence Tree", () => {
         ]);
 
         expect(result?.toString()).toBe("!+++a");
-        expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
+        expect(result?.isEqual(expected));
     });
 
     test("add Postfix", () => {
@@ -84,7 +84,7 @@ describe("Precedence Tree", () => {
 
         const result = tree.commit();
         expect(result?.toString()).toBe("a--++");
-        expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
+        expect(result?.isEqual(expected));
     });
 
     test("all", () => {
@@ -120,7 +120,7 @@ describe("Precedence Tree", () => {
         ]);
 
         expect(result?.toString()).toBe("!a++*b+c");
-        expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
+        expect(result?.isEqual(expected));
     });
 
     test("Incomplete", () => {
@@ -157,7 +157,7 @@ describe("Precedence Tree", () => {
         ]);
 
         expect(result?.toString()).toBe("!a++*b+c");
-        expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
+        expect(result?.isEqual(expected));
     });
 
     test("add Partial Binary With Lower Precedence", () => {
@@ -187,7 +187,7 @@ describe("Precedence Tree", () => {
 
 
         expect(result?.toString()).toBe("a+b*c");
-        expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
+        expect(result?.isEqual(expected));
     });
 
     test("add Partial Binary With Equal Precedence", () => {
@@ -216,7 +216,7 @@ describe("Precedence Tree", () => {
         ]);
 
         expect(result?.toString()).toBe("a+b*c");
-        expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
+        expect(result?.isEqual(expected));
     });
 
     test("add Partial Binary With Equal Precedence And Right Associated", () => {
@@ -245,7 +245,7 @@ describe("Precedence Tree", () => {
         ]);
 
         expect(result?.toString()).toBe("a+b*c");
-        expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
+        expect(result?.isEqual(expected));
     });
 
     test("mul Partial Binary With Greater Precedence", () => {
@@ -269,6 +269,6 @@ describe("Precedence Tree", () => {
         ]);
 
         expect(result?.toString()).toBe("a+b");
-        expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
+        expect(result?.isEqual(expected));
     });
 });

package/src/patterns/Reference.test.ts

@@ -42,7 +42,7 @@ describe("Reference", () => {
             new Node("literal", "close-bracket", 5, 5, [], "]"),
         ]);
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected));
     });
 
     test("No Reference Pattern", () => {

package/src/patterns/Regex.test.ts

@@ -24,7 +24,7 @@ describe("Regex", () => {
         const result = number.parse(cursor);
         const expected = new Node("regex", "number", 0, 0, [], "1");
 
-        expect(result).toEqual(expected);
+        expect(result?.isEqual(expected));
         expect(cursor.hasError).toBeFalsy();
     });
 

package/src/patterns/Repeat.test.ts

@@ -17,7 +17,7 @@ describe("Repeat", () => {
         let result = finiteRepeat.parse(cursor);
         let expected: Node | null = null;
 
-        expect(result).toBe(expected);
+        expect(result).toBeNull();
         expect(cursor.hasError).toBeTruthy();
 
         cursor = new Cursor("1");
@@ -26,7 +26,7 @@ describe("Repeat", () => {
             new Node("regex", "number", 0, 0, [], "1")
         ]);
 
-        expect(result?.toJson()).toEqual(expected.toJson());
+        expect(result?.isEqual(expected));
         expect(cursor.hasError).toBeFalsy();
 
         cursor = new Cursor("12");
@@ -36,7 +36,7 @@ describe("Repeat", () => {
             new Node("regex", "number", 1, 1, [], "2")
         ]);
 
-        expect(result?.toJson()).toEqual(expected.toJson());
+        expect(result?.isEqual(expected));
         expect(cursor.hasError).toBeFalsy();
 
         cursor = new Cursor("123");
@@ -46,7 +46,7 @@ describe("Repeat", () => {
             new Node("regex", "number", 1, 1, [], "2")
         ]);
 
-        expect(result?.toJson()).toEqual(expected.toJson());
+        expect(result?.isEqual(expected));
         expect(cursor.hasError).toBeFalsy();
         expect(cursor.index).toBe(1);
     });
@@ -59,14 +59,14 @@ describe("Repeat", () => {
         let result = finiteRepeat.parse(cursor);
         let expected: Node | null = null;
 
-        expect(result).toBe(expected);
+        expect(result).toBeNull();
         expect(cursor.hasError).toBeTruthy();
 
         cursor = new Cursor("1");
         result = finiteRepeat.parse(cursor);
         expected = null;
 
-        expect(result).toEqual(expected);
+        expect(result).toBeNull();
         expect(cursor.hasError).toBeTruthy();
 
         cursor = new Cursor("12");
@@ -76,7 +76,7 @@ describe("Repeat", () => {
             new Node("regex", "number", 1, 1, [], "2")
         ]);
 
-        expect(result?.toJson()).toEqual(expected.toJson());
+        expect(result?.isEqual(expected));
         expect(cursor.hasError).toBeFalsy();
 
         cursor = new Cursor("123");
@@ -86,7 +86,7 @@ describe("Repeat", () => {
             new Node("regex", "number", 1, 1, [], "2")
         ]);
 
-        expect(result?.toJson()).toEqual(expected.toJson());
+        expect(result?.isEqual(expected));
         expect(cursor.hasError).toBeFalsy();
         expect(cursor.index).toBe(1);
     });