clarity-pattern-parser 11.0.21 → 11.0.23

package/dist/patterns/Sequence.d.ts

@@ -24,7 +24,8 @@ export declare class Sequence implements Pattern {
     parse(cursor: Cursor): Node | null;
     private tryToParse;
     private getLastValidNode;
-    private areRemainingPatternsOptional;
+    private _areAllPatternsOptional;
+    private _areRemainingPatternsOptional;
     private createNode;
     getTokens(): string[];
     getTokensAfter(childReference: Pattern): string[];

package/dist/patterns/generate_error_message.d.ts

@@ -0,0 +1,3 @@
+import { Cursor } from "./Cursor";
+import { Pattern } from "./Pattern";
+export declare function generateErrorMessage(pattern: Pattern, cursor: Cursor): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "11.0.21",
+  "version": "11.0.23",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",

package/src/grammar/Grammar.ts

@@ -8,11 +8,11 @@ import { Options } from "../patterns/Options";
 import { Not } from "../patterns/Not";
 import { Sequence } from "../patterns/Sequence";
 import { Repeat, RepeatOptions } from "../patterns/Repeat";
-import { AutoComplete } from "../intellisense/AutoComplete";
 import { Optional } from "../patterns/Optional";
 import { Context } from "../patterns/Context";
 import { Expression } from "../patterns/Expression";
 import { RightAssociated } from "../patterns/RightAssociated";
+import { generateErrorMessage } from "../patterns/generate_error_message";
 
 let anonymousIndexId = 0;
 
@@ -55,16 +55,12 @@ export class Grammar {
     private _originResource?: string | null;
     private _resolveImport: (resource: string, originResource: string | null) => Promise<GrammarFile>;
     private _parseContext: ParseContext;
-    private _autoComplete: AutoComplete;
 
     constructor(options: GrammarOptions = {}) {
         this._params = options?.params == null ? [] : options.params;
         this._originResource = options?.originResource == null ? null : options.originResource;
         this._resolveImport = options.resolveImport == null ? defaultImportResolver : options.resolveImport;
         this._parseContext = new ParseContext(this._params);
-        this._autoComplete = new AutoComplete(grammar, {
-            greedyPatternNames: ["spaces", "optional-spaces", "whitespace", "new-line"],
-        });
     }
 
     async import(path: string) {
@@ -113,22 +109,14 @@ export class Grammar {
     }
 
     private _tryToParse(expression: string): Node {
-        const { ast, cursor, options, isComplete } = this._autoComplete.suggestFor(expression);
-
-        if (!isComplete) {
-            const text = cursor?.text || "";
-            const index = options.reduce((num, o) => Math.max(o.startIndex, num), 0);
-            const foundText = text.slice(Math.max(index - 10, 0), index + 10);
-            const expectedTexts = "'" + options.map(o => {
-                const startText = text.slice(Math.max(o.startIndex - 10), o.startIndex);
-                return startText + o.text;
-            }).join("' or '") + "'";
-            const message = `[Parse Error] Found: '${foundText}', expected: ${expectedTexts}.`;
-            throw new Error(message);
+        const { ast, cursor } = grammar.exec(expression, true);
+
+        if (ast == null) {
+            const message = generateErrorMessage(grammar, cursor);
+            throw new Error(`[Invalid Grammar] ${message}`);
         }
 
-        // If it is complete it will always have a node. So we have to cast it.
-        return ast as Node;
+        return ast;
     }
 
     private _hasImports(ast: Node) {
@@ -291,9 +279,10 @@ export class Grammar {
         const firstChild = pattern.children[0];
         const lastChild = pattern.children[pattern.children.length - 1];
         const isLongEnough = pattern.children.length >= 2;
-        return (pattern.type === "sequence" && isLongEnough &&
-            (firstChild.name === name) ||
-            (lastChild.name === name));
+
+        return pattern.type === "sequence" && isLongEnough &&
+            (firstChild.name === name ||
+                lastChild.name === name);
     }
 
     private _buildPattern(node: Node): Pattern {

package/src/patterns/Literal.ts

@@ -94,6 +94,10 @@ export class Literal implements Pattern {
     let passed = false;
     const literalRuneLength = this._runes.length;
 
+    if (!cursor.hasNext){
+      return false;
+    }
+
     for (let i = 0; i < literalRuneLength; i++) {
       const literalRune = this._runes[i];
       const cursorRune = cursor.currentChar;

package/src/patterns/Reference.ts

@@ -86,6 +86,8 @@ export class Reference implements Pattern {
 
   private _cacheAncestors(id: string) {
     if (!this._cachedAncestors) {
+      this._cachedAncestors = true;
+
       let pattern: Pattern | null = this.parent;
 
       while (pattern != null) {
@@ -101,7 +103,7 @@ export class Reference implements Pattern {
     let depth = 0;
 
     for (let pattern of this._recursiveAncestors) {
-      if (pattern._firstIndex === this._firstIndex) {
+      if (pattern.startedOnIndex === this.startedOnIndex) {
         depth++;
 
         if (depth > 0) {

package/src/patterns/Sequence.test.ts

@@ -323,4 +323,15 @@ describe("Sequence", () => {
         expect(nextPatterns.length).toBe(0);
     });
 
+    test("All Patterns are Optional", () => {
+        const sequence = new Sequence("sequence", [
+            new Optional("optional-a", new Literal("a", "A")),
+            new Optional("optional-b", new Literal("b", "B"))
+        ]);
+        const result = sequence.exec("");
+
+        expect(result.ast).toBe(null);
+        expect(result.cursor.hasError).toBeFalsy();
+    });
+
 });

package/src/patterns/Sequence.ts

@@ -83,8 +83,8 @@ export class Sequence implements Pattern {
     this._firstIndex = cursor.index;
     this._nodes = [];
     const passed = this.tryToParse(cursor);
-
     if (passed) {
+
       const node = this.createNode(cursor);
 
       if (node !== null) {
@@ -121,7 +121,7 @@ export class Sequence implements Pattern {
             } else {
               // We are at the end of the text, it may still be valid, if all the
               // following patterns are optional.
-              if (this.areRemainingPatternsOptional(i)) {
+              if (this._areRemainingPatternsOptional(i)) {
                 passed = true;
                 break;
               }
@@ -139,7 +139,7 @@ export class Sequence implements Pattern {
         } else {
           // If we don't have any results from what we parsed then record error.
           const lastNode = this.getLastValidNode();
-          if (lastNode === null) {
+          if (lastNode === null && !this._areAllPatternsOptional()) {
             cursor.recordErrorAt(this._firstIndex, cursor.index, this);
             break;
           }
@@ -168,7 +168,11 @@ export class Sequence implements Pattern {
     return nodes[nodes.length - 1];
   }
 
-  private areRemainingPatternsOptional(fromIndex: number): boolean {
+  private _areAllPatternsOptional() {
+    return this._areRemainingPatternsOptional(-1);
+  }
+
+  private _areRemainingPatternsOptional(fromIndex: number): boolean {
     const startOnIndex = fromIndex + 1;
     const length = this._children.length;
 
@@ -185,6 +189,11 @@ export class Sequence implements Pattern {
   private createNode(cursor: Cursor): Node | null {
     const children = filterOutNull(this._nodes);
 
+    if (children.length === 0) {
+      cursor.moveTo(this._firstIndex);
+      return null;
+    }
+
     const lastIndex = children[children.length - 1].lastIndex;
 
     cursor.moveTo(lastIndex);

package/src/patterns/generate_error_message.ts

@@ -0,0 +1,33 @@
+import { Cursor } from "./Cursor";
+import { Pattern } from "./Pattern";
+
+export function generateErrorMessage(pattern: Pattern, cursor: Cursor) {
+    const furthestMatch = cursor.leafMatch;
+
+    if (furthestMatch == null || furthestMatch.node == null || furthestMatch.pattern == null) {
+        const suggestions = cleanSuggestions(pattern.getTokens()).join(", ");
+        return `Error at line 1, column 1. Hint: ${suggestions}`;
+    }
+
+    const endIndex = furthestMatch.node.endIndex;
+
+    if (endIndex === 0) {
+        const suggestions = cleanSuggestions(pattern.getTokens()).join(", ");
+        return `Error at line 1, column 1. Hint: ${suggestions}`;
+    }
+
+    const lastPattern = furthestMatch.pattern as Pattern;
+    const suggestions = cleanSuggestions(lastPattern.getTokens());
+    const strUpToError = cursor.getChars(0, endIndex);
+    const lines = strUpToError.split("\n");
+    const lastLine = lines[lines.length - 1];
+    const line = lines.length;
+    const column = lastLine.length;
+
+    return `Error at line ${line}, column ${column}. Hint: ${suggestions}`;
+
+}
+
+function cleanSuggestions(suggestions: string[]) {
+    return suggestions.map(s => s.trim()).filter(s => s.length > 0);
+}

package/src/query/query.test.ts

@@ -0,0 +1,174 @@
+import { Node } from "../ast/Node";
+import { $ } from "./query";
+
+function createNodeTree() {
+    const node = Node.createNode("node", "root", [
+        Node.createNode("node", "grand-parent", [
+            Node.createNode("node", "parent", [
+                Node.createValueNode("node", 'child', "1"),
+                Node.createValueNode("node", 'child', "2"),
+                Node.createValueNode("node", 'child', "3"),
+                Node.createValueNode("node", 'child', "4"),
+            ]),
+            Node.createNode("node", "parent", [
+                Node.createValueNode("node", 'child', "5"),
+                Node.createValueNode("node", 'child', "6"),
+                Node.createValueNode("node", 'child', "7"),
+                Node.createValueNode("node", 'child', "8"),
+            ]),
+            Node.createNode("node", "parent", [
+                Node.createValueNode("node", 'child', "9"),
+                Node.createValueNode("node", 'child', "10"),
+                Node.createValueNode("node", 'child', "11"),
+                Node.createValueNode("node", 'child', "12"),
+            ])
+        ]),
+        Node.createNode("node", "grand-parent", [
+            Node.createNode("node", "parent", [
+                Node.createValueNode("node", 'child', "13"),
+                Node.createValueNode("node", 'child', "14"),
+                Node.createValueNode("node", 'child', "15"),
+                Node.createValueNode("node", 'child', "16"),
+            ]),
+            Node.createNode("node", "parent", [
+                Node.createValueNode("node", 'child', "17"),
+                Node.createValueNode("node", 'child', "18"),
+                Node.createValueNode("node", 'child', "19"),
+                Node.createValueNode("node", 'child', "20"),
+            ]),
+            Node.createNode("node", "parent", [
+                Node.createValueNode("node", 'child', "21"),
+                Node.createValueNode("node", 'child', "22"),
+                Node.createValueNode("node", 'child', "23"),
+                Node.createValueNode("node", 'child', "24"),
+            ])
+        ])
+    ]);
+    node.normalize();
+    return node;
+}
+
+describe("Query", () => {
+    test("Construct", () => {
+        const root = createNodeTree();
+
+        const children = $(root, "child");
+        const result = children.toArray().map(n => n.value).join(",");
+
+        expect(result).toBe("1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24");
+    });
+
+    test("First", () => {
+        const root = createNodeTree();
+
+        const children = $(root, "child").first();
+        const result = children.toArray().map(n => n.value).join(",");
+
+        expect(result).toBe("1");
+    });
+
+    test("Last", () => {
+        const root = createNodeTree();
+
+        const children = $(root, "child").last();
+        const result = children.toArray().map(n => n.value).join(",");
+
+        expect(result).toBe("24");
+    });
+
+    test("Parent", () => {
+        const root = createNodeTree();
+
+        const children = $(root, "child").parent();
+        const result = children.toArray();
+
+        expect(result.length).toBe(6);
+        expect(result.map(n => n.value).join(",")).toBe("1234,5678,9101112,13141516,17181920,21222324");
+    });
+
+    test("Parents", () => {
+        const root = createNodeTree();
+
+        const children = $(root, "child").parents("grand-parent parent[value='1234']");
+        const result = children.toArray();
+
+        expect(result.length).toBe(1);
+        expect(result.map(n => n.value).join(",")).toBe("1234");
+    });
+
+    test("Filter", () => {
+        const root = createNodeTree();
+
+        const children = $(root, "parent").filter("grand-parent parent[value='1234']");
+        const result = children.toArray();
+
+        expect(result.length).toBe(1);
+        expect(result.map(n => n.value).join(",")).toBe("1234");
+    });
+
+    test("Not", () => {
+        const root = createNodeTree();
+
+        const children = $(root, "parent").not("grand-parent parent[value='1234']");
+        const result = children.toArray();
+
+        expect(result.length).toBe(5);
+        expect(result.map(n => n.value).join(",")).toBe("5678,9101112,13141516,17181920,21222324");
+    });
+
+    test("First Before", () => {
+        const root = createNodeTree();
+
+        $(root, "child").first().before(() => Node.createValueNode("node", "adopted-child", "0"));
+
+        const adoptedChild = root.find(n => n.name === "adopted-child");
+        const firstChild = root.find(n => n.value === "1");
+        expect(adoptedChild?.nextSibling()).toBe(firstChild);
+    });
+
+    test("Last After", () => {
+        const root = createNodeTree();
+
+        $(root, "child").last().after(() => Node.createValueNode("node", "adopted-child", "25"));
+
+        const adoptedChild = root.find(n => n.name === "adopted-child");
+        const lastChild = root.find(n => n.value === "24");
+        expect(adoptedChild?.previousSibling()).toBe(lastChild);
+    });
+
+    test("Append", () => {
+        const root = createNodeTree();
+
+        const parents = $(root, "parent").append((n) => {
+            const lastChild = n.children[n.children.length - 1];
+            const value = Number(lastChild.value) + 1;
+            return Node.createValueNode("node", "adopted-child", String(value));
+        }).toArray();
+
+        const haveFiveChildren = parents.every(n => n.children.length === 5);
+        expect(haveFiveChildren).toBeTruthy();
+        expect(parents.map(n => n.toString()).join(",")).toBe("12345,56789,910111213,1314151617,1718192021,2122232425");
+    });
+
+    test("Prepend", () => {
+        const root = createNodeTree();
+
+        const parents = $(root, "parent").prepend((n) => {
+            const firstChild = n.children[0];
+            const value = Number(firstChild.value) - 1;
+            return Node.createValueNode("node", "adopted-child", String(value));
+        }).toArray();
+
+        const haveFiveChildren = parents.every(n => n.children.length === 5);
+        expect(haveFiveChildren).toBeTruthy();
+        expect(parents.map(n => n.toString()).join(",")).toBe("01234,45678,89101112,1213141516,1617181920,2021222324");
+    });
+
+    test("ReplaceWith", () => {
+        const root = createNodeTree();
+
+        $(root, "child").replaceWith(() => Node.createValueNode("node","child","b"));
+
+        expect(root.toString()).toBe("bbbbbbbbbbbbbbbbbbbbbbbb");
+    });
+});

package/src/query/query.ts

@@ -1,41 +1,168 @@
+import { Node } from "../ast/Node";
+import { Selector } from "./selector";
+
 export class Query {
     private _context: Node[];
     private _prevQuery: Query | null;
 
-    constructor(context: Node[], selector?: string, prevQuery: Query | null = null) {
+    constructor(context: Node[], prevQuery: Query | null = null) {
         this._context = context;
         this._prevQuery = prevQuery;
+    }
 
-        if (selector != null) {
-            this.find(selector);
-        }
+    toArray() {
+        return this._context.slice();
+    }
+
+    // Modifiers
+    append(visitor: (node: Node) => Node) {
+        this._context.forEach(n => {
+            const parent = n.parent;
+
+            if (parent == null) {
+                return;
+            }
+            const newNode = visitor(n);
+            n.appendChild(newNode);
+        });
+
+        return this;
+    }
+
+    prepend(visitor: (node: Node) => Node) {
+        this._context.forEach(n => {
+            const parent = n.parent;
+
+            if (parent == null) {
+                return;
+            }
+            const newNode = visitor(n);
+            n.insertBefore(newNode, n.children[0]);
+        });
+
+        return this;
+    }
+
+    after(visitor: (node: Node) => Node) {
+        this._context.forEach(n => {
+            const parent = n.parent;
+
+            if (parent == null) {
+                return;
+            }
+            const index = parent.findChildIndex(n);
+            const newNode = visitor(n);
+
+            parent.spliceChildren(index + 1, 0, newNode);
+        });
+
+        return this;
+    }
+
+    before(visitor: (node: Node) => Node) {
+        this._context.forEach(n => {
+            const parent = n.parent;
+
+            if (parent == null) {
+                return;
+            }
+            const index = parent.findChildIndex(n);
+            const newNode = visitor(n);
+
+            parent.spliceChildren(index, 0, newNode);
+        });
+
+        return this;
+    }
+
+    replaceWith(visitor: (node: Node) => Node) {
+        this._context.forEach(n => {
+            const newNode = visitor(n);
+            n.replaceWith(newNode);
+        });
+
+        return this;
+    }
+
+    compact() {
+        this._context.forEach(n => {
+            n.compact();
+        });
+
+        return this;
+    }
+
+    remove() {
+        this._context.forEach(n => {
+            n.remove();
+        });
+
+        return this;
     }
 
+    // Filters from the currently matched nodes
     slice(start: number, end?: number) {
         return new Query(this._context.slice(start, end));
     }
 
-    // Modifiers
-    append() { }
+    filter(selectorString: string) {
+        const selector = new Selector(selectorString);
+        const newContext = selector.filter(this._context);
+
+        return new Query(newContext, this);
+    }
 
-    prepend() { }
+    // Selects out of all descedants of currently matched nodes
+    find(selectorString: string) {
+        const selector = new Selector(selectorString);
+        const newContext = selector.find(this._context);
 
-    after() { }
+        return new Query(newContext, this);
+    }
 
-    before() { }
+    // Remove nodes from the set of matched nodes.
+    not(selectorString: string) {
+        const selector = new Selector(selectorString);
+        const newContext = selector.not(this._context);
 
+        return new Query(newContext, this);
+    }
 
-    // Refiners
-    filter(selector: string) { }
+    // Select the parent of currently matched nodes
+    parent() {
+        const parents = this._context.map(n => n.parent);
+        const result = new Set<Node>();
+        parents.forEach((n) => {
+            if (n != null) {
+                result.add(n);
+            }
+        });
+
+        return new Query(Array.from(result), this);
+    }
 
-    find(selector: string) { }
+    // Select the ancestors of currently matched nodes
+    parents(selectorString: string) {
+        const selector = new Selector(selectorString);
+        const newContext = selector.parents(this._context);
 
-    not(selector: string) { }
+        const result = new Set<Node>();
+        newContext.forEach((n) => {
+            if (n != null) {
+                result.add(n);
+            }
+        });
 
-    parent() { }
+        return new Query(Array.from(result), this);
+    }
 
-    parents(selector: string) { }
+    first() {
+        return new Query(this._context.slice(0, 1), this);
+    }
 
+    last() {
+        return new Query(this._context.slice(-1), this);
+    }
 
     // Pop query stack
     end() {
@@ -45,4 +172,13 @@ export class Query {
         return this;
     }
 
-}
+}
+
+export function $(root: Node, selector?: string) {
+    if (selector == null) {
+        return new Query([root]);
+    } else {
+        return new Query([root]).find(selector);
+    }
+
+}