clarity-pattern-parser 4.0.3 → 6.0.0

package/src/ast/Node.test.ts

@@ -0,0 +1,364 @@
+import { Node } from "./Node";
+
+describe("Node", () => {
+    test("Create", () => {
+        const node = new Node("type", "name", 0, 0, [], "value");
+
+        expect(node.type).toBe("type");
+        expect(node.name).toBe("name");
+        expect(node.value).toBe("value");
+        expect(node.firstIndex).toBe(0);
+        expect(node.lastIndex).toBe(0);
+        expect(node.startIndex).toBe(0);
+        expect(node.endIndex).toBe(1);
+        expect(node.parent).toBeNull();
+        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]);
+
+        expect(parent.value).toBe(child.value);
+    });
+
+    test("Remove Child", () => {
+        const child = new Node("child", "child", 0, 0, [], "Child");
+        const parent = new Node("parent", "parent", 0, 0, [child]);
+
+        parent.removeChild(child);
+
+        expect(parent.children.length).toBe(0);
+        expect(child.parent).toBeNull();
+        expect(parent.value).toBe("");
+        expect(child.value).toBe("Child");
+    });
+
+    test("Remove all Child", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a, b], "Fallback Value");
+
+        expect(parent.children.length).toBe(2);
+        expect(a.parent).toBe(parent);
+        expect(b.parent).toBe(parent);
+        expect(parent.value).toBe("AB");
+        expect(a.value).toBe("A");
+        expect(b.value).toBe("B");
+
+        parent.removeAllChildren();
+
+        expect(parent.children.length).toBe(0);
+        expect(a.parent).toBeNull();
+        expect(b.parent).toBeNull();
+        expect(parent.value).toBe("Fallback Value");
+        expect(a.value).toBe("A");
+        expect(b.value).toBe("B");
+    });
+
+    test("Replace Child", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a]);
+
+        parent.replaceChild(b, a);
+
+        expect(parent.children.length).toBe(1);
+        expect(a.parent).toBeNull();
+        expect(b.parent).toBe(parent);
+        expect(a.value).toBe("A");
+        expect(b.value).toBe("B");
+    });
+
+    test("Insert Child", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a]);
+
+        expect(parent.value).toBe("A");
+
+        parent.insertBefore(b, a);
+
+        expect(parent.children.length).toBe(2);
+        expect(parent.value).toBe("BA")
+        expect(parent.children[0]).toBe(b);
+        expect(parent.children[1]).toBe(a);
+        expect(a.parent).toBe(parent);
+        expect(b.parent).toBe(parent);
+        expect(a.value).toBe("A");
+        expect(b.value).toBe("B");
+    });
+
+    test("Insert Child With Null Reference", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a]);
+
+        expect(parent.value).toBe("A");
+
+        parent.insertBefore(b, null);
+
+        expect(parent.children.length).toBe(2);
+        expect(parent.value).toBe("AB")
+        expect(parent.children[0]).toBe(a);
+        expect(parent.children[1]).toBe(b);
+        expect(a.parent).toBe(parent);
+        expect(b.parent).toBe(parent);
+        expect(a.value).toBe("A");
+        expect(b.value).toBe("B");
+    });
+
+    test("Append Child", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a]);
+
+        expect(parent.value).toBe("A");
+
+        parent.appendChild(b);
+
+        expect(parent.children.length).toBe(2);
+        expect(parent.value).toBe("AB")
+        expect(parent.children[0]).toBe(a);
+        expect(parent.children[1]).toBe(b);
+        expect(a.parent).toBe(parent);
+        expect(b.parent).toBe(parent);
+        expect(a.value).toBe("A");
+        expect(b.value).toBe("B");
+    });
+
+    test("Splice Children", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a]);
+
+        expect(parent.value).toBe("A");
+
+        parent.spliceChildren(0, 0, b);
+
+        expect(parent.children.length).toBe(2);
+        expect(parent.value).toBe("BA")
+        expect(parent.children[0]).toBe(b);
+        expect(parent.children[1]).toBe(a);
+        expect(a.parent).toBe(parent);
+        expect(b.parent).toBe(parent);
+        expect(a.value).toBe("A");
+        expect(b.value).toBe("B");
+    });
+
+    test("Splice Children (Replace)", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a]);
+
+        expect(parent.value).toBe("A");
+
+        parent.spliceChildren(0, 1, b);
+
+        expect(parent.children.length).toBe(1);
+        expect(parent.value).toBe("B")
+        expect(parent.children[0]).toBe(b);
+        expect(a.parent).toBeNull();
+        expect(b.parent).toBe(parent);
+        expect(a.value).toBe("A");
+        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");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a, b]);
+
+        const result = parent.find(n => n.name === "a");
+
+        expect(result).toBe(a)
+    });
+
+    test("Walk Down", () => {
+        const result: Node[] = [];
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a, b]);
+
+        parent.walkDown((n) => {
+            result.push(n)
+        });
+
+        const expected = [parent, a, b];
+
+        expect(result).toEqual(expected);
+    });
+
+    test("Walk Up", () => {
+        const result: Node[] = [];
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a, b]);
+
+        parent.walkUp((n) => {
+            result.push(n)
+        });
+
+        const expected = [a, b, parent];
+
+        expect(result).toEqual(expected);
+    });
+
+    test("Clone", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a, b]);
+        const clone = parent.clone();
+
+        expect(clone).toEqual(parent)
+    });
+
+    test("Turn Into JSON", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a, b]);
+        const result = parent.toJson();
+        const expected = JSON.stringify({
+            type: "parent",
+            name: "parent",
+            value: "AB",
+            firstIndex: 0,
+            lastIndex: 0,
+            startIndex: 0,
+            endIndex: 1,
+            children: [{
+                type: "a",
+                name: "a",
+                value: "A",
+                firstIndex: 0,
+                lastIndex: 0,
+                startIndex: 0,
+                endIndex: 1,
+                children: [],
+            }, {
+                type: "b",
+                name: "b",
+                value: "B",
+                firstIndex: 0,
+                lastIndex: 0,
+                startIndex: 0,
+                endIndex: 1,
+                children: [],
+            }],
+        });
+
+        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

