clarity-pattern-parser 4.0.3 → 6.0.0

package/src/intellisense/AutoComplete.test.ts

@@ -0,0 +1,150 @@
+import { And } from "../patterns/And";
+import { findPattern } from "../patterns/findPattern";
+import { Literal } from "../patterns/Literal";
+import { Or } from "../patterns/Or";
+import { Regex } from "../patterns/Regex";
+import { Repeat } from "../patterns/Repeat";
+import { AutoComplete, AutoCompleteOptions } from "./AutoComplete";
+
+describe("AutoComplete", () => {
+    test("No Text", () => {
+        const name = new Literal("name", "Name");
+        const autoComplete = new AutoComplete(name);
+        let result = autoComplete.suggest("");
+
+        expect(result.options[0].text).toBe("Name");
+        expect(result.options[0].startIndex).toBe(0);
+        expect(result.nextPatterns[0]).toBe(name);
+        expect(result.isComplete).toBeFalsy();
+    });
+
+    test("Full Pattern Match", () => {
+        const john = new Literal("john", "John");
+        const space = new Literal("space", " ");
+        const doe = new Literal("doe", "Doe");
+        const smith = new Literal("smith", "Smith");
+        const name = new And("name", [john, space, new Or("last-name", [smith, doe])]);
+
+        const autoComplete = new AutoComplete(name);
+        const result = autoComplete.suggest("John Doe");
+
+        expect(result.ast?.value).toBe("John Doe");
+        expect(result.options.length).toBe(0);
+        expect(result.nextPatterns.length).toBe(0);
+        expect(result.isComplete).toBeTruthy();
+        expect(result.cursor).not.toBeNull();
+    });
+
+    test("More Than One Option", () => {
+        const john = new Literal("john", "John");
+        const space = new Literal("space", " ");
+        const doe = new Literal("doe", "Doe");
+        const smith = new Literal("smith", "Smith");
+        const name = new And("name", [john, space, new Or("last-name", [smith, doe])]);
+
+        const autoComplete = new AutoComplete(name);
+        const result = autoComplete.suggest("John ");
+
+        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.isComplete).toBeFalsy();
+        expect(result.cursor).not.toBeNull();
+    });
+
+    test("Full Pattern Match With Root Repeat", () => {
+        const john = new Literal("john", "John");
+        const space = new Literal("space", " ");
+        const doe = new Literal("doe", "Doe");
+        const smith = new Literal("smith", "Smith");
+        const name = new And("name", [john, space, new Or("last-name", [smith, doe])]);
+        const divider = new Regex("divider", "\\s+,\\s+");
+
+        divider.setTokens([", "])
+
+        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);
+        expect(result.isComplete).toBeTruthy();
+        expect(result.cursor).not.toBeNull();
+    });
+
+    test("Partial", () => {
+        const name = new Literal("name", "Name");
+        const autoComplete = new AutoComplete(name);
+        let result = autoComplete.suggest("Na");
+
+        expect(result.options[0].text).toBe("me");
+        expect(result.options[0].startIndex).toBe(2);
+        expect(result.nextPatterns[0]).toBe(name);
+        expect(result.isComplete).toBeFalsy();
+    });
+
+    test("Partial Match With Bad Characters", () => {
+        const name = new Literal("name", "Name");
+        const autoComplete = new AutoComplete(name);
+        let result = autoComplete.suggest("Ni");
+
+        expect(result.options[0].text).toBe("ame");
+        expect(result.options[0].startIndex).toBe(1);
+        //expect(result.nextPattern).toBe(name);
+        expect(result.isComplete).toBeFalsy();
+    });
+
+    test("Complete", () => {
+        const name = new Literal("name", "Name");
+        const autoComplete = new AutoComplete(name);
+        let result = autoComplete.suggest("Name");
+
+        expect(result.options.length).toBe(0);
+        expect(result.nextPatterns.length).toBe(0);
+        expect(result.isComplete).toBeTruthy();
+    });
+
+    test("Options", ()=>{
+        const autoCompleteOptions: AutoCompleteOptions = {
+            greedyPatternNames: ["space"],
+            customTokens: {
+                "last-name": ["Sparrow"]
+            }
+        };
+
+        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 = "John";
+        const autoComplete = new AutoComplete(fullName, autoCompleteOptions);
+        const { options, ast, nextPatterns } = autoComplete.suggest(text);
+        const expectedOptions = [
+            {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 expectedResults = [
+            "John Doe",
+            "John Smith",
+            "John Sparrow",
+        ]
+
+        expect(options).toEqual(expectedOptions);
+        expect(ast).toBeNull();
+        expect(nextPatterns.length).toBe(1);
+        expect(nextPatterns[0].name).toBe("space");
+        expect(results).toEqual(expectedResults)
+
+    });
+
+});

