clarity-pattern-parser 5.0.0 → 6.0.0

package/src/ast/Node.test.ts

@@ -15,6 +15,25 @@ describe("Node", () => {
         expect(node.children.length).toBe(0);
     });
 
+    test("Properties", () => {
+        const child = new Node("child", "child", 0, 0, undefined, "Content")
+        const parent = new Node("parent", "parent", 0, 0, [
+            child,
+        ]);
+
+        expect(parent.hasChildren).toBeTruthy();
+        expect(child.parent).toBe(parent);
+        expect(parent.children[0]).toBe(child);
+        expect(child.type).toBe("child");
+        expect(parent.value).toBe("Content");
+        expect(child.value).toBe("Content");
+        expect(child.name).toBe("child");
+        expect(child.firstIndex).toBe(0);
+        expect(child.lastIndex).toBe(0);
+        expect(child.startIndex).toBe(0);
+        expect(child.endIndex).toBe(1);
+    });
+
     test("Create Tree", () => {
         const child = new Node("child", "child", 0, 0, [], "Child");
         const parent = new Node("parent", "parent", 0, 0, [child]);
@@ -164,6 +183,56 @@ describe("Node", () => {
         expect(b.value).toBe("B");
     });
 
+    test("Next Sibling", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        new Node("parent", "parent", 0, 0, [a, b]);
+
+        const nextSibling = a.nextSibling()
+
+        expect(nextSibling).toBe(b);
+    });
+
+    test("Next Sibling (No Parent)", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+
+        const nextSibling = a.nextSibling()
+        expect(nextSibling).toBeNull;
+    });
+
+    test("Next Sibling (Last Child)", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        new Node("parent", "parent", 0, 0, [a, b]);
+
+        const nextSibling = b.nextSibling()
+        expect(nextSibling).toBeNull;
+    });
+
+    test("Previous Sibling", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        new Node("parent", "parent", 0, 0, [a, b]);
+
+        const previousSibling = b.previousSibling()
+
+        expect(previousSibling).toBe(a);
+    });
+
+    test("Previous Sibling (No Parent)", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const previousSibling = a.previousSibling()
+        expect(previousSibling).toBeNull();
+    });
+
+    test("Previous Sibling (First Child)", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        new Node("parent", "parent", 0, 0, [a, b]);
+
+        const previousSibling = a.previousSibling()
+        expect(previousSibling).toBeNull;
+    });
 
     test("Find", () => {
         const a = new Node("a", "a", 0, 0, [], "A");
@@ -251,4 +320,45 @@ describe("Node", () => {
         expect(result).toEqual(expected)
     });
 
+    test("Reduce", () => {
+        const parent = new Node("parent", "parent", 0, 6, [
+            new Node("child", "child", 0, 6, undefined, "Content")
+        ]);
+
+        parent.reduce();
+
+        expect(parent.hasChildren).toBeFalsy();
+        expect(parent.value).toBe("Content")
+    });
+
+    test("Flatten", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 1, 1, [], "B");
+        const c = new Node("c", "c", 2, 2, [], "C");
+
+        const parent = new Node("parent", "parent", 0, 1, [
+            a,
+            b,
+        ]);
+
+        const grandParent = new Node("grand-parent", "grand-parent", 0, 2, [
+            parent,
+            c,
+        ]);
+
+        const nodes = grandParent.flatten();
+        const expected = [a, b, c];
+
+        expect(nodes).toEqual(expected)
+    });
+
+    test("Find Ancester", () => {
+        const child = new Node("child", "child", 0, 0, []);
+        const parent = new Node("parent", "parent", 0, 0, [child]);
+        const grandParent = new Node("grand-parent", "grand-parent", 0, 0, [parent]);
+        const result = child.findAncester(p => p.name === "grand-parent")
+
+        expect(result).toBe(grandParent)
+    });
+
 });

package/src/ast/Node.ts

@@ -50,6 +50,10 @@ export class Node {
     return this._children;
   }
 
+  get hasChildren(): boolean {
+    return this._children.length > 0;
+  }
+
   get value() {
     return this.toString();
   }
