clarity-pattern-parser 6.0.0 → 6.0.2

package/src/intellisense/AutoComplete.test.ts

@@ -10,11 +10,11 @@ describe("AutoComplete", () => {
     test("No Text", () => {
         const name = new Literal("name", "Name");
         const autoComplete = new AutoComplete(name);
-        let result = autoComplete.suggest("");
+        let result = autoComplete.suggestFor("");
 
         expect(result.options[0].text).toBe("Name");
         expect(result.options[0].startIndex).toBe(0);
-        expect(result.nextPatterns[0]).toBe(name);
+        expect(result.errorAtIndex).toBe(0);
         expect(result.isComplete).toBeFalsy();
     });
 
@@ -26,11 +26,11 @@ describe("AutoComplete", () => {
         const name = new And("name", [john, space, new Or("last-name", [smith, doe])]);
 
         const autoComplete = new AutoComplete(name);
-        const result = autoComplete.suggest("John Doe");
+        const result = autoComplete.suggestFor("John Doe");
 
         expect(result.ast?.value).toBe("John Doe");
         expect(result.options.length).toBe(0);
-        expect(result.nextPatterns.length).toBe(0);
+        expect(result.errorAtIndex).toBeNull();
         expect(result.isComplete).toBeTruthy();
         expect(result.cursor).not.toBeNull();
     });
@@ -42,14 +42,20 @@ describe("AutoComplete", () => {
         const smith = new Literal("smith", "Smith");
         const name = new And("name", [john, space, new Or("last-name", [smith, doe])]);
 
+        const text = "John "
         const autoComplete = new AutoComplete(name);
-        const result = autoComplete.suggest("John ");
+        const result = autoComplete.suggestFor(text);
+        const expectedOptions = [{
+            text: "Doe",
+            startIndex: 5
+        }, {
+            text: "Smith",
+            startIndex: 5
+        }];
 
         expect(result.ast).toBeNull();
-        expect(result.options.length).toBe(2);
-        expect(result.nextPatterns.length).toBe(1);
-        expect(result.nextPatterns[0].type).toBe("or");
-        expect(result.nextPatterns[0].name).toBe("last-name");
+        expect(result.options).toEqual(expectedOptions);
+        expect(result.errorAtIndex).toBe(text.length)
         expect(result.isComplete).toBeFalsy();
         expect(result.cursor).not.toBeNull();
     });
@@ -64,12 +70,17 @@ describe("AutoComplete", () => {
 
         divider.setTokens([", "])
 
+        const text = "John Doe";
         const autoComplete = new AutoComplete(new Repeat("last-names", name, divider));
-        const result = autoComplete.suggest("John Doe");
-
-        expect(result.ast?.value).toBe("John Doe");
-        expect(result.options.length).toBe(1);
-        expect(result.nextPatterns.length).toBe(result.options.length);
+        const result = autoComplete.suggestFor(text);
+        const expectedOptions = [{
+            text: ", ",
+            startIndex: 8
+        }];
+
+        expect(result.ast?.value).toBe(text);
+        expect(result.options).toEqual(expectedOptions);
+        expect(result.errorAtIndex).toBeNull()
         expect(result.isComplete).toBeTruthy();
         expect(result.cursor).not.toBeNull();
     });
@@ -77,36 +88,50 @@ describe("AutoComplete", () => {
     test("Partial", () => {
         const name = new Literal("name", "Name");
         const autoComplete = new AutoComplete(name);
-        let result = autoComplete.suggest("Na");
+        const result = autoComplete.suggestFor("Na");
+        const expectedOptions = [{
+            text: "me",
+            startIndex: 2
+        }];
 
-        expect(result.options[0].text).toBe("me");
-        expect(result.options[0].startIndex).toBe(2);
-        expect(result.nextPatterns[0]).toBe(name);
+        expect(result.ast).toBeNull();
+        expect(result.options).toEqual(expectedOptions);
+        expect(result.errorAtIndex).toBe(2);
         expect(result.isComplete).toBeFalsy();
+        expect(result.cursor).not.toBeNull();
     });
 
     test("Partial Match With Bad Characters", () => {
         const name = new Literal("name", "Name");
         const autoComplete = new AutoComplete(name);
-        let result = autoComplete.suggest("Ni");
+        const result = autoComplete.suggestFor("Ni");
+
+        const expectedOptions = [{
+            text: "ame",
+            startIndex: 1
+        }];
 
-        expect(result.options[0].text).toBe("ame");
-        expect(result.options[0].startIndex).toBe(1);
-        //expect(result.nextPattern).toBe(name);
+        expect(result.ast).toBeNull();
+        expect(result.options).toEqual(expectedOptions);
+        expect(result.errorAtIndex).toBe(1);
         expect(result.isComplete).toBeFalsy();
+        expect(result.cursor).not.toBeNull();
     });
 
     test("Complete", () => {
         const name = new Literal("name", "Name");
         const autoComplete = new AutoComplete(name);
-        let result = autoComplete.suggest("Name");
+        const text = "Name"
+        const result = autoComplete.suggestFor(text);
 
-        expect(result.options.length).toBe(0);
-        expect(result.nextPatterns.length).toBe(0);
+        expect(result.ast?.value).toBe(text);
+        expect(result.options).toEqual([]);
+        expect(result.errorAtIndex).toBeNull();
         expect(result.isComplete).toBeTruthy();
+        expect(result.cursor).not.toBeNull();
     });
 
-    test("Options", ()=>{
+    test("Options AutoComplete on Composing Pattern", () => {
         const autoCompleteOptions: AutoCompleteOptions = {
             greedyPatternNames: ["space"],
             customTokens: {
@@ -123,26 +148,68 @@ describe("AutoComplete", () => {
         const lastName = new Or("last-name", [doe, smith]);
         const fullName = new And("full-name", [firstName, space, lastName]);
 
-        const text = "John";
+        const text = "Jack";
         const autoComplete = new AutoComplete(fullName, autoCompleteOptions);
-        const { options, ast, nextPatterns } = autoComplete.suggest(text);
+        const { options, ast, errorAtIndex } = autoComplete.suggestFor(text);
+
         const expectedOptions = [
-            {text: " Doe", startIndex: 4},
-            {text: " Smith", startIndex: 4},
-            {text: " Sparrow", startIndex: 4},
+            { text: " Doe", startIndex: 4 },
+            { text: " Smith", startIndex: 4 },
+            { text: " Sparrow", startIndex: 4 },
         ];
 
-        const results = expectedOptions.map(o=>text.slice(0, o.startIndex) + o.text);
+        const results = expectedOptions.map(o => text.slice(0, o.startIndex) + o.text);
         const expectedResults = [
-            "John Doe",
-            "John Smith",
-            "John Sparrow",
+            "Jack Doe",
+            "Jack Smith",
+            "Jack Sparrow",
         ]
 
+        expect(ast).toBeNull();
+        expect(errorAtIndex).toBe(4);
         expect(options).toEqual(expectedOptions);
+        expect(results).toEqual(expectedResults);
+
+    });
+
+    test("Options AutoComplete On Leaf Pattern", () => {
+        const autoCompleteOptions: AutoCompleteOptions = {
+            greedyPatternNames: ["space"],
+            customTokens: {
+                "space": ["  "]
+            }
+        };
+
+        const jack = new Literal("jack", "Jack");
+        const john = new Literal("john", "John");
+        const space = new Literal("space", " ");
+        const doe = new Literal("doe", "Doe");
+        const smith = new Literal("smith", "Smith");
+        const firstName = new Or("first-name", [jack, john]);
+        const lastName = new Or("last-name", [doe, smith]);
+        const fullName = new And("full-name", [firstName, space, lastName]);
+
+        const text = "Jack";
+        const autoComplete = new AutoComplete(fullName, autoCompleteOptions);
+        const { options, ast, errorAtIndex } = autoComplete.suggestFor(text);
+        const expectedOptions = [
+            { text: "  Doe", startIndex: 4 },
+            { text: "  Smith", startIndex: 4 },
+            { text: " Doe", startIndex: 4 },
+            { text: " Smith", startIndex: 4 },
+        ];
+
+        const results = expectedOptions.map(o => text.slice(0, o.startIndex) + o.text);
+        const expectedResults = [
+            "Jack  Doe",
+            "Jack  Smith",
+            "Jack Doe",
+            "Jack Smith",
+        ]
+
         expect(ast).toBeNull();
-        expect(nextPatterns.length).toBe(1);
-        expect(nextPatterns[0].name).toBe("space");
+        expect(errorAtIndex).toBe(4);
+        expect(options).toEqual(expectedOptions);
         expect(results).toEqual(expectedResults)
 
     });

package/src/intellisense/AutoComplete.ts

@@ -9,12 +9,12 @@ export interface AutoCompleteOptions {
    * Be very careful, this can explode to infinity pretty quick. Usually useful 
    * for dividers and spaces.
    */
-  greedyPatternNames: string[];
+  greedyPatternNames?: string[];
   /**
    * Allows for custom suggestions for patterns. The key is the name of the pattern
    * and the string array are the tokens suggested for that pattern.
    */
-  customTokens: Record<string, string[]>;
+  customTokens?: Record<string, string[]>;
 }
 
 const defaultOptions = { greedyPatternNames: [], customTokens: {} };
@@ -31,12 +31,20 @@ export class AutoComplete {
     this._text = "";
   }
 
+  /**
+   * @deprecated Use suggestFor instead.
+   * @param text The text to suggest for.
+   */
   suggest(text: string): Suggestion {
+    return this.suggestFor(text);
+  }
+
+  suggestFor(text: string): Suggestion {
     if (text.length === 0) {
       return {
         isComplete: false,
-        options: this.createSuggestionsFromRoot(),
-        nextPatterns: [this._pattern],
+        options: this._createSuggestionsFromRoot(),
+        errorAtIndex: 0,
         cursor: null,
         ast: null
       }
@@ -48,43 +56,51 @@ export class AutoComplete {
 
     const leafPattern = this._cursor.leafMatch.pattern;
     const isComplete = ast?.value === text;
-    const options = this.createSuggestionsFromTokens();
+    const options = this._createSuggestionsFromTokens();
 
     let nextPatterns = [this._pattern];
+    let errorAtIndex = null;
 
     if (leafPattern != null) {
       nextPatterns = leafPattern.getNextPatterns();
     }
 
+    if (this._cursor.hasError && this._cursor.furthestError != null) {
+      errorAtIndex = this._cursor.furthestError.index;
+
+      errorAtIndex = options.reduce((errorAtIndex, option) =>
+        Math.max(errorAtIndex, option.startIndex),
+        errorAtIndex);
+    }
+
     return {
       isComplete: isComplete,
       options: options,
-      nextPatterns,
+      errorAtIndex,
       cursor: this._cursor,
       ast,
     }
   }
 
-  private createSuggestionsFromRoot(): SuggestionOption[] {
+  private _createSuggestionsFromRoot(): SuggestionOption[] {
     const suggestions: SuggestionOption[] = [];
     const tokens = this._pattern.getTokens();
 
     for (const token of tokens) {
-      suggestions.push(this.createSuggestion("", token));
+      suggestions.push(this._createSuggestion("", token));
     }
 
     return suggestions;
   }
 
-  private createSuggestionsFromTokens(): SuggestionOption[] {
+  private _createSuggestionsFromTokens(): SuggestionOption[] {
     const leafMatch = this._cursor.leafMatch;
 
     if (!leafMatch.pattern) {
-      return this.createSuggestions(-1, this._getTokensForPattern(this._pattern));
+      return this._createSuggestions(-1, this._getTokensForPattern(this._pattern));
     }
 
     const leafPattern = leafMatch.pattern;
-    const leafNode = leafMatch.node;
     const parent = leafMatch.pattern.parent;
 
     if (parent !== null && leafMatch.node != null) {
@@ -95,39 +111,50 @@ export class AutoComplete {
         return acc;
       }, []);
 
-      return this.createSuggestions(leafMatch.node.lastIndex, tokens);
+      return this._createSuggestions(leafMatch.node.lastIndex, tokens);
     } else {
       return [];
     }
   }
 
   private _getTokensForPattern(pattern: Pattern) {
-    if (this._options.greedyPatternNames.includes(pattern.name)) {
-      const greedyTokens = pattern.getTokens();
+    const augmentedTokens = this._getAugmentedTokens(pattern)
+
+    if (this._options.greedyPatternNames != null && this._options.greedyPatternNames.includes(pattern.name)) {
       const nextPatterns = pattern.getNextPatterns();
       const tokens: string[] = [];
 
-      const nextPatternTokens = nextPatterns.reduce((acc: string[], pattern)=>{
+      const nextPatternTokens = nextPatterns.reduce((acc: string[], pattern) => {
         acc.push(...this._getTokensForPattern(pattern));
         return acc;
       }, []);
 
-      for (let token of greedyTokens){
-        for (let nextPatternToken of nextPatternTokens){
+      for (let token of augmentedTokens) {
+        for (let nextPatternToken of nextPatternTokens) {
           tokens.push(token + nextPatternToken);
         }
       }
 
       return tokens;
     } else {
-      const tokens = pattern.getTokens();
-      const customTokens = this._options.customTokens[pattern.name] || [];
-      tokens.push(...customTokens);
-      return tokens;
+      return augmentedTokens;
     }
   }
 
-  private createSuggestions(lastIndex: number, tokens: string[]): SuggestionOption[] {
+  private _getAugmentedTokens(pattern: Pattern) {
+    const customTokensMap: any = this._options.customTokens || {};
+    const leafPatterns = pattern.getPatterns();
+    const tokens: string[] = customTokensMap[pattern.name] || [];
+
+    leafPatterns.forEach(p => {
+      const augmentedTokens = customTokensMap[p.name] || [];
+      tokens.push(...p.getTokens(), ...augmentedTokens);
+    });
+
+    return tokens;
+  }
+
+  private _createSuggestions(lastIndex: number, tokens: string[]): SuggestionOption[] {
     let substring = lastIndex === -1 ? "" : this._cursor.getChars(0, lastIndex);
     const suggestionStrings: string[] = [];
     const options: SuggestionOption[] = [];
@@ -140,7 +167,7 @@ export class AutoComplete {
 
       if (startsWith && !alreadyExist && !isSameAsText) {
         suggestionStrings.push(suggestion);
-        options.push(this.createSuggestion(this._cursor.text, suggestion));
+        options.push(this._createSuggestion(this._cursor.text, suggestion));
       }
     }
 
@@ -150,7 +177,7 @@ export class AutoComplete {
     return reducedOptions;
   }
 
-  private createSuggestion(fullText: string, suggestion: string): SuggestionOption {
+  private _createSuggestion(fullText: string, suggestion: string): SuggestionOption {
     const furthestMatch = findMatchIndex(suggestion, fullText);
     const text = suggestion.slice(furthestMatch);
 

package/src/intellisense/Suggestion.ts

@@ -6,7 +6,7 @@ import { SuggestionOption } from "./SuggestionOption";
 export interface Suggestion {
   isComplete: boolean;
   options: SuggestionOption[];
-  nextPatterns: Pattern[];
+  errorAtIndex: number | null;
   cursor: Cursor | null;
   ast: Node | null;
 }

package/src/intellisense/javascript/Javascript.test.ts

@@ -1,12 +1,14 @@
+import { Cursor } from "../../patterns/Cursor";
 import { escapedCharacter } from "./escapedCharacter";
 import { exponent } from "./exponent";
 import { expression } from "./expression";
-import { expressionStatement } from "./expressionStatement";
+import { assignment } from "./assignment";
 import { infixOperator } from "./infixOperator";
 import { integer } from "./integer";
 import { name } from "./name";
 import { parameters } from "./parameters";
 import { prefixOperator } from "./prefixOperator";
+import { objectAccess } from "./objectAccess";
 
 describe("Ecmascript 3", () => {
     test("Escaped Character", () => {
@@ -173,30 +175,52 @@ describe("Ecmascript 3", () => {
         expect(result.ast?.value).toBe(`{"prop":1}`);
     });
 
-    test("Array Literal", () => {
+    test("Expression", () => {
+
         let result = expression.exec("[]")
         expect(result.ast?.value).toBe("[]");
 
         result = expression.exec("[{}, 9, 0.9e-10, [1, 2]]")
         expect(result.ast?.value).toBe("[{}, 9, 0.9e-10, [1, 2]]");
-    });
+
+        result = expression.exec(`"John"`);
+        expect(result.ast?.value).toBe(`"John"`)
+
+        result = expression.exec(`variableName.property`);
+        expect(result.ast?.value).toBe(`variableName.property`);
+
+        result = expression.exec(`{property: ""}`);
+        expect(result.ast?.value).toBe(`{property: ""}`);
+
+        const cursor = new Cursor(`name() == name.property === name2 ? {prop: name, blah: [ 0.9e-10 ]} : name`);
+        cursor.startRecording();
+        const ast = expression.parse(cursor);
+    })
 
     test("Expression Statement", () => {
-        let result = expressionStatement.exec(`name = "John"`);
+        let result = assignment.exec(`name = "John"`);
         expect(result.ast?.value).toBe(`name = "John"`);
 
-        result = expressionStatement.exec(`name = othername = "John"`)
+        result = assignment.exec(`name = othername = "John"`)
         expect(result.ast?.value).toBe(`name = othername = "John"`);
 
-        result = expressionStatement.exec(`name = othername.prop = "John"`)
+        result = assignment.exec(`name = othername.prop = "John"`)
         expect(result.ast?.value).toBe(`name = othername.prop = "John"`);
 
-        result = expressionStatement.exec(`name = othername.prop += 2`)
+        result = assignment.exec(`name = othername.prop += 2`)
         expect(result.ast?.value).toBe(`name = othername.prop += 2`);
-    
-        result = expressionStatement.exec(`name.prop().method(blah) = blah.prop()`)
-        expect(result.ast?.value).toBe(`name.prop().method(blah) = blah.prop()`);
-    
+
+        result = assignment.exec(`name.prop().method(blah) = blah.prop() == ha ? first : second`)
+        expect(result.ast?.value).toBe(`name.prop().method(blah) = blah.prop() == ha ? first : second`);
+    });
+
+
+    test("Object Access", () => {
+        let result = expression.exec("name.prop");
+        expect(result.ast?.value).toBe(`name.prop`);
+
+        result = expression.exec(`name.prop.anotherProp["Ha"][coolYo] === 1`);
+        expect(result.ast?.value).toBe(`name.prop.anotherProp["Ha"][coolYo] === 1`);
     });
 
 

package/src/intellisense/javascript/{expressionStatement.ts → assignment.ts}

@@ -1,7 +1,7 @@
 import { And } from "../../patterns/And";
 import { Literal } from "../../patterns/Literal";
 import { Or } from "../../patterns/Or";
-import { Repeat } from "../../patterns/Repeat";
+import { Reference } from "../../patterns/Reference";
 import { expression } from "./expression";
 import { optionalSpaces } from "./optionalSpaces";
 
@@ -16,14 +16,13 @@ const assignment = new And("assignment", [
     optionalSpaces,
     assignmentOperators,
     optionalSpaces,
+    new Or("assignment-right-operand", [
+        new Reference("assignment"),
+        expression
+    ]),
 ]);
 
-const expressionStatement = new And("expressionStatement", [
-    new Repeat("assignments",
-        assignment),
-    optionalSpaces,
-    expression
-]);
 
 
-export { expressionStatement }
+
+export { assignment }

package/src/intellisense/javascript/expression.ts

@@ -6,8 +6,10 @@ import { Reference } from "../../patterns/Reference";
 import { Repeat } from "../../patterns/Repeat";
 import { infixOperator } from "./infixOperator";
 import { invocation } from "./invocation";
+import { nullKeyword } from "./keywords";
 import { literal } from "./literal";
 import { name } from "./name";
+import { objectAccess } from "./objectAccess";
 import { optionalSpaces } from "./optionalSpaces";
 import { prefixOperator } from "./prefixOperator";
 import { propertyAccess } from "./propertyAccess";
@@ -41,46 +43,62 @@ const prefixExpression = new And("prefix-expression", [
     new Reference("expression")
 ]);
 
-const optionalInfix = new And("infix-expression", [
-    infixOperator,
-    optionalSpaces,
-    new Reference("expression"),
-], true);
-
-const optionalTernary = new And("ternary", [
-    new Literal("question-mark", "?"),
-    optionalSpaces,
-    new Reference("expression"),
-    optionalSpaces,
-    new Literal("colon", ":"),
-    optionalSpaces,
-    new Reference("expression")
-], true);
-
-const optionalMemberAccesses = new Repeat("object-member-accesses",
-    new Or("object-member-access", [
+const memberAccess = new Repeat("member-access",
+    new Or("member-access", [
         invocation,
         propertyAccess,
-    ]),
-    undefined, true
+    ])
 );
 
+
 var variableName = name.clone("variable-name");
 
 const expressions = new Or("expressions", [
     newExpression,
     deleteExpression,
-    groupExpression,
-    prefixExpression,
     literal,
+    nullKeyword,
+    objectAccess,
     variableName,
+    groupExpression,
+    prefixExpression
 ]);
 
-const expression = new And("expression", [
+const expressionBody = new And("expression-body", [
     expressions,
-    optionalInfix,
-    optionalTernary,
-    optionalMemberAccesses
+    memberAccess.clone(undefined, true),
+]);
+
+const infixExpression = new And("infix-expression", [
+    expressionBody,
+    optionalSpaces,
+    infixOperator,
+    optionalSpaces,
+    new Or("infix-right-operand", [
+        new Reference("infix-expression"),
+        expressionBody,
+    ])
+]);
+
+const ternaryExpression = new And("ternary", [
+    new Or("ternary-condition", [
+        infixExpression,
+        expressionBody
+    ]),
+    optionalSpaces,
+    new Literal("question-mark", "?"),
+    optionalSpaces,
+    new Reference("expression"),
+    optionalSpaces,
+    new Literal("colon", ":"),
+    optionalSpaces,
+    new Reference("expression")
+]);
+
+const expression = new Or("expression", [
+    ternaryExpression,
+    infixExpression,
+    expressionBody
 ]);
 
 export { expression }

package/src/intellisense/javascript/infixOperator.ts

@@ -10,8 +10,10 @@ const greaterOrEqual = new Literal("greater-or-equal", ">=");
 const lessOrEqual = new Literal("less-or-equal", "<=");
 const greater = new Literal("greater", ">");
 const less = new Literal("less", "<");
-const equal = new Literal("equal", "===");
-const notEqual = new Literal("not-equal", "!==");
+const equal = new Literal("equal", "==");
+const notEqual = new Literal("not-equal", "!=");
+const strictEqual = new Literal("strict-equal", "===");
+const strictNotEqual = new Literal("strict-not-equal", "!==");
 const logicalOr = new Literal("logical-or", "||");
 const logicalAnd = new Literal("logical-and", "&&");
 
@@ -25,6 +27,8 @@ const infixOperator = new Or("infix-operator", [
     lessOrEqual,
     greater,
     less,
+    strictEqual,
+    strictNotEqual,
     equal,
     notEqual,
     logicalOr,

package/src/intellisense/javascript/keywords.ts

@@ -0,0 +1,3 @@
+import { Literal } from "../../patterns/Literal";
+
+export const nullKeyword = new Literal("null", "null");

package/src/intellisense/javascript/objectAccess.ts

@@ -0,0 +1,9 @@
+import { And } from "../../patterns/And";
+import { Reference } from "../../patterns/Reference";
+import { name } from "./name";
+import { propertyAccess } from "./propertyAccess";
+
+export const objectAccess = new And("object-access", [
+    name.clone("variable-name"),
+    propertyAccess,
+]);

package/src/intellisense/javascript/objectLiteral.ts

@@ -8,7 +8,7 @@ import { name } from "./name";
 import { optionalSpaces } from "./optionalSpaces";
 import { stringLiteral } from "./stringLiteral";
 
-const propertyName = new Or("property-name", [stringLiteral, name]);
+const propertyName = new Or("property-name", [stringLiteral.clone("object-property"), name.clone("object-property")]);
 const property = new And("property", [
     propertyName,
     optionalSpaces,
@@ -17,12 +17,12 @@ const property = new And("property", [
     new Reference("expression"),
 ]);
 const divider = new Regex("property-divider", "\\s*,\\s*");
-const properties = new Repeat("properties", property, divider, true);
+const optionalProperties = new Repeat("properties", property, divider, true);
 
 const objectLiteral = new And("object-literal", [
     new Literal("open-curly-bracket", "{"),
     optionalSpaces,
-    properties,
+    optionalProperties,
     optionalSpaces,
     new Literal("close-curly-bracket", "}"),
 ]);