clarity-pattern-parser 10.1.20 → 10.1.22

package/dist/patterns/Reference.d.ts

@@ -20,7 +20,7 @@ export declare class Reference implements Pattern {
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
-    private _getPatternSafely;
+    getReferencePatternSafely(): Pattern;
     private _findPattern;
     private _isValidPattern;
     private _getRoot;

package/dist/patterns/isRecursivePattern.d.ts

@@ -0,0 +1,2 @@
+import { Pattern } from "./Pattern";
+export declare function isRecursivePattern(pattern: Pattern): boolean;

package/package.json

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

package/src/intellisense/AutoComplete.test.ts

@@ -490,4 +490,89 @@ describe("AutoComplete", () => {
         expect(results.options).toEqual(expected);
     });
 
+    test("Multiple Complex Branches", () => {
+        const branchOne = new Sequence("branch-1", [
+            new Literal("space-1-1", " "),
+            new Literal("space-1-2", " "),
+            new Options('branch-1-options', [
+                new Literal("AA", "AA"),
+                new Literal("AB", "AB"),
+                new Literal("BC", "BC"),
+            ])
+        ]);
+        const branchTwo = new Sequence("branch-2", [
+            new Literal("space-2-1", " "),
+            new Literal("space-2-2", " "),
+            new Options('branch-2-options', [
+                new Literal("BA", "BA"),
+                new Literal("BB", "BB")
+            ])
+        ]);
+        const eitherBranch = new Options("either-branch", [branchOne, branchTwo]);
+
+        const autoComplete = new AutoComplete(eitherBranch);
+        const results = autoComplete.suggestFor("  B");
+        const expected = [
+            { startIndex: 3, text: "A" },
+            { startIndex: 3, text: "B" },
+            { startIndex: 3, text: "C" },
+        ];
+        expect(results.options).toEqual(expected);
+    });
+
+
+    test("Recursion With Or", () => {
+        const ref = new Reference("names");
+        const names = new Options("names", [
+            ref,
+            new Literal("john", "John"),
+            new Literal("jane", "Jane")
+        ]);
+
+        const autoComplete = new AutoComplete(names);
+        const suggestion = autoComplete.suggestFor("Jo");
+
+        expect(suggestion.options).toEqual([
+            { text: 'hn', startIndex: 2 }
+        ]);
+        expect(suggestion.error?.endIndex).toBe(2);
+    });
+
+    test("Recursion With And", () => {
+        const firstNames = new Options("first-names", [
+            new Literal("john", "John"),
+            new Literal("jane", "Jane"),
+        ]);
+
+        const lastNames = new Options("last-names", [
+            new Literal("doe", "Doe"),
+            new Literal("smith", "Smith"),
+        ]);
+
+        const fullName = new Sequence("full-name", [
+            firstNames,
+            new Literal("space", " "),
+            lastNames
+        ]);
+
+        const ref = new Reference("names");
+        const names = new Sequence("names", [
+            fullName,
+            ref,
+            lastNames,
+        ]);
+
+        const autoComplete = new AutoComplete(names, {
+            greedyPatternNames: ["space"]
+        });
+        const suggestion = autoComplete.suggestFor("John");
+
+        expect(suggestion.options).toEqual([{
+            "text": " Doe",
+            "startIndex": 4
+        }, {
+            "text": " Smith",
+            "startIndex": 4
+        }]);
+    });
 });

package/src/patterns/ExpressionPattern.ts

