clarity-pattern-parser 6.0.0 → 6.0.2

package/src/intellisense/javascript/propertyAccess.ts

@@ -6,7 +6,7 @@ import { name } from "./name";
 
 const dotPropertyAccess = new And("dot-property-access", [
     new Literal("period", "."),
-    name
+    name.clone("property-name")
 ]);
 
 const bracketPropertyAccess = new And("bracket-property-access", [
@@ -15,9 +15,14 @@ const bracketPropertyAccess = new And("bracket-property-access", [
     new Literal("close-square-bracket", "]"),
 ]);
 
-const propertyAccess = new Or("property-access", [
+const propertyAccessTypes = new Or("property-access-types", [
     dotPropertyAccess,
-    bracketPropertyAccess,
+    bracketPropertyAccess
+]);
+
+const propertyAccess = new And("property-access", [
+    propertyAccessTypes,
+    new Reference("property-access", true)
 ]);
 
 export { propertyAccess }

package/src/intellisense/javascript/stringLiteral.ts

@@ -7,19 +7,27 @@ import { escapedCharacter } from "./escapedCharacter";
 
 const doubleQuoteStringLiteral = new And("double-string-literal", [
     new Literal("double-quote", "\""),
-    new Repeat("characters", new Or("characters", [
-        new Regex("normal-characters", "[^\\\"]+"),
-        escapedCharacter
-    ])),
+    new Repeat("characters",
+        new Or("characters", [
+            new Regex("normal-characters", "[^\\\"]+"),
+            escapedCharacter
+        ]),
+        undefined,
+        true
+    ),
     new Literal("double-quote", "\""),
 ]);
 
 const singleQuoteStringLiteral = new And("single-string-literal", [
     new Literal("single-quote", "'"),
-    new Repeat("characters", new Or("characters", [
-        new Regex("normal-characters", "[^\\']+"),
-        escapedCharacter
-    ])),
+    new Repeat("characters",
+        new Or("characters", [
+            new Regex("normal-characters", "[^\\']+"),
+            escapedCharacter
+        ]),
+        undefined,
+        true
+    ),
     new Literal("single-quote", "'"),
 ]);
 

package/src/patterns/And.test.ts

@@ -289,6 +289,19 @@ describe("And", () => {
         expect(tokens.length).toBe(0);
     });
 
+    test("Get Patterns", () => {
+        const sequence = new And("sequence", [
+            new Literal("a", "A", true),
+            new Literal("b", "B"),
+        ], true);
+        const tokens = sequence.getPatterns();
+        const a = sequence.findPattern(p=>p.name === "a");
+        const b = sequence.findPattern(p=>p.name === "b");
+        const expected = [a, b]
+
+        expect(tokens).toEqual(expected);
+    });
+
     test("Get Next Patterns", () => {
         const sequence = new And("sequence", [new Literal("a", "A")]);
         const parent = new And("parent", [sequence, new Literal("b", "B")]);

package/src/patterns/And.ts

@@ -234,6 +234,20 @@ export class And implements Pattern {
     return this.parent.getTokensAfter(this);
   }
 
+  getPatterns(): Pattern[] {
+    const patterns: Pattern[] = [];
+
+    for (const pattern of this._children) {
+      patterns.push(...pattern.getPatterns());
+
+      if (!pattern.isOptional) {
+        break;
+      }
+    }
+
+    return patterns;
+  }
+
   getPatternsAfter(childReference: Pattern): Pattern[] {
     let nextSibling: Pattern | null = null;
     let nextSiblingIndex = -1;

package/src/patterns/Literal.test.ts

@@ -132,6 +132,15 @@ describe("Literal", () => {
         expect(tokens.length).toBe(0);
     });
 
+    test("Get Patterns", () => {
+        const a = new Literal("a", "A");
+
+        const tokens = a.getPatterns();
+        const expectedTokens = [a];
+
+        expect(tokens).toEqual(expectedTokens);
+    });
+
     test("Get Next Patterns", () => {
         const sequence = new And("sequence", [new Literal("a", "A")]);
         const parent = new And("parent", [sequence, new Literal("b", "B")]);

package/src/patterns/Literal.ts

@@ -151,6 +151,10 @@ export class Literal implements Pattern {
     return this.parent.getTokensAfter(this);
   }
 
+  getPatterns(): Pattern[] {
+    return [this];
+  }
+
   getPatternsAfter(): Pattern[] {
     return []
   }

package/src/patterns/Not.test.ts

@@ -128,6 +128,17 @@ describe("Not", () => {
         expect(child).not.toBeNull();
     });
 
+    test("Get Patterns", () => {
+        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 nextPatterns = cloneNotAboutUs.getPatterns();
+        const expected = [sequence.findPattern(p=>p.name === "about-them")];
+
+        expect(nextPatterns).toEqual(expected);
+    });
+
     test("Get Next Patterns", () => {
         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")]);

package/src/patterns/Not.ts

@@ -106,6 +106,10 @@ export class Not implements Pattern {
     return this.parent.getTokensAfter(this);
   }
 
+  getPatterns(): Pattern[] {
+    return [...this.getNextPatterns().map(p => p.getPatterns()).flat()];
+  }
+
   getPatternsAfter(_childReference: Pattern): Pattern[] {
     const parent = this._parent;
 

package/src/patterns/Or.test.ts

@@ -153,6 +153,17 @@ describe("Or", () => {
         expect(tokens[0]).toBe("C");
     });
 
+    test("Get Patterns", () => {
+        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")
+        ];
+
+        expect(patterns).toEqual(expected);
+    });
+
     test("Get Patterns After", () => {
         const sequence = new And("sequence", [
             new Or("a-or-b", [

package/src/patterns/Or.ts

@@ -136,6 +136,16 @@ export class Or implements Pattern {
     return this._parent.getTokensAfter(this);
   }
 
+  getPatterns(): Pattern[] {
+    const patterns: Pattern[] = [];
+
+    for (const pattern of this._children) {
+      patterns.push(...pattern.getPatterns());
+    }
+
+    return patterns;
+  }
+
   getPatternsAfter(_childReference: Pattern): Pattern[] {
     if (this._parent === null) {
       return [];

package/src/patterns/Pattern.ts

@@ -15,8 +15,9 @@ export interface Pattern {
   clone(name?: string, isOptional?: boolean): Pattern;
   getTokens(): string[];
   getTokensAfter(childReference: Pattern): string[];
+  getNextTokens(): string[];
+  getPatterns(): Pattern[];
   getPatternsAfter(childReference: Pattern): Pattern[];
   getNextPatterns(): Pattern[];
-  getNextTokens(): string[];
   findPattern(predicate: (p: Pattern) => boolean): Pattern | null;
 }

package/src/patterns/Reference.test.ts

@@ -152,6 +152,16 @@ describe("Reference", () => {
         expect(tokens).toEqual([])
     });
 
+    test("Get Patterns", () => {
+        const value = createValuePattern();
+        const ref = findPattern(value, (p) => p.type === "reference");
+        const patterns = ref?.getPatterns() || [];
+
+        expect(patterns.length).toBe(2);
+        expect(patterns[0].name).toBe("number");
+        expect(patterns[1].name).toBe("open-bracket");
+    });
+
     test("Get Patterns After", () => {
         const value = createValuePattern();
         const reference = value.findPattern(p => p.type === "reference") as Pattern;

package/src/patterns/Reference.ts

@@ -127,6 +127,10 @@ export class Reference implements Pattern {
     return this.parent.getTokensAfter(this);
   }
 
+  getPatterns(): Pattern[] {
+    return this._getPatternSafely().getPatterns();
+  }
+
   getPatternsAfter(_childReference: Pattern): Pattern[] {
     if (this._parent == null) {
       return [];

package/src/patterns/Regex.test.ts

@@ -99,6 +99,15 @@ describe("Regex", () => {
         expect(tokens).toEqual([]);
     });
 
+    test("Get Patterns", () => {
+        const a = new Regex("a", "A");
+
+        const tokens = a.getPatterns();
+        const expectedTokens = [a];
+
+        expect(tokens).toEqual(expectedTokens);
+    });
+
     test("Get Patterns After", () => {
         const a = new Regex("a", "A")
         const patterns = a.getPatternsAfter(new Literal("bogus", "bogus"));

package/src/patterns/Regex.ts

@@ -157,6 +157,10 @@ export class Regex implements Pattern {
     return this.parent.getTokensAfter(this);
   }
 
+  getPatterns(): Pattern[] {
+    return [this];
+  }
+
   getPatternsAfter(_childReference: Pattern): Pattern[] {
     return [];
   }

package/src/patterns/Repeat.test.ts

@@ -198,6 +198,15 @@ describe("Repeat", () => {
         expect(digitClone).not.toBeNull();
     });
 
+    test("Get Patterns", () => {
+        const a = new Literal("a", "A");
+        const manyA = new Repeat("number", a);
+        const patterns = manyA.getPatterns();
+        const expected = [manyA.findPattern(p => p.name === "a")];
+
+        expect(patterns).toEqual(expected)
+    });
+
     test("Get Next Patterns", () => {
         const integer = new Repeat("integer", new Regex("digit", "\\d"));
         const parent = new And("parent", [integer, new Literal("pow", "!")]);

package/src/patterns/Repeat.ts

@@ -216,6 +216,10 @@ export class Repeat implements Pattern {
     return this.parent.getTokensAfter(this);
   }
 
+  getPatterns(): Pattern[] {
+    return this._pattern.getPatterns();
+  }
+
   getPatternsAfter(childReference: Pattern): Pattern[] {
     let index = -1;
     const patterns: Pattern[] = [];