clarity-pattern-parser 5.0.0 → 6.0.2

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,51 @@ 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)
+    });
+
+    test("Find Ancester Without Parent", () => {
+        const child = new Node("child", "child", 0, 0, []);
+        const result = child.findAncester(p => p.name === "parent")
+        expect(result).toBeNull()
+    });
+
 });

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,17 +2,19 @@ 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", () => {
         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.nextPattern).toBe(name);
+        expect(result.errorAtIndex).toBe(0);
         expect(result.isComplete).toBeFalsy();
     });
 
@@ -21,52 +23,195 @@ 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])]);
+
+        const autoComplete = new AutoComplete(name);
+        const result = autoComplete.suggestFor("John Doe");
 
-        space.enableContextualTokenAggregation();
+        expect(result.ast?.value).toBe("John Doe");
+        expect(result.options.length).toBe(0);
+        expect(result.errorAtIndex).toBeNull();
+        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 text = "John "
         const autoComplete = new AutoComplete(name);
-        let result = autoComplete.suggest("John");
-
-        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);
+        const result = autoComplete.suggestFor(text);
+        const expectedOptions = [{
+            text: "Doe",
+            startIndex: 5
+        }, {
+            text: "Smith",
+            startIndex: 5
+        }];
+
+        expect(result.ast).toBeNull();
+        expect(result.options).toEqual(expectedOptions);
+        expect(result.errorAtIndex).toBe(text.length)
         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 text = "John Doe";
+        const autoComplete = new AutoComplete(new Repeat("last-names", name, divider));
+        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();
     });
 
     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.nextPattern).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.nextPattern).toBe(null);
+        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 AutoComplete on Composing Pattern", () => {
+        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 = "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: " Sparrow", startIndex: 4 },
+        ];
+
+        const results = expectedOptions.map(o => text.slice(0, o.startIndex) + o.text);
+        const expectedResults = [
+            "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(errorAtIndex).toBe(4);
+        expect(options).toEqual(expectedOptions);
+        expect(results).toEqual(expectedResults)
+
+    });
+
 });