clarity-pattern-parser 6.0.2 → 7.0.0

package/src/patterns/Not.test.ts

@@ -88,7 +88,7 @@ describe("Not", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
         const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
 
-        const cloneNotAboutUs = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
+        const cloneNotAboutUs = sequence.find(p => p.name === "not-about-us") as Pattern;
         const nextTokens = cloneNotAboutUs.getNextTokens() || [];
 
         expect(nextTokens[0]).toBe("About Them");
@@ -105,7 +105,7 @@ describe("Not", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
         const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
 
-        const cloneNotAboutUs = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
+        const cloneNotAboutUs = sequence.find(p => p.name === "not-about-us") as Pattern;
         const nextTokens = cloneNotAboutUs.getTokens() || [];
 
         expect(nextTokens[0]).toBe("About Them");
@@ -114,8 +114,8 @@ describe("Not", () => {
     test("Get Tokens After", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
         const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
-        const notAboutUsClone = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
-        const aboutUsClone = sequence.findPattern(p => p.name === "about-us") as Pattern;
+        const notAboutUsClone = sequence.find(p => p.name === "not-about-us") as Pattern;
+        const aboutUsClone = sequence.find(p => p.name === "about-us") as Pattern;
         const nextTokens = notAboutUsClone.getTokensAfter(aboutUsClone) || [];
 
         expect(nextTokens[0]).toBe("About Them");
@@ -123,7 +123,7 @@ describe("Not", () => {
 
     test("Find Pattern", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
-        const child = notAboutUs.findPattern(p => p.name === "about-us")
+        const child = notAboutUs.find(p => p.name === "about-us")
 
         expect(child).not.toBeNull();
     });
@@ -132,9 +132,9 @@ describe("Not", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
         const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
 
-        const cloneNotAboutUs = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
+        const cloneNotAboutUs = sequence.find(p => p.name === "not-about-us") as Pattern;
         const nextPatterns = cloneNotAboutUs.getPatterns();
-        const expected = [sequence.findPattern(p=>p.name === "about-them")];
+        const expected = [sequence.find(p=>p.name === "about-them")];
 
         expect(nextPatterns).toEqual(expected);
     });
@@ -143,7 +143,7 @@ describe("Not", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
         const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
 
-        const cloneNotAboutUs = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
+        const cloneNotAboutUs = sequence.find(p => p.name === "not-about-us") as Pattern;
         const patterns = cloneNotAboutUs.getNextPatterns() || [];
 
         expect(patterns.length).toBe(1);
@@ -160,8 +160,8 @@ describe("Not", () => {
     test("Get Patterns After", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
         const sequence = new And("sequence", [notAboutUs, new Literal("about-them", "About Them")]);
-        const notAboutUsClone = sequence.findPattern(p => p.name === "not-about-us") as Pattern;
-        const aboutUsClone = sequence.findPattern(p => p.name === "about-us") as Pattern;
+        const notAboutUsClone = sequence.find(p => p.name === "not-about-us") as Pattern;
+        const aboutUsClone = sequence.find(p => p.name === "about-us") as Pattern;
         const patterns = notAboutUsClone.getPatternsAfter(aboutUsClone) || [];
 
         expect(patterns.length).toBe(1);
@@ -170,7 +170,7 @@ describe("Not", () => {
 
     test("Get Patterns After With Null Parent", () => {
         const notAboutUs = new Not("not-about-us", new Literal("about-us", "About Us"));
-        const aboutUsClone = notAboutUs.findPattern(p => p.name === "about-us") as Pattern;
+        const aboutUsClone = notAboutUs.find(p => p.name === "about-us") as Pattern;
         const patterns = notAboutUs.getPatternsAfter(aboutUsClone) || [];
 
         expect(patterns.length).toBe(0);

package/src/patterns/Not.ts

@@ -128,7 +128,7 @@ export class Not implements Pattern {
     return this.parent.getPatternsAfter(this)
   }
 
-  findPattern(predicate: (p: Pattern) => boolean): Pattern | null {
+  find(predicate: (p: Pattern) => boolean): Pattern | null {
     return predicate(this._children[0]) ? this._children[0] : null;
   }
 

package/src/patterns/Or.test.ts

@@ -118,7 +118,7 @@ describe("Or", () => {
             new Literal("c", "C")
         ]);
 
-        const orClone = sequence.findPattern(p => p.name === "a-or-b") as Pattern;
+        const orClone = sequence.find(p => p.name === "a-or-b") as Pattern;
         const tokens = orClone.getNextTokens();
 
         expect(tokens.length).toBe(1);
@@ -145,8 +145,8 @@ describe("Or", () => {
             new Literal("c", "C")
         ]);
 
-        const aClone = sequence.findPattern(p => p.name === "a") as Pattern;
-        const orClone = sequence.findPattern(p => p.name === "a-or-b") as Pattern;
+        const aClone = sequence.find(p => p.name === "a") as Pattern;
+        const orClone = sequence.find(p => p.name === "a-or-b") as Pattern;
         const tokens = orClone.getTokensAfter(aClone);
 
         expect(tokens.length).toBe(1);
@@ -157,8 +157,8 @@ describe("Or", () => {
         const aOrB = new Or("a-b", [new Literal("a", "A"), new Literal("b", "B")]);
         const patterns = aOrB.getPatterns();
         const expected = [
-            aOrB.findPattern(p => p.name === "a"),
-            aOrB.findPattern(p => p.name === "b")
+            aOrB.find(p => p.name === "a"),
+            aOrB.find(p => p.name === "b")
         ];
 
         expect(patterns).toEqual(expected);
@@ -173,8 +173,8 @@ describe("Or", () => {
             new Literal("c", "C")
         ]);
 
-        const aClone = sequence.findPattern(p => p.name === "a") as Pattern;
-        const orClone = sequence.findPattern(p => p.name === "a-or-b") as Pattern;
+        const aClone = sequence.find(p => p.name === "a") as Pattern;
+        const orClone = sequence.find(p => p.name === "a-or-b") as Pattern;
         const patterns = orClone.getPatternsAfter(aClone);
 
         expect(patterns.length).toBe(1);
@@ -186,7 +186,7 @@ describe("Or", () => {
             new Literal("a", "A"),
             new Literal("b", "B")
         ])
-        const aClone = or.findPattern(p => p.name === "a") as Pattern;
+        const aClone = or.find(p => p.name === "a") as Pattern;
         const patterns = or.getPatternsAfter(aClone);
 
         expect(patterns.length).toBe(0);
@@ -201,7 +201,7 @@ describe("Or", () => {
             new Literal("c", "C")
         ]);
 
-        const orClone = sequence.findPattern(p => p.name === "a-or-b") as Pattern;
+        const orClone = sequence.find(p => p.name === "a-or-b") as Pattern;
         const patterns = orClone.getNextPatterns();
 
         expect(patterns.length).toBe(1);

package/src/patterns/Or.ts

@@ -162,7 +162,7 @@ export class Or implements Pattern {
     return this.parent.getPatternsAfter(this)
   }
 
-  findPattern(predicate: (p: Pattern) => boolean): Pattern | null {
+  find(predicate: (p: Pattern) => boolean): Pattern | null {
     return findPattern(this, predicate);
   }
 

package/src/patterns/Pattern.ts

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

package/src/patterns/Reference.test.ts

@@ -19,7 +19,7 @@ function createValuePattern() {
     divider.setTokens([", "]);
 
     const valueRef = new Reference("value");
-    const values = new Repeat("values", valueRef, divider);
+    const values = new Repeat("values", valueRef, { divider });
     const array = new And("array", [openBracket, values, closeBracket]);
     const value = new Or("value", [number, array]);
 
@@ -34,7 +34,7 @@ describe("Reference", () => {
 
         const expected = new Node("and", "array", 0, 5, [
             new Node("literal", "open-bracket", 0, 0, [], "["),
-            new Node("repeat", "values", 1, 4, [
+            new Node("infinite-repeat", "values", 1, 4, [
                 new Node("regex", "number", 1, 1, [], "1"),
                 new Node("regex", "divider", 2, 3, [], ", "),
                 new Node("regex", "number", 4, 4, [], "2")
@@ -114,9 +114,9 @@ describe("Reference", () => {
 
     test("Find Pattern", () => {
         const value = createValuePattern();
-        const reference = value.findPattern(p => p.type === "reference") as Pattern;
+        const reference = value.find(p => p.type === "reference") as Pattern;
 
-        const pattern = reference?.findPattern(p => p.name === "Nada");
+        const pattern = reference?.find(p => p.name === "Nada");
 
         expect(pattern).toBe(null);
     });
@@ -124,7 +124,7 @@ describe("Reference", () => {
 
     test("Get Next Tokens", () => {
         const value = createValuePattern();
-        const reference = value.findPattern(p => p.type === "reference") as Pattern;
+        const reference = value.find(p => p.type === "reference") as Pattern;
         const tokens = reference.getNextTokens();
 
         expect(tokens).toEqual([", ", "]"]);
@@ -139,7 +139,7 @@ describe("Reference", () => {
 
     test("Get Tokens After", () => {
         const value = createValuePattern();
-        const reference = value.findPattern(p => p.type === "reference") as Pattern;
+        const reference = value.find(p => p.type === "reference") as Pattern;
         const tokens = reference.getTokensAfter(new Literal("bogus", "Bogus"));
 
         expect(tokens).toEqual([", ", "]"]);
@@ -164,7 +164,7 @@ describe("Reference", () => {
 
     test("Get Patterns After", () => {
         const value = createValuePattern();
-        const reference = value.findPattern(p => p.type === "reference") as Pattern;
+        const reference = value.find(p => p.type === "reference") as Pattern;
         const patterns = reference.getPatternsAfter(new Literal("bogus", "Bogus"));
 
         expect(patterns.length).toEqual(2);
@@ -183,7 +183,7 @@ describe("Reference", () => {
 
     test("Get Next Patterns", () => {
         const value = createValuePattern();
-        const reference = value.findPattern(p => p.type === "reference") as Pattern;
+        const reference = value.find(p => p.type === "reference") as Pattern;
         const patterns = reference.getNextPatterns();
 
         expect(patterns.length).toEqual(2);

package/src/patterns/Reference.ts

@@ -147,7 +147,7 @@ export class Reference implements Pattern {
     return this.parent.getPatternsAfter(this)
   }
 
-  findPattern(_predicate: (p: Pattern) => boolean): Pattern | null {
+  find(_predicate: (p: Pattern) => boolean): Pattern | null {
     return null;
   }
 

package/src/patterns/Regex.test.ts

@@ -86,7 +86,7 @@ describe("Regex", () => {
 
     test("Get Next Tokens", () => {
         const parent = new And("parent", [new Regex("a", "A"), new Literal("b", "B")]);
-        const aClone = parent.findPattern(p => p.name === "a") as Pattern;
+        const aClone = parent.find(p => p.name === "a") as Pattern;
         const tokens = aClone.getNextTokens();
 
         expect(tokens).toEqual(["B"]);
@@ -117,15 +117,15 @@ describe("Regex", () => {
 
     test("Find Pattern", () => {
         const a = new Regex("a", "A")
-        const pattern = a.findPattern(p => p.name === "other");
+        const pattern = a.find(p => p.name === "other");
 
         expect(pattern).toBeNull();
     });
 
     test("Get Next Patterns", () => {
         const parent = new And("parent", [new Regex("a", "A"), new Literal("b", "B")]);
-        const aClone = parent.findPattern(p => p.name === "a") as Pattern;
-        const bClone = parent.findPattern(p => p.name === "b") as Pattern;
+        const aClone = parent.find(p => p.name === "a") as Pattern;
+        const bClone = parent.find(p => p.name === "b") as Pattern;
         const patterns = aClone.getNextPatterns();
 
         expect(patterns.length).toBe(1);

package/src/patterns/Regex.ts

@@ -173,7 +173,7 @@ export class Regex implements Pattern {
     return this.parent.getPatternsAfter(this)
   }
 
-  findPattern(_predicate: (p: Pattern) => boolean): Pattern | null {
+  find(_predicate: (p: Pattern) => boolean): Pattern | null {
     return null;
   }