clarity-pattern-parser 10.1.17 → 10.1.21

package/dist/intellisense/AutoComplete.d.ts

@@ -21,6 +21,7 @@ export declare class AutoComplete {
     private _text;
     constructor(pattern: Pattern, options?: AutoCompleteOptions);
     suggestForWithCursor(cursor: Cursor): Suggestion;
+    private getFurthestPosition;
     suggestFor(text: string): Suggestion;
     private _getAllOptions;
     private _getOptionsFromErrors;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "10.1.17",
+  "version": "10.1.21",
   "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/intellisense/AutoComplete.ts

@@ -73,12 +73,8 @@ export class AutoComplete {
       error = new ParseError(startIndex, endIndex, this._pattern);
       errorAtIndex = startIndex;
     } else if (!isComplete && this._cursor.hasError && this._cursor.furthestError != null) {
-      errorAtIndex = this._cursor.furthestError.endIndex;
-      error = this._cursor.furthestError;
-
-      errorAtIndex = options.reduce((errorAtIndex, option) =>
-        Math.max(errorAtIndex, option.startIndex),
-        errorAtIndex);
+      errorAtIndex = this.getFurthestPosition(cursor);
+      error = new ParseError(errorAtIndex, errorAtIndex, this._pattern);
     }
 
     return {
@@ -92,6 +88,29 @@ export class AutoComplete {
 
   }
 
+  private getFurthestPosition(cursor: Cursor): number {
+    const furthestError = cursor.furthestError;
+    const furthestMatch = cursor.allMatchedNodes[cursor.allMatchedNodes.length - 1];
+
+    if (furthestError && furthestMatch) {
+      if (furthestError.endIndex > furthestMatch.endIndex) {
+        return furthestMatch.endIndex;
+      } else {
+        return furthestError.endIndex;
+      }
+    }
+
+    if (furthestError == null && furthestMatch != null) {
+      return furthestMatch.endIndex;
+    }
+
+    if (furthestMatch == null && furthestError != null) {
+      return furthestError.endIndex;
+    }
+
+    return 0;
+  }
+
   suggestFor(text: string): Suggestion {
     return this.suggestForWithCursor(new Cursor(text));
   }
@@ -101,9 +120,9 @@ export class AutoComplete {
     const leafMatches = this._cursor.leafMatches.map((m) => this._createSuggestionsFromMatch(m)).flat();
     const finalResults: SuggestionOption[] = [];
 
-    [...leafMatches, ...errorMatches].forEach(m=>{
-      const index = finalResults.findIndex(f=> m.text === f.text);
-      if (index === -1){
+    [...leafMatches, ...errorMatches].forEach(m => {
+      const index = finalResults.findIndex(f => m.text === f.text);
+      if (index === -1) {
         finalResults.push(m);
       }
     });

package/src/patterns/ExpressionPattern.ts

@@ -0,0 +1,133 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
+import { Pattern } from "./Pattern";
+
+let indexId = 0;
+
+export class ExpressionPattern implements Pattern {
+    private _id: string;
+    private _type: string;
+    private _name: string;
+    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;
+    }
+
+    get type(): string {
+        return this._type;
+    }
+
+    get name(): string {
+        return this._name;
+    }
+
+    get token(): string {
+        return this._token;
+    }
+
+    get parent(): Pattern | null {
+        return this._parent;
+    }
+
+    set parent(pattern: Pattern | null) {
+        this._parent = pattern;
+    }
+
+    get children(): Pattern[] {
+        return [];
+    }
+
+    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 {
+        this._firstIndex = cursor.index;
+        return null;
+    }
+
+    exec(text: string, record?: boolean | undefined): ParseResult {
+        throw new Error("Method not implemented.");
+    }
+
+    test(text: string, record?: boolean | undefined): boolean {
+        throw new Error("Method not implemented.");
+    }
+
+    clone(name?: string | undefined): Pattern {
+        throw new Error("Method not implemented.");
+    }
+
+    getTokens(): string[] {
+        throw new Error("Method not implemented.");
+    }
+
+    getTokensAfter(childReference: Pattern): string[] {
+        throw new Error("Method not implemented.");
+    }
+
+    getNextTokens(): string[] {
+        throw new Error("Method not implemented.");
+    }
+
+    getPatterns(): Pattern[] {
+        throw new Error("Method not implemented.");
+    }
+
+    getPatternsAfter(childReference: Pattern): Pattern[] {
+        throw new Error("Method not implemented.");
+    }
+
+    getNextPatterns(): Pattern[] {
+        throw new Error("Method not implemented.");
+    }
+
+    find(predicate: (pattern: Pattern) => boolean): Pattern | null {
+        throw new Error("Method not implemented.");
+    }
+
+    isEqual(pattern: Pattern): boolean {
+        throw new Error("Method not implemented.");
+    }
+}

package/src/patterns/Options.ts

@@ -108,8 +108,6 @@ export class Options implements Pattern {
     return null;
   }
 
-
-
   private _tryToParse(cursor: Cursor): Node | null {
     if (depthCache.getDepth(this._id, this._firstIndex) > 2) {
       cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
@@ -144,8 +142,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 (pattern.type === "reference" && pattern.name === this.name) {
+        continue;
+      }
+      tokens.push(...pattern.getTokens());
     }
 
     return tokens;
@@ -171,6 +172,9 @@ export class Options implements Pattern {
     const patterns: Pattern[] = [];
 
     for (const pattern of this._children) {
+      if (pattern.type === "reference" && pattern.name === this.name) {
+        continue;
+      }
       patterns.push(...pattern.getPatterns());
     }
 

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

@@ -216,10 +216,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 (pattern.type === "reference" && pattern.name === this.name && 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 +250,15 @@ 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 (pattern.type === "reference" && pattern.name === this.name && 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;
       }
     }