package/src/intellisense/AutoComplete.ts

@@ -0,0 +1,200 @@
+import { Cursor } from "../patterns/Cursor";
+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, options: AutoCompleteOptions = defaultOptions) {
+    this._pattern = pattern;
+    this._options = options;
+    this._text = "";
+  }
+
+  suggest(text: string): Suggestion {
+    if (text.length === 0) {
+      return {
+        isComplete: false,
+        options: this.createSuggestionsFromRoot(),
+        nextPatterns: [this._pattern],
+        cursor: null,
+        ast: null
+      }
+    }
+
+    this._text = text;
+    this._cursor = new Cursor(text);
+    const ast = this._pattern.parse(this._cursor);
+
+    const leafPattern = this._cursor.leafMatch.pattern;
+    const isComplete = ast?.value === text;
+    const options = this.createSuggestionsFromTokens();
+
+    let nextPatterns = [this._pattern];
+
+    if (leafPattern != null) {
+      nextPatterns = leafPattern.getNextPatterns();
+    }
+
+    return {
+      isComplete: isComplete,
+      options: options,
+      nextPatterns,
+      cursor: this._cursor,
+      ast,
+    }
+  }
+
+  private createSuggestionsFromRoot(): SuggestionOption[] {
+    const suggestions: SuggestionOption[] = [];
+    const tokens = this._pattern.getTokens();
+
+    for (const token of tokens) {
+      suggestions.push(this.createSuggestion("", token));
+    }
+
+    return suggestions;
+  }
+
+  private createSuggestionsFromTokens(): SuggestionOption[] {
+    const leafMatch = this._cursor.leafMatch;
+
+    if (!leafMatch.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) {
+      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 _getTokensForPattern(pattern: Pattern) {
+    if (this._options.greedyPatternNames.includes(pattern.name)) {
+      const greedyTokens = pattern.getTokens();
+      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 greedyTokens){
+        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;
+    }
+  }
+
+  private createSuggestions(lastIndex: number, tokens: string[]): SuggestionOption[] {
+    let substring = lastIndex === -1 ? "" : this._cursor.getChars(0, lastIndex);
+    const suggestionStrings: string[] = [];
+    const options: SuggestionOption[] = [];
+
+    for (const token of tokens) {
+      const suggestion = substring + token;
+      const startsWith = suggestion.startsWith(substring);
+      const alreadyExist = suggestionStrings.includes(suggestion);
+      const isSameAsText = suggestion === this._text;
+
+      if (startsWith && !alreadyExist && !isSameAsText) {
+        suggestionStrings.push(suggestion);
+        options.push(this.createSuggestion(this._cursor.text, suggestion));
+      }
+    }
+
+    const reducedOptions = getFurthestOptions(options);
+    reducedOptions.sort((a, b) => a.text.localeCompare(b.text));
+
+    return reducedOptions;
+  }
+
+  private createSuggestion(fullText: string, suggestion: string): SuggestionOption {
+    const furthestMatch = findMatchIndex(suggestion, fullText);
+    const text = suggestion.slice(furthestMatch);
+
+    return {
+      text: text,
+      startIndex: furthestMatch,
+    }
+  }
+}
+
+function findMatchIndex(str1: string, str2: string): number {
+  let matchCount = 0;
+  let minLength = str1.length;
+
+  if (str2.length < minLength) {
+    minLength = str2.length;
+  }
+
+  for (let i = 0; i < minLength; i++) {
+    if (str1[i] === str2[i]) {
+      matchCount++;
+    } else {
+      break;
+    }
+  }
+
+  return matchCount;
+}
+
+function getFurthestOptions(options: SuggestionOption[]): SuggestionOption[] {
+  let furthestOptions: SuggestionOption[] = [];
+  let furthestIndex = -1;
+
+  for (const option of options) {
+    if (option.startIndex > furthestIndex) {
+      furthestIndex = option.startIndex;
+      furthestOptions = [];
+    }
+
+    if (option.startIndex === furthestIndex) {
+      furthestOptions.push(option);
+    }
+  }
+
+  return furthestOptions;
+}
+

package/src/intellisense/Suggestion.ts

@@ -0,0 +1,12 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "../patterns/Cursor";
+import { Pattern } from "../patterns/Pattern";
+import { SuggestionOption } from "./SuggestionOption";
+
+export interface Suggestion {
+  isComplete: boolean;
+  options: SuggestionOption[];
+  nextPatterns: Pattern[];
+  cursor: Cursor | null;
+  ast: Node | null;
+}

package/src/intellisense/SuggestionOption.ts

@@ -0,0 +1,4 @@
+export interface SuggestionOption {
+  text: string;
+  startIndex: number;
+}

package/src/{tests/cssPatterns → intellisense/css}/cssValue.ts

@@ -1,4 +1,4 @@
-import { Repeat } from "../../index";
+import { Repeat } from "../../patterns/Repeat";
 import divider from "./divider";
 import values from "./values";
 

package/src/{tests/cssPatterns → intellisense/css}/divider.ts

@@ -1,5 +1,6 @@
-import { Regex } from "../../index";
+import { Regex } from "../../patterns/Regex";
 
 const divider = new Regex(",", "\\s*[,]\\s*");
+divider.setTokens([", "]);
 
 export default divider;

package/src/intellisense/css/hex.ts

@@ -0,0 +1,6 @@
+import { Regex } from "../../patterns/Regex";
+
+const hex = new Regex("hex", "#[0-9a-fA-F]{6}|#[0-9a-fA-F]{3}");
+hex.setTokens(["#000", "#FFF"]);
+
+export default hex;

package/src/{tests/cssPatterns → intellisense/css}/method.ts

@@ -1,21 +1,20 @@
-import {
-  Literal,
-  And,
-  Repeat,
-  Recursive,
-} from "../../index";
-
+import { Reference } from "../../patterns/Reference";
+import { Literal } from "../../patterns/Literal";
+import { Repeat } from "../../patterns/Repeat";
+import { And } from "../../patterns/And";
 import name from "./name";
 import optionalSpaces from "./optionalSpaces";
 import divider from "./divider";
 
 const openParen = new Literal("open-paren", "(");
 const closeParen = new Literal("close-paren", ")");
-const values = new Recursive("values");
+const values = new Reference("values");
 const args = new Repeat("arguments", values, divider, true);
+const methodName = name.clone("method-name");
+methodName.setTokens(["rgba", "radial-gradient", "linear-gradient"]);
 
 const method = new And("method", [
-  name.clone("[Method Name]"),
+  methodName,
   openParen,
   optionalSpaces,
   args,

package/src/intellisense/css/name.ts

@@ -0,0 +1,5 @@
+import { Regex } from "../../patterns/Regex";
+
+const name = new Regex("name", "[a-zA-Z]+[a-zA-Z0-9_-]+");
+
+export default name;

package/src/{tests/javascriptPatterns → intellisense/css}/number.ts

@@ -1,10 +1,10 @@
-import {
-  Regex
-} from "../../index";
+import { Regex } from "../../patterns/Regex";
 
 const number = new Regex(
   "number",
   "[-+]?[0-9]*[.]?[0-9]+([eE][-+]?[0-9]+)?"
 );
 
+number.setTokens(["0"]);
+
 export default number;

package/src/intellisense/css/spaces.ts

@@ -0,0 +1,6 @@
+import { Regex } from "../../patterns/Regex";
+
+const spaces = new Regex("spaces", "\\s+");
+spaces.setTokens([" "])
+
+export default spaces;

package/src/intellisense/css/unit.ts

@@ -0,0 +1,10 @@
+import { And } from "../../patterns/And";
+import { Regex } from "../../patterns/Regex";
+import number from "./number";
+
+const unitType = new Regex("unit-type", "[a-zA-Z%]+");
+unitType.setTokens(["px", "%", "em", "rem", "vh", "vw"]);
+
+const unit = new And("unit", [number, unitType]);
+
+export default unit;

package/src/{tests/cssPatterns → intellisense/css}/value.ts

@@ -1,9 +1,9 @@
-import { Or } from "../../index";
 import unit from "./unit";
 import hex from "./hex";
 import number from "./number";
 import method from "./method";
 import name from "./name"
+import { Or } from "../../patterns/Or";
 
 const value = new Or("value", [hex, method, unit, number, name]);
 

package/src/{tests/cssPatterns → intellisense/css}/values.ts

@@ -1,4 +1,4 @@
-import { Repeat } from "../../index";
+import { Repeat } from "../../patterns/Repeat";
 import value from "./value";
 import spaces from "./spaces";
 

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

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