clarity-pattern-parser 9.2.5 → 10.0.0

package/src/patterns/CursorHistory.ts

@@ -106,11 +106,11 @@ export class CursorHistory {
     }
   }
 
-  recordErrorAt(firstIndex: number, lastIndex: number, pattern: Pattern): void {
-    const error = new ParseError(firstIndex, lastIndex, pattern);
+  recordErrorAt(startIndex: number, endIndex: number, pattern: Pattern): void {
+    const error = new ParseError(startIndex, endIndex, pattern);
     this._currentError = error;
 
-    if (this._furthestError === null || lastIndex > this._furthestError.endIndex) {
+    if (this._furthestError === null || endIndex > this._furthestError.endIndex) {
       this._furthestError = error;
     }
 

package/src/patterns/FiniteRepeat.test.ts

@@ -4,7 +4,6 @@ import { Regex } from "./Regex";
 import { Node } from "../ast/Node";
 import { Literal } from "./Literal";
 import { Sequence } from "./Sequence";
-import { arePatternsEqual } from "./arePatternsEqual";
 import { Optional } from "./Optional";
 
 describe("BoundedRepeat", () => {
@@ -287,22 +286,22 @@ describe("BoundedRepeat", () => {
         let clone = numbers.clone();
         let expected = new FiniteRepeat("numbers", new Regex("number", "\\d"), { min: 0, max: 3 });
 
-        expect(arePatternsEqual(clone, expected)).toBeTruthy();
+        expect(clone.isEqual(expected)).toBeTruthy();
 
         clone = numbers.clone("cloned-numbers");
         expected = new FiniteRepeat("cloned-numbers", new Regex("number", "\\d"), { min: 0, max: 3 });
 
-        expect(arePatternsEqual(clone, expected)).toBeTruthy();
+        expect(clone.isEqual(expected)).toBeTruthy();
 
         clone = numbers.clone("cloned-numbers");
         expected = new FiniteRepeat("cloned-numbers", new Regex("number", "\\d"), { min: 0, max: 3 });
 
-        expect(arePatternsEqual(clone, expected)).toBeTruthy();
+        expect(clone.isEqual(expected)).toBeTruthy();
 
         clone = numbers.clone("cloned-numbers");
         expected = new FiniteRepeat("cloned-numbers", new Regex("number", "\\d"), { min: 0, max: 3 });
 
-        expect(arePatternsEqual(clone, expected)).toBeTruthy();
+        expect(clone.isEqual(expected)).toBeTruthy();
     });
 
     test("Get Tokens", () => {

package/src/patterns/InfiniteRepeat.test.ts

@@ -6,7 +6,6 @@ import { Literal } from "./Literal";
 import { Pattern } from "./Pattern";
 import { Regex } from "./Regex";
 import { InfiniteRepeat } from "./InfiniteRepeat";
-import { arePatternsEqual } from "./arePatternsEqual";
 import { Optional } from "./Optional";
 
 describe("InfiniteRepeat", () => {
@@ -254,7 +253,7 @@ describe("InfiniteRepeat", () => {
         let clone = numbers.clone();
         let expected = new InfiniteRepeat("numbers", new Regex("number", "\\d"), { min: 3, divider: new Literal("divider", "divider"), trimDivider: true });
 
-        expect(arePatternsEqual(clone, expected)).toBeTruthy();
+        expect(clone.isEqual(expected)).toBeTruthy();
     });
 
     test("No Results, min is 0", () => {

package/src/patterns/Literal.ts

@@ -10,7 +10,7 @@ export class Literal implements Pattern {
   private _type: string;
   private _name: string;
   private _parent: Pattern | null;
-  private _text: string;
+  private _token: string;
   private _runes: string[];
   private _firstIndex: number;
   private _lastIndex: number;
@@ -28,8 +28,8 @@ export class Literal implements Pattern {
     return this._name;
   }
 
-  get value(): string {
-    return this._text;
+  get token(): string {
+    return this._token;
   }
 
   get parent(): Pattern | null {
@@ -52,7 +52,7 @@ export class Literal implements Pattern {
     this._id = `literal-${idIndex++}`;
     this._type = "literal";
     this._name = name;
-    this._text = value;
+    this._token = value;
     this._runes = Array.from(value);
     this._parent = null;
     this._firstIndex = 0;
@@ -60,8 +60,10 @@ export class Literal implements Pattern {
     this._endIndex = 0;
   }
 
-  test(text: string) {
+  test(text: string, record = false) {
     const cursor = new Cursor(text);
+    record && cursor.startRecording();
+
     const ast = this.parse(cursor);
 
     return ast?.value === text;
@@ -83,7 +85,6 @@ export class Literal implements Pattern {
     cursor.startParseWith(this);
 
     this._firstIndex = cursor.index;
-
     const passed = this._tryToParse(cursor);
 
     if (passed) {
@@ -114,7 +115,7 @@ export class Literal implements Pattern {
       }
 
       if (i + 1 === literalRuneLength) {
-        this._lastIndex = this._firstIndex + this._text.length - 1;
+        this._lastIndex = this._firstIndex + this._token.length - 1;
         passed = true;
         break;
       }
@@ -137,18 +138,18 @@ export class Literal implements Pattern {
       this._firstIndex,
       this._lastIndex,
       undefined,
-      this._text
+      this._token
     );
   }
 
   clone(name = this._name): Pattern {
-    const clone = new Literal(name, this._text);
+    const clone = new Literal(name, this._token);
     clone._id = this._id;
     return clone;
   }
 
   getTokens(): string[] {
-    return [this._text];
+    return [this._token];
   }
 
   getTokensAfter(_lastMatched: Pattern): string[] {
@@ -184,6 +185,6 @@ export class Literal implements Pattern {
   }
 
   isEqual(pattern: Literal) {
-    return pattern.type === this.type && pattern._text === this._text;
+    return pattern.type === this.type && pattern._token === this._token;
   }
 }

package/src/patterns/ParseError.ts

@@ -1,7 +1,7 @@
 import { Pattern } from "./Pattern";
 
 export class ParseError {
-  public startIndex: number
+  public startIndex: number;
   public endIndex: number;
   public pattern: Pattern;
 

package/src/patterns/Pattern.ts

@@ -19,6 +19,6 @@ export interface Pattern {
   getPatterns(): Pattern[];
   getPatternsAfter(childReference: Pattern): Pattern[];
   getNextPatterns(): Pattern[];
-  find(predicate: (p: Pattern) => boolean): Pattern | null;
+  find(predicate: (pattern: Pattern) => boolean): Pattern | null;
   isEqual(pattern: Pattern): boolean;
 }

package/src/patterns/Repeat.test.ts

@@ -1,6 +1,5 @@
 import { Node } from "../ast/Node";
 import { Sequence } from "./Sequence";
-import { arePatternsEqual } from "./arePatternsEqual";
 import { Cursor } from "./Cursor";
 import { InfiniteRepeat } from "./InfiniteRepeat";
 import { Literal } from "./Literal";
@@ -202,11 +201,11 @@ describe("Repeat", () => {
         let repeatClone = repeat.clone();
         let expected = new Repeat("numbers", number);
 
-        expect(arePatternsEqual(repeatClone, expected)).toBeTruthy();
+        expect(repeatClone.isEqual(expected)).toBeTruthy();
 
         repeatClone = repeat.clone("new-name");
         expected = new Repeat("new-name", number);
 
-        expect(arePatternsEqual(repeatClone, expected)).toBeTruthy();
+        expect(repeatClone.isEqual(expected)).toBeTruthy();
     });
 });

package/src/patterns/arePatternsEqual.ts

@@ -1,12 +0,0 @@
-import { Literal } from "./Literal";
-import { Pattern } from "./Pattern";
-
-export function arePatternsEqual(a?: Pattern | null, b?: Pattern | null): boolean {
-    if (a === b) {
-        return true;
-    } else if (a == null || b == null) {
-        return false;
-    }
-
-    return a.isEqual(b);
-}