@@ -12,6 +12,9 @@ export class ExpressionPattern implements Pattern {
     private _parent: Pattern | null;
     private _token: string;
     private _firstIndex: number;
+    private _patterns: Pattern[];
+    private _unaryPatterns: Pattern[];
+    private _binaryPatterns: Pattern[];
 
     get id(): string {
         return this._id;
@@ -41,10 +44,42 @@ export class ExpressionPattern implements Pattern {
         return [];
     }
 
-    constructor(){
+    constructor(name: string, patterns: []) {
         this._id = `expression-${indexId++}`;
         this._type = "expression";
+        this._unaryPatterns = [];
+        this._binaryPatterns = [];
+    }
+
+    private _organizePatterns() {
+        this._patterns.forEach((pattern) => {
+            if (this._isBinary(pattern)) {
+                this._binaryPatterns.push(pattern);
+            } else {
+                this._unaryPatterns.push();
+            }
+        });
+    }
+
+    private _isBinary(pattern: Pattern) {
+        if (pattern.type === "right-associated" && this._isBinaryPattern(pattern.children[0])) {
+            return true;
+        }
+
+        return this._isBinaryPattern(pattern);
+    }
+
+    private _isBinaryPattern(pattern: Pattern) {
+        return pattern.type === "sequence" &&
+            pattern.children[0].type === "reference" &&
+            pattern.children[0].name === this.name &&
+            pattern.children[2].type === "reference" &&
+            pattern.children[2].name === this.name &&
+            pattern.children.length === 3;
+    }
 
+    private extractDelimiter(pattern) {
+        return pattern.children[1];
     }
 
     parse(cursor: Cursor): Node | null {

package/src/patterns/Options.ts

@@ -5,6 +5,7 @@ import { clonePatterns } from "./clonePatterns";
 import { findPattern } from "./findPattern";
 import { ParseResult } from "./ParseResult";
 import { DepthCache } from './DepthCache';
+import { isRecursivePattern } from "./isRecursivePattern";
 
 /*
   The following is created to reduce the overhead of recursion check. 
@@ -142,8 +143,11 @@ export class Options implements Pattern {
   getTokens(): string[] {
     const tokens: string[] = [];
 
-    for (const child of this._children) {
-      tokens.push(...child.getTokens());
+    for (const pattern of this._children) {
+      if (isRecursivePattern(pattern)) {
+        continue;
+      }
+      tokens.push(...pattern.getTokens());
     }
 
     return tokens;
@@ -169,6 +173,9 @@ export class Options implements Pattern {
     const patterns: Pattern[] = [];
 
     for (const pattern of this._children) {
+      if (isRecursivePattern(pattern)) {
+        continue;
+      }
       patterns.push(...pattern.getPatterns());
     }
 

package/src/patterns/Reference.ts

@@ -70,10 +70,10 @@ export class Reference implements Pattern {
   }
 
   parse(cursor: Cursor): Node | null {
-    return this._getPatternSafely().parse(cursor);
+    return this.getReferencePatternSafely().parse(cursor);
   }
 
-  private _getPatternSafely(): Pattern {
+  getReferencePatternSafely(): Pattern {
     if (this._pattern === null) {
       let pattern: Pattern | null = null;
 
@@ -150,7 +150,7 @@ export class Reference implements Pattern {
   }
 
   getTokens(): string[] {
-    return this._getPatternSafely().getTokens();
+    return this.getReferencePatternSafely().getTokens();
   }
 
   getTokensAfter(_lastMatched: Pattern): string[] {
@@ -170,7 +170,7 @@ export class Reference implements Pattern {
   }
 
   getPatterns(): Pattern[] {
-    return this._getPatternSafely().getPatterns();
+    return this.getReferencePatternSafely().getPatterns();
   }
 
   getPatternsAfter(_childReference: Pattern): Pattern[] {

package/src/patterns/RightAssociatedPattern.ts

@@ -0,0 +1,71 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
+import { Pattern } from "./Pattern";
+
+let indexId = 0;
+
+export class RightAssociatedPattern implements Pattern {
+    readonly id: string;
+    readonly type: string;
+    readonly name: string;
+    private _parent: Pattern | null;
+    readonly children: Pattern[];
+
+    get parent() {
+        return this._parent;
+    }
+
+    set parent(pattern: Pattern | null) {
+        this._parent = pattern;
+    }
+
+    constructor(pattern: Pattern) {
+        this.id = `right-associated-${indexId++}`;
+        this.type = "right-associated";
+        this.name = "";
+        this.parent = null;
+        this.children = [pattern];
+    }
+
+    parse(cursor: Cursor): Node | null {
+        return this.children[0].parse(cursor);
+    }
+
+    exec(text: string, record?: boolean | undefined): ParseResult {
+        return this.children[0].exec(text, record);
+    }
+
+    test(text: string, record?: boolean | undefined): boolean {
+        return this.children[0].test(text, record);
+    }
+
+    clone(name?: string | undefined): Pattern {
+        return new RightAssociatedPattern(this.children[0]);
+    }
+
+    getTokens(): string[] {
+        return this.children[0].getTokens();
+    }
+    getTokensAfter(childReference: Pattern): string[] {
+        return this.children[0].getTokensAfter(childReference);
+    }
+    getNextTokens(): string[] {
+        return this.children[0].getNextTokens();
+    }
+    getPatterns(): Pattern[] {
+        return this.children[0].getPatterns();
+    }
+    getPatternsAfter(childReference: Pattern): Pattern[] {
+        return this.children[0].getPatternsAfter(childReference);
+    }
+    getNextPatterns(): Pattern[] {
+        return this.children[0].getNextPatterns();
+    }
+    find(predicate: (pattern: Pattern) => boolean): Pattern | null {
+        return this.children[0].find(predicate);
+    }
+    isEqual(pattern: Pattern): boolean {
+        return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+    }
+}

package/src/patterns/Sequence.ts

@@ -5,6 +5,7 @@ import { clonePatterns } from "./clonePatterns";
 import { filterOutNull } from "./filterOutNull";
 import { findPattern } from "./findPattern";
 import { DepthCache } from "./DepthCache";
+import { isRecursivePattern } from "./isRecursivePattern";
 
 const depthCache = new DepthCache();
 let idIndex = 0;
@@ -216,10 +217,13 @@ export class Sequence implements Pattern {
   getTokens(): string[] {
     const tokens: string[] = [];
 
-    for (const child of this._children) {
-      tokens.push(...child.getTokens());
+    for (const pattern of this._children) {
+      if (isRecursivePattern(pattern) && pattern === this._children[0]) {
+        return tokens;
+      }
 
-      if (child.type !== "optional" && child.type !== "not") {
+      tokens.push(...pattern.getTokens());
+      if (pattern.type !== "optional" && pattern.type !== "not") {
         break;
       }
     }
@@ -247,10 +251,14 @@ export class Sequence implements Pattern {
   getPatterns(): Pattern[] {
     const patterns: Pattern[] = [];
 
-    for (const child of this._children) {
-      patterns.push(...child.getPatterns());
+    for (const pattern of this._children) {
+      if (isRecursivePattern(pattern) && pattern === this._children[0]) {
+        return patterns;
+      }
+
+      patterns.push(...pattern.getPatterns());
 
-      if (child.type !== "optional" && child.type !== "not") {
+      if (pattern.type !== "optional" && pattern.type !== "not") {
         break;
       }
     }

package/src/patterns/isRecursivePattern.ts

@@ -0,0 +1,21 @@
+import { Pattern } from "./Pattern";
+import { Reference } from "./Reference";
+
+export function isRecursivePattern(pattern: Pattern) {
+    let onPattern = pattern.parent;
+    let depth = 0;
+
+    while (onPattern != null) {
+        if (onPattern.id === pattern.id) {
+            depth++;
+        }
+
+        onPattern = onPattern.parent;
+
+        if (depth > 1){
+            return true;
+        }
+    }
+
+    return false;
+}