clarity-pattern-parser 5.0.0 → 6.0.2

package/src/intellisense/AutoComplete.ts

@@ -1,79 +1,160 @@
 import { Cursor } from "../patterns/Cursor";
-import { ParseError } from "../patterns/ParseError";
 import { Pattern } from "../patterns/Pattern";
 import { Suggestion } from "./Suggestion";
 import { SuggestionOption } from "./SuggestionOption";
 
+export interface AutoCompleteOptions {
+  /**
+   * Allows for certain patterns to combine their tokens with the next tokens. 
+   * Be very careful, this can explode to infinity pretty quick. Usually useful 
+   * for dividers and spaces.
+   */
+  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[]>;
+}
+
+const defaultOptions = { greedyPatternNames: [], customTokens: {} };
+
 export class AutoComplete {
   private _pattern: Pattern;
+  private _options: AutoCompleteOptions;
   private _cursor!: Cursor;
   private _text: string;
 
-  constructor(pattern: Pattern) {
+  constructor(pattern: Pattern, options: AutoCompleteOptions = defaultOptions) {
     this._pattern = pattern;
+    this._options = options;
     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(),
-        nextPattern: this._pattern,
+        options: this._createSuggestionsFromRoot(),
+        errorAtIndex: 0,
         cursor: null,
-        error: new ParseError(0, this._pattern),
+        ast: null
       }
     }
 
     this._text = text;
     this._cursor = new Cursor(text);
-    this._pattern.parse(this._cursor);
+    const ast = this._pattern.parse(this._cursor);
 
     const leafPattern = this._cursor.leafMatch.pattern;
-    const rootMatch = this._cursor.rootMatch.pattern;
-    const isComplete = this._cursor.isOnLast && rootMatch === this._pattern;
-    const options = this.createSuggestionsFromTokens();
-    const nextPattern = isComplete ? null : leafPattern?.getNextPattern() || this._pattern;
+    const isComplete = ast?.value === text;
+    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,
-      nextPattern,
+      errorAtIndex,
       cursor: this._cursor,
-      error: this._cursor.furthestError
+      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._pattern.getTokens());
+      return this._createSuggestions(-1, this._getTokensForPattern(this._pattern));
     }
 
     const leafPattern = leafMatch.pattern;
     const parent = leafMatch.pattern.parent;
 
     if (parent !== null && leafMatch.node != null) {
-      const tokens = parent.getNextTokens(leafPattern);
-      return this.createSuggestions(leafMatch.node.lastIndex, tokens);
+      const patterns = leafPattern.getNextPatterns();
+
+      const tokens = patterns.reduce((acc: string[], pattern) => {
+        acc.push(...this._getTokensForPattern(pattern));
+        return acc;
+      }, []);
+
+      return this._createSuggestions(leafMatch.node.lastIndex, tokens);
     } else {
       return [];
     }
   }
 
-  private createSuggestions(lastIndex: number, tokens: string[]): SuggestionOption[] {
+  private _getTokensForPattern(pattern: Pattern) {
+    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) => {
+        acc.push(...this._getTokensForPattern(pattern));
+        return acc;
+      }, []);
+
+      for (let token of augmentedTokens) {
+        for (let nextPatternToken of nextPatternTokens) {
+          tokens.push(token + nextPatternToken);
+        }
+      }
+
+      return tokens;
+    } else {
+      return augmentedTokens;
+    }
+  }
+
+  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[] = [];
@@ -86,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));
       }
     }
 
@@ -96,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

@@ -1,13 +1,12 @@
+import { Node } from "../ast/Node";
 import { Cursor } from "../patterns/Cursor";
-import { Match } from "../patterns/CursorHistory";
-import { ParseError } from "../patterns/ParseError";
 import { Pattern } from "../patterns/Pattern";
 import { SuggestionOption } from "./SuggestionOption";
 
 export interface Suggestion {
   isComplete: boolean;
   options: SuggestionOption[];
-  nextPattern: Pattern | null;
+  errorAtIndex: number | null;
   cursor: Cursor | null;
-  error: ParseError | null;
+  ast: Node | null;
 }

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

@@ -1,202 +1,226 @@
+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", () => {
-        let result = escapedCharacter.parseText(`\\"`);
+        let result = escapedCharacter.exec(`\\"`);
         expect(result.ast?.value).toBe(`\\"`)
 
-        result = escapedCharacter.parseText(`\\'`)
+        result = escapedCharacter.exec(`\\'`)
         expect(result.ast?.value).toBe(`\\'`)
 