@@ -1,39 +1,253 @@
-export default class Node {
-  public type: string;
-  public name: string;
-  public startIndex: number;
-  public endIndex: number;
-  public children: Node[];
-  public value: string;
+export interface CycleFreeNode {
+  type: string;
+  name: string;
+  firstIndex: number;
+  lastIndex: number;
+  startIndex: number;
+  endIndex: number;
+  value: string;
+  children: CycleFreeNode[];
+}
+
+export class Node {
+  private _type: string;
+  private _name: string;
+  private _firstIndex: number;
+  private _lastIndex: number;
+  private _parent: Node | null;
+  private _children: Node[];
+  private _value: string;
+
+  get type() {
+    return this._type;
+  }
+
+  get name() {
+    return this._name;
+  }
+
+  get firstIndex() {
+    return this._firstIndex;
+  }
+
+  get lastIndex() {
+    return this._lastIndex;
+  }
+
+  get startIndex() {
+    return this._firstIndex;
+  }
+
+  get endIndex() {
+    return this._lastIndex + 1;
+  }
+
+  get parent() {
+    return this._parent;
+  }
+
+  get children(): readonly Node[] {
+    return this._children;
+  }
+
+  get hasChildren(): boolean {
+    return this._children.length > 0;
+  }
+
+  get value() {
+    return this.toString();
+  }
 
   constructor(
     type: string,
     name: string,
-    startIndex: number,
-    endIndex: number,
+    firstIndex: number,
+    lastIndex: number,
     children: Node[] = [],
     value: string = ""
   ) {
-    this.type = type;
-    this.name = name;
-    this.startIndex = startIndex;
-    this.endIndex = endIndex;
-    this.children = children;
-    this.value = value;
+    this._type = type;
+    this._name = name;
+    this._firstIndex = firstIndex;
+    this._lastIndex = lastIndex;
+    this._parent = null;
+    this._children = children;
+    this._value = value;
+
+    this._children.forEach(c => c._parent = this)
+  }
+
+  removeChild(node: Node) {
+    const index = this._children.indexOf(node);
+
+    if (index > -1) {
+      this._children.splice(index, 1);
+      node._parent = null;
+    }
+  }
+
+  removeAllChildren() {
+    this._children.forEach(c => c._parent = null);
+    this._children.length = 0;
+  }
+
+  replaceChild(newNode: Node, referenceNode: Node) {
+    const index = this._children.indexOf(referenceNode);
+
+    if (index > -1) {
+      this._children.splice(index, 1, newNode);
+      newNode._parent = this;
+      referenceNode._parent = null;
+    }
+  }
+
+  insertBefore(newNode: Node, referenceNode: Node | null) {
+    newNode._parent = this;
+
+    if (referenceNode == null) {
+      this._children.push(newNode);
+      return;
+    }
+
+    const index = this._children.indexOf(referenceNode);
+
+    if (index > -1) {
+      this._children.splice(index, 0, newNode);
+    }
+  }
+
+  appendChild(newNode: Node) {
+    newNode._parent = this;
+    this._children.push(newNode);
+  }
+
+  spliceChildren(index: number, deleteCount: number, ...items: Node[]) {
+    const removedItems = this._children.splice(index, deleteCount, ...items);
+
+    removedItems.forEach(i => i._parent = null);
+    items.forEach(i => i._parent = this);
+
+    return removedItems;
+  }
+
+  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
+  }
+
+  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 (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);
+  }
+
+  walkDown(callback: (node: Node) => void) {
+    callback(this);
+    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,
-      this.name,
-      this.startIndex,
-      this.endIndex,
-      this.children.map((c) => c.clone()),
-      this.value
+      this._type,
+      this._name,
+      this._firstIndex,
+      this._lastIndex,
+      this._children.map((c) => c.clone()),
+      this._value
     );
   }
 