@@ -120,25 +124,69 @@ export class Node {
   spliceChildren(index: number, deleteCount: number, ...items: Node[]) {
     const removedItems = this._children.splice(index, deleteCount, ...items);
 
-    items.forEach(i => i._parent = this);
     removedItems.forEach(i => i._parent = null);
+    items.forEach(i => i._parent = this);
 
     return removedItems;
   }
 
-  find(isMatch: (node: Node) => boolean): Node | null {
-    return this.findAll(isMatch)[0] || null
+  nextSibling() {
+    if (this._parent == null) {
+      return null;
+    }
+
+    const children = this._parent._children;
+    const index = children.indexOf(this);
+
+    if (index > -1 && index < children.length - 1) {
+      return children[index + 1]
+    }
+
+    return null
+  }
+
+  previousSibling() {
+    if (this._parent == null) {
+      return null;
+    }
+
+    const children = this._parent._children;
+    const index = children.indexOf(this);
+
+    if (index > -1 && index > 0) {
+      return children[index - 1]
+    }
+
+    return null
   }
 
-  findAll(isMatch: (node: Node) => boolean): Node[] {
+  find(predicate: (node: Node) => boolean): Node | null {
+    return this.findAll(predicate)[0] || null
+  }
+
+  findAll(predicate: (node: Node) => boolean): Node[] {
     const matches: Node[] = [];
     this.walkUp(n => {
-      if (isMatch(n)) { matches.push(n); }
+      if (predicate(n)) { matches.push(n); }
     })
 
     return matches;
   }
 
+  findAncester(predicate: (node: Node) => boolean){
+    let parent = this._parent;
+
+    while(parent != null){
+      if (predicate(parent)){
+        return parent;
+      }
+
+      parent = parent._parent;
+    }
+
+    return null;
+  }
+
   walkUp(callback: (node: Node) => void) {
     this.children.forEach(c => c.walkUp(callback))
     callback(this);
@@ -149,6 +197,24 @@ export class Node {
     this.children.forEach(c => c.walkDown(callback))
   }
 
+  flatten(){
+    const nodes: Node[] = [];
+
+    this.walkDown((node: Node)=>{
+      if (!node.hasChildren){
+        nodes.push(node);
+      }
+    });
+
+    return nodes;
+  }
+
+  reduce() {
+    const value = this.toString();
+    this.removeAllChildren();
+    this._value = value;
+  }
+
   clone(): Node {
     return new Node(
       this._type,

package/src/index.ts

@@ -9,17 +9,28 @@ import { Repeat } from "./patterns/Repeat";
 import { ParseError } from "./patterns/ParseError";
 import { Pattern } from "./patterns/Pattern";
 import { Reference } from "./patterns/Reference";
+import { AutoComplete } from './intellisense/AutoComplete';
+import { CursorHistory, Match } from "./patterns/CursorHistory";
+import { ParseResult } from "./patterns/ParseResult";
+import { Suggestion } from "./intellisense/Suggestion";
+import { SuggestionOption } from "./intellisense/SuggestionOption";
 
 export {
   Node,
-  Cursor,
-  Regex,
+  AutoComplete,
+  Suggestion,
+  SuggestionOption,
   And,
+  Cursor,
+  CursorHistory,
+  Match,
   Literal,
   Not,
   Or,
-  Repeat,
   ParseError,
+  ParseResult,
   Pattern,
   Reference,
+  Regex,
+  Repeat,
 };

package/src/intellisense/AutoComplete.test.ts

@@ -2,7 +2,9 @@ import { And } from "../patterns/And";
 import { findPattern } from "../patterns/findPattern";
 import { Literal } from "../patterns/Literal";
 import { Or } from "../patterns/Or";
-import { AutoComplete } from "./AutoComplete";
+import { Regex } from "../patterns/Regex";
+import { Repeat } from "../patterns/Repeat";
+import { AutoComplete, AutoCompleteOptions } from "./AutoComplete";
 
 describe("AutoComplete", () => {
     test("No Text", () => {
@@ -12,7 +14,7 @@ describe("AutoComplete", () => {
 
         expect(result.options[0].text).toBe("Name");
         expect(result.options[0].startIndex).toBe(0);
-        expect(result.nextPattern).toBe(name);
+        expect(result.nextPatterns[0]).toBe(name);
         expect(result.isComplete).toBeFalsy();
     });
 
@@ -21,21 +23,55 @@ describe("AutoComplete", () => {
         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])]);
 
-        space.enableContextualTokenAggregation();
+        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);
-        let result = autoComplete.suggest("John");
+        const result = autoComplete.suggest("John ");
 
+        expect(result.ast).toBeNull();
         expect(result.options.length).toBe(2);
-        expect(result.nextPattern).toBe(findPattern(name, p=>p.name === "space"));
-        expect(result.options[0].text).toBe(" Doe");
-        expect(result.options[0].startIndex).toBe(4);
-        expect(result.options[1].text).toBe(" Smith");
-        expect(result.options[1].startIndex).toBe(4);
+        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", () => {
@@ -45,7 +81,7 @@ describe("AutoComplete", () => {
 
         expect(result.options[0].text).toBe("me");
         expect(result.options[0].startIndex).toBe(2);
-        expect(result.nextPattern).toBe(name);
+        expect(result.nextPatterns[0]).toBe(name);
         expect(result.isComplete).toBeFalsy();
     });
 
@@ -56,7 +92,7 @@ describe("AutoComplete", () => {
 
         expect(result.options[0].text).toBe("ame");
         expect(result.options[0].startIndex).toBe(1);
-        expect(result.nextPattern).toBe(name);
+        //expect(result.nextPattern).toBe(name);
         expect(result.isComplete).toBeFalsy();
     });
 
@@ -66,7 +102,49 @@ describe("AutoComplete", () => {
         let result = autoComplete.suggest("Name");
 
         expect(result.options.length).toBe(0);
-        expect(result.nextPattern).toBe(null);
+        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

@@ -1,16 +1,33 @@
 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 = "";
   }
 
@@ -19,28 +36,32 @@ export class AutoComplete {
       return {
         isComplete: false,
         options: this.createSuggestionsFromRoot(),
-        nextPattern: this._pattern,
+        nextPatterns: [this._pattern],
         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 isComplete = ast?.value === text;
     const options = this.createSuggestionsFromTokens();
-    const nextPattern = isComplete ? null : leafPattern?.getNextPattern() || this._pattern;
+
+    let nextPatterns = [this._pattern];
+
+    if (leafPattern != null) {
+      nextPatterns = leafPattern.getNextPatterns();
+    }
 
     return {
       isComplete: isComplete,
       options: options,
-      nextPattern,
+      nextPatterns,
       cursor: this._cursor,
-      error: this._cursor.furthestError
+      ast,
     }
   }
 
@@ -59,20 +80,53 @@ export class AutoComplete {
     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 leafNode = leafMatch.node;
     const parent = leafMatch.pattern.parent;
 
     if (parent !== null && leafMatch.node != null) {
-      const tokens = parent.getNextTokens(leafPattern);
+      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[] = [];

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;
+  nextPatterns: Pattern[];
   cursor: Cursor | null;
-  error: ParseError | null;
+  ast: Node | null;
 }