-        result = escapedCharacter.parseText(`\\\\`)
+        result = escapedCharacter.exec(`\\\\`)
         expect(result.ast?.value).toBe(`\\\\`)
 
-        result = escapedCharacter.parseText(`\\/`)
+        result = escapedCharacter.exec(`\\/`)
         expect(result.ast?.value).toBe(`\\/`)
 
-        result = escapedCharacter.parseText(`\\f`)
+        result = escapedCharacter.exec(`\\f`)
         expect(result.ast?.value).toBe(`\\f`)
 
-        result = escapedCharacter.parseText(`\\t`)
+        result = escapedCharacter.exec(`\\t`)
         expect(result.ast?.value).toBe(`\\t`)
 
-        result = escapedCharacter.parseText(`\\u00E9`)
+        result = escapedCharacter.exec(`\\u00E9`)
         expect(result.ast?.value).toBe(`\\u00E9`)
     });
 
     test("Exponent", () => {
-        let result = exponent.parseText("e+1");
+        let result = exponent.exec("e+1");
         expect(result.ast?.value).toBe("e+1")
 
-        result = exponent.parseText("e-1");
+        result = exponent.exec("e-1");
         expect(result.ast?.value).toBe("e-1")
 
-        result = exponent.parseText("E+1");
+        result = exponent.exec("E+1");
         expect(result.ast?.value).toBe("E+1")
 
-        result = exponent.parseText("E-1");
+        result = exponent.exec("E-1");
         expect(result.ast?.value).toBe("E-1")
 
-        result = exponent.parseText("e+11");
+        result = exponent.exec("e+11");
         expect(result.ast?.value).toBe("e+11")
 
-        result = exponent.parseText("11");
+        result = exponent.exec("11");
         expect(result.ast).toBeNull()
     });
 
     test("Integer", () => {
-        let result = integer.parseText("0");
+        let result = integer.exec("0");
         expect(result.ast?.value).toBe("0");
 
-        result = integer.parseText("1");
+        result = integer.exec("1");
         expect(result.ast?.value).toBe("1");
 
-        result = integer.parseText("100");
+        result = integer.exec("100");
         expect(result.ast?.value).toBe("100");
 
-        result = integer.parseText(".1");
+        result = integer.exec(".1");
         expect(result.ast).toBeNull();
     });
 
     test("Infix Operator", () => {
-        let result = infixOperator.parseText("*");
+        let result = infixOperator.exec("*");
         expect(result.ast?.value).toBe("*");
 
-        result = infixOperator.parseText("/");
+        result = infixOperator.exec("/");
         expect(result.ast?.value).toBe("/");
 
-        result = infixOperator.parseText("%");
+        result = infixOperator.exec("%");
         expect(result.ast?.value).toBe("%");
 
-        result = infixOperator.parseText("+");
+        result = infixOperator.exec("+");
         expect(result.ast?.value).toBe("+");
 
-        result = infixOperator.parseText("-");
+        result = infixOperator.exec("-");
         expect(result.ast?.value).toBe("-");
 
-        result = infixOperator.parseText(">=");
+        result = infixOperator.exec(">=");
         expect(result.ast?.value).toBe(">=");
 
-        result = infixOperator.parseText("<=");
+        result = infixOperator.exec("<=");
         expect(result.ast?.value).toBe("<=");
 
-        result = infixOperator.parseText(">");
+        result = infixOperator.exec(">");
         expect(result.ast?.value).toBe(">");
 
-        result = infixOperator.parseText("<");
+        result = infixOperator.exec("<");
         expect(result.ast?.value).toBe("<");
 
-        result = infixOperator.parseText("===");
+        result = infixOperator.exec("===");
         expect(result.ast?.value).toBe("===");
 
-        result = infixOperator.parseText("!==");
+        result = infixOperator.exec("!==");
         expect(result.ast?.value).toBe("!==");
 
-        result = infixOperator.parseText("||");
+        result = infixOperator.exec("||");
         expect(result.ast?.value).toBe("||");
 
-        result = infixOperator.parseText("&&");
+        result = infixOperator.exec("&&");
         expect(result.ast?.value).toBe("&&");
 
-        result = infixOperator.parseText("bad");
+        result = infixOperator.exec("bad");
         expect(result.ast).toBeNull();
     });
 
 
     test("Name", () => {
-        let result = name.parseText("p_0");
+        let result = name.exec("p_0");
         expect(result.ast?.value).toBe("p_0");
 
-        result = name.parseText("_0");
+        result = name.exec("_0");
         expect(result.ast?.value).toBe("_0");
 
-        result = name.parseText("0");
+        result = name.exec("0");
         expect(result.ast).toBeNull();
 
-        result = name.parseText("_");
+        result = name.exec("_");
         expect(result.ast?.value).toBe("_");
     });
 
     test("Parameters", () => {
-        let result = parameters.parseText("(param1)");
+        let result = parameters.exec("(param1)");
         expect(result.ast?.value).toBe("(param1)");
 
-        result = parameters.parseText("(param1, param2)");
+        result = parameters.exec("(param1, param2)");
         expect(result.ast?.value).toBe("(param1, param2)");
 
-        result = parameters.parseText("(param1, param2,)");
+        result = parameters.exec("(param1, param2,)");
         expect(result.ast).toBeNull();
     });
 
     test("Prefix Operator", () => {
-        let result = prefixOperator.parseText("typeof ");
+        let result = prefixOperator.exec("typeof ");
         expect(result.ast?.value).toBe("typeof ");
 
-        result = prefixOperator.parseText("+");
+        result = prefixOperator.exec("+");
         expect(result.ast?.value).toBe("+");
 
-        result = prefixOperator.parseText("-");
+        result = prefixOperator.exec("-");
         expect(result.ast?.value).toBe("-");
 
-        result = prefixOperator.parseText("!");
+        result = prefixOperator.exec("!");
         expect(result.ast?.value).toBe("!");
 
-        result = prefixOperator.parseText("a");
+        result = prefixOperator.exec("a");
         expect(result.ast).toBeNull();
     });
 
     test("Object Literal", () => {
-        let result = expression.parseText(`{}`)
+        let result = expression.exec(`{}`)
         expect(result.ast?.value).toBe("{}");
 
-        result = expression.parseText(`{prop:{}}`)
+        result = expression.exec(`{prop:{}}`)
         expect(result.ast?.value).toBe("{prop:{}}");
 
-        result = expression.parseText(`{prop:"value"}`)
+        result = expression.exec(`{prop:"value"}`)
         expect(result.ast?.value).toBe(`{prop:"value"}`);
 
-        result = expression.parseText(`{prop:0.9}`)
+        result = expression.exec(`{prop:0.9}`)
         expect(result.ast?.value).toBe(`{prop:0.9}`);
 
-        result = expression.parseText(`{prop:1}`)
+        result = expression.exec(`{prop:1}`)
         expect(result.ast?.value).toBe(`{prop:1}`);
 
-        result = expression.parseText(`{"prop":1}`)
+        result = expression.exec(`{"prop":1}`)
         expect(result.ast?.value).toBe(`{"prop":1}`);
     });
 