-  toString() {
-    return this.value;
+  toString(): string {
+    if (this._children.length === 0) {
+      return this._value;
+    }
+
+    return this._children.map(c => c.toString()).join("")
+  }
+
+  toCycleFreeObject(): CycleFreeNode {
+    return {
+      type: this._type,
+      name: this._name,
+      value: this.toString(),
+      firstIndex: this._firstIndex,
+      lastIndex: this._lastIndex,
+      startIndex: this.startIndex,
+      endIndex: this.endIndex,
+      children: this._children.map(c => c.toCycleFreeObject()),
+    }
+  }
+
+  toJson(space?: number): string {
+    return JSON.stringify(this.toCycleFreeObject(), null, space)
   }
 }

package/src/index.ts

@@ -1,38 +1,36 @@
-import Node from "./ast/Node";
-import Cursor from "./Cursor";
-import Regex from "./patterns/Regex";
-import And from "./patterns/And";
-import Literal from "./patterns/Literal";
-import LookAhead from "./patterns/LookAhead";
-import Not from "./patterns/Not";
-import Or from "./patterns/Or";
-import Repeat from "./patterns/Repeat";
-import ParseError from "./patterns/ParseError";
-import Pattern from "./patterns/Pattern";
-import Recursive from "./patterns/Recursive";
-import Reference from "./patterns/Reference";
-import Visitor from "./ast/Visitor";
-export { default as TextSuggester } from "./TextSuggester";
-export type {
-  SuggestionError,
-  SuggestionMatch,
-  SuggestionResult,
-  Token,
-} from "./TextSuggester";
+import { Node } from "./ast/Node";
+import { Cursor } from "./patterns/Cursor";
+import { Regex } from "./patterns/Regex";
+import { And } from "./patterns/And";
+import { Literal } from "./patterns/Literal";
+import { Not } from "./patterns/Not";
+import { Or } from "./patterns/Or";
+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,
-  Recursive,
   Reference,
-  Visitor,
-  LookAhead,
+  Regex,
+  Repeat,
 };