-    test("Array Literal", () => {
-        let result = expression.parseText("[]")
+    test("Expression", () => {
+
+        let result = expression.exec("[]")
         expect(result.ast?.value).toBe("[]");
 
-        result = expression.parseText("[{}, 9, 0.9e-10, [1, 2]]")
+        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.parseText(`name = "John"`);
+        let result = assignment.exec(`name = "John"`);
         expect(result.ast?.value).toBe(`name = "John"`);
 
-        result = expressionStatement.parseText(`name = othername = "John"`)
+        result = assignment.exec(`name = othername = "John"`)
         expect(result.ast?.value).toBe(`name = othername = "John"`);
 
-        result = expressionStatement.parseText(`name = othername.prop = "John"`)
+        result = assignment.exec(`name = othername.prop = "John"`)
         expect(result.ast?.value).toBe(`name = othername.prop = "John"`);
 
-        result = expressionStatement.parseText(`name = othername.prop += 2`)
+        result = assignment.exec(`name = othername.prop += 2`)
         expect(result.ast?.value).toBe(`name = othername.prop += 2`);
-    
-        result = expressionStatement.parseText(`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/escapedCharacter.ts

@@ -42,7 +42,6 @@ const specialCharacter = new Or("special-character", [
 ]);
 
 const escapedCharacter = new And("escaped-character", [backslash, specialCharacter])
-escapedCharacter.enableAstReduction();
 
 export {
     escapedCharacter

package/src/intellisense/javascript/exponent.ts

@@ -21,6 +21,4 @@ const exponent = new And("exponent", [
     digit,
 ]);
 
-exponent.enableAstReduction();
-
 export { exponent }

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/fraction.ts

@@ -6,8 +6,6 @@ const period = new Literal("period", ".");
 const digit = new Regex("digit", "\\d+");
 const fraction = new And("fraction", [period, digit]);
 
-fraction.enableAstReduction();
-
 export {
     fraction
 }