clarity-pattern-parser 10.1.26 → 10.2.1

package/src/patterns/ExpressionPattern.ts

@@ -3,10 +3,16 @@ import { Cursor } from "./Cursor";
 import { DepthCache } from "./DepthCache";
 import { ParseResult } from "./ParseResult";
 import { Pattern } from "./Pattern";
+import { findPattern } from "./findPattern";
+import { Sequence } from "./Sequence";
 
 let indexId = 0;
 const depthCache = new DepthCache();
 
+function createNode(name: string, children: Node[]) {
+    return new Node("expression", name, 0, 0, children, "");
+}
+
 enum Association {
     left = 0,
     right = 1,
@@ -17,13 +23,15 @@ export class ExpressionPattern implements Pattern {
     private _type: string;
     private _name: string;
     private _parent: Pattern | null;
-    private _token: string;
     private _firstIndex: number;
+    private _originalPatterns: Pattern[];
     private _patterns: Pattern[];
     private _unaryPatterns: Pattern[];
     private _binaryPatterns: Pattern[];
+    private _recursivePatterns: Pattern[];
+    private _recursiveNames: string[];
     private _binaryAssociation: Association[];
-    private _precedenceMap: Record<string, number>; 
+    private _precedenceMap: Record<string, number>;
     private _binaryNames: string[];
 
     get id(): string {
@@ -38,10 +46,6 @@ export class ExpressionPattern implements Pattern {
         return this._name;
     }
 
-    get token(): string {
-        return this._token;
-    }
-
     get parent(): Pattern | null {
         return this._parent;
     }
@@ -54,6 +58,18 @@ export class ExpressionPattern implements Pattern {
         return this._patterns;
     }
 
+    get unaryPatterns(): readonly Pattern[] {
+        return this._unaryPatterns;
+    }
+
+    get binaryPatterns(): readonly Pattern[] {
+        return this._binaryPatterns;
+    }
+
+    get recursivePatterns(): readonly Pattern[] {
+        return this._recursivePatterns;
+    }
+
     constructor(name: string, patterns: Pattern[]) {
         if (patterns.length === 0) {
             throw new Error("Need at least one pattern with an 'expression' pattern.");
@@ -62,19 +78,28 @@ export class ExpressionPattern implements Pattern {
         this._id = `expression-${indexId++}`;
         this._type = "expression";
         this._name = name;
+        this._parent = null;
+        this._firstIndex = -1;
         this._unaryPatterns = [];
         this._binaryPatterns = [];
+        this._recursivePatterns = [];
+        this._recursiveNames = [];
+        this._binaryNames = [];
+        this._binaryAssociation = [];
         this._precedenceMap = {};
-
-        this._patterns.forEach(p => p.parent = this);
+        this._originalPatterns = patterns;
         this._patterns = this._organizePatterns(patterns);
+
+        if (this._unaryPatterns.length === 0) {
+            throw new Error("Need at least one operand pattern with an 'expression' pattern.");
+        }
     }
 
     private _organizePatterns(patterns: Pattern[]) {
         const finalPatterns: Pattern[] = [];
         patterns.forEach((pattern) => {
             if (this._isBinary(pattern)) {
-                const binaryName = pattern.name;
+                const binaryName = this._extractName(pattern);
                 const clone = this._extractDelimiter(pattern).clone();
                 clone.parent = this;
 
@@ -89,6 +114,14 @@ export class ExpressionPattern implements Pattern {
                 }
 
                 finalPatterns.push(clone);
+            } else if (this._isRecursive(pattern)) {
+                const name = this._extractName(pattern);
+                const tail = this._extractRecursiveTail(pattern);
+                tail.parent = this;
+
+                this._recursivePatterns.push(tail);
+                this._recursiveNames.push(name);
+                finalPatterns.push(tail);
             } else {
                 const clone = pattern.clone();
                 clone.parent = this;
@@ -118,10 +151,43 @@ export class ExpressionPattern implements Pattern {
             pattern.children.length === 3;
     }
 
-    private _extractDelimiter(pattern) {
+    private _extractDelimiter(pattern: Pattern) {
+        if (pattern.type === "right-associated") {
+            return pattern.children[0].children[1];
+        }
         return pattern.children[1];
     }
 
+    private _extractName(pattern: Pattern) {
+        if (pattern.type === "right-associated") {
+            return pattern.children[0].name;
+        }
+
+        return pattern.name;
+    }
+
+    private _isRecursive(pattern: Pattern) {
+        if (pattern.type === "right-associated" && this._isRecursivePattern(pattern.children[0])) {
+            return true;
+        }
+
+        return this._isRecursivePattern(pattern);
+    }
+
+    private _isRecursivePattern(pattern: Pattern) {
+        return pattern.type === "sequence" &&
+            pattern.children[0].type === "reference" &&
+            pattern.children[0].name === this.name &&
+            pattern.children.length > 2;
+    }
+
+    private _extractRecursiveTail(pattern: Pattern) {
+        if (pattern.type === "right-associated") {
+            return new Sequence(`${pattern.children[0].name}-tail`, pattern.children[0].children.slice(1));
+        }
+        return new Sequence(`${pattern.name}-tail`, pattern.children.slice(1));
+    }
+
     parse(cursor: Cursor): Node | null {
         // This is a cache to help with speed
         this._firstIndex = cursor.index;
@@ -143,103 +209,278 @@ export class ExpressionPattern implements Pattern {
     }
 
     private _tryToParse(cursor: Cursor): Node | null {
+        if (depthCache.getDepth(this._id, this._firstIndex) > 2) {
+            cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
+            return null;
+        }
+
         let lastUnaryNode: Node | null = null;
         let lastBinaryNode: Node | null = null;
         let onIndex = cursor.index;
-        
-        while (true) {
+
+        outer: while (true) {
             onIndex = cursor.index;
 
             for (let i = 0; i < this._unaryPatterns.length; i++) {
                 cursor.moveTo(onIndex);
 
                 const pattern = this._unaryPatterns[i];
-                lastUnaryNode = pattern.parse(cursor);
+                const node = pattern.parse(cursor);
+
+                if (node != null) {
+                    lastUnaryNode = node;
+                    break;
+                } else {
+                    lastUnaryNode = null;
+                    cursor.resolveError();
+                }
             }
-            
-            const canContinue = cursor.hasNext();
 
-            // if (canContinue) {
-            //     cursor.next();
-            // } else if (!canContinue && astStack.length > 1) {
-                
-            // } else if (!canContinue && astStack.length === 1){
-            //     return astStack[0];
-            // }
+            if (lastUnaryNode == null) {
+                break;
+            }
+
+            if (cursor.hasNext()) {
+                cursor.next();
+            } else {
+                if (lastBinaryNode != null && lastUnaryNode != null) {
+                    lastBinaryNode.appendChild(lastUnaryNode);
+                }
+                break;
+            }
 
             onIndex = cursor.index;
 
+            for (let i = 0; i < this._recursivePatterns.length; i++) {
+                const pattern = this._recursivePatterns[i];
+                const node = pattern.parse(cursor);
+
+                if (node != null) {
+                    if (lastBinaryNode != null && lastUnaryNode != null) {
+                        lastBinaryNode.appendChild(lastUnaryNode);
+                    }
+
+                    const frontExpression = lastBinaryNode == null ? lastUnaryNode as Node : lastBinaryNode.findRoot();
+                    const name = this._recursiveNames[i];
+                    const recursiveNode = createNode(name, [frontExpression, ...node.children]);
+
+                    recursiveNode.normalize(this._firstIndex);
+                    return recursiveNode;
+                }
+
+                cursor.moveTo(onIndex);
+            }
+
+            onIndex = cursor.index;
             for (let i = 0; i < this._binaryPatterns.length; i++) {
                 cursor.moveTo(onIndex);
-                const name = this._binaryNames[i];
-                const pattern = this._binaryPatterns[i];
 
-                const node = pattern.parse(cursor);
+                const pattern = this._binaryPatterns[i];
+                const name = this._binaryNames[i];
+                const delimiterNode = pattern.parse(cursor);
+
+                if (delimiterNode == null) {
+                    if (i === this._binaryPatterns.length - 1) {
+                        if (lastBinaryNode == null) {
+                            return lastUnaryNode;
+                        } else if (lastUnaryNode != null) {
+                            lastBinaryNode.appendChild(lastUnaryNode);
+                        }
+                    }
+                    continue;
+                }
 
-                // if (node != null) {
-                //     binaryIndex = i;
+                if (lastBinaryNode == null && lastUnaryNode != null && delimiterNode != null) {
+                    const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                    lastBinaryNode = node;
+                } else if (lastBinaryNode != null && lastUnaryNode != null && delimiterNode != null) {
+                    const precedence = this._precedenceMap[name];
+                    const lastPrecendece = lastBinaryNode == null ? 0 : this._precedenceMap[lastBinaryNode.name];
+                    const association = this._binaryAssociation[i];
+
+                    if (precedence === lastPrecendece && association === Association.right) {
+                        const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                        lastBinaryNode.appendChild(node);
+                        lastBinaryNode = node;
+                    } else if (precedence === lastPrecendece) {
+                        const node = createNode(name, []);
+
+                        lastBinaryNode.replaceWith(node);
+                        lastBinaryNode.appendChild(lastUnaryNode);
+                        node.append(lastBinaryNode, delimiterNode);
+                        lastBinaryNode = node;
+                    } else if (precedence > lastPrecendece) {
+                        let ancestor = lastBinaryNode.parent;
+                        let root: Node | null = lastBinaryNode;
+
+                        while(ancestor != null){
+                            const nodePrecedence = this._precedenceMap[ancestor.name];
+
+                            if (nodePrecedence > precedence){
+                                break;
+                            }
+                            root = ancestor;
+                            ancestor = ancestor.parent;
+                        }
+
+                        lastBinaryNode.appendChild(lastUnaryNode);
+
+                        if (root != null) {
+                            const node = createNode(name, []);
+                            root.replaceWith(node);
+                            node.append(root, delimiterNode);
+                            
+                            lastBinaryNode = node;
+                        } else {
+                            const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                            lastBinaryNode = node;
+                        }
+
+                    } else {
+                        const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                        lastBinaryNode.appendChild(node);
+                        lastBinaryNode = node;
+                    }
 
-                //     const binaryNode = Node.createNode(name, []);
-                //     association = this._binaryAssociation[i];
+                }
 
-                //     if (association === Association.left) {
-                //         if (nodeToAppendTo != null){
-                //             nodeToAppendTo = binaryNode;
-                //         } else {
-                //             nodeToAppendTo.
-                //         }
-                //      } else {
+                if (cursor.hasNext()) {
+                    cursor.next();
+                } else {
+                    break outer;
+                }
 
-                //     }
-                // }
+                break;
+            }
 
+            if (lastBinaryNode == null){
+                break;
             }
         }
 
-        return null;
-    }
+        if (lastBinaryNode == null) {
+            return lastUnaryNode;
+        } else {
+            const root = lastBinaryNode.findAncestor(n => n.parent == null) as Node || lastBinaryNode;
+            if (lastBinaryNode.children.length < 3) {
+                lastBinaryNode.remove();
+
+                if (lastBinaryNode === root) {
+                    return lastUnaryNode;
+                }
+            }
 
-    exec(text: string, record?: boolean | undefined): ParseResult {
-        throw new Error("Method not implemented.");
+            root.normalize(this._firstIndex);
+            return root;
+        }
     }
 
-    test(text: string, record?: boolean | undefined): boolean {
-        throw new Error("Method not implemented.");
+    test(text: string) {
+        const cursor = new Cursor(text);
+        const ast = this.parse(cursor);
+
+        return ast?.value === text;
     }
 
-    clone(name?: string | undefined): Pattern {
-        throw new Error("Method not implemented.");
+    exec(text: string, record = false): ParseResult {
+        const cursor = new Cursor(text);
+        record && cursor.startRecording();
+
+        const ast = this.parse(cursor);
+
+        return {
+            ast: ast?.value === text ? ast : null,
+            cursor
+        };
     }
 
     getTokens(): string[] {
-        throw new Error("Method not implemented.");
+        return this.unaryPatterns.map(p => p.getTokens()).flat();
     }
 
     getTokensAfter(childReference: Pattern): string[] {
-        throw new Error("Method not implemented.");
+        if (this.unaryPatterns.indexOf(childReference)) {
+            const recursiveTokens = this._recursivePatterns.map(p => p.getTokens()).flat();
+            const binaryTokens = this._binaryPatterns.map(p => p.getTokens()).flat();
+
+            return [...recursiveTokens, ...binaryTokens];
+        }
+
+        if (this.recursivePatterns.indexOf(childReference)) {
+            return this._binaryPatterns.map(p => p.getTokens()).flat();
+        }
+
+        if (this.binaryPatterns.indexOf(childReference)) {
+            const unaryTokens = this._unaryPatterns.map(p => p.getTokens()).flat();
+
+            if (this._parent != null) {
+                const nextTokens = this._parent.getTokensAfter(this);
+                return [...unaryTokens, ...nextTokens];
+            }
+
+            return unaryTokens;
+        }
+
+        return [];
     }
 
     getNextTokens(): string[] {
-        throw new Error("Method not implemented.");
+        if (this._parent == null) {
+            return [];
+        }
+
+        return this._parent.getTokensAfter(this);
     }
 
     getPatterns(): Pattern[] {
-        throw new Error("Method not implemented.");
+        return this.unaryPatterns.map(p => p.getPatterns()).flat();
     }
 
     getPatternsAfter(childReference: Pattern): Pattern[] {
-        throw new Error("Method not implemented.");
+        if (this.unaryPatterns.indexOf(childReference)) {
+            const recursivePatterns = this._recursivePatterns.map(p => p.getPatterns()).flat();
+            const binaryPatterns = this._binaryPatterns.map(p => p.getPatterns()).flat();
+
+            return [...recursivePatterns, ...binaryPatterns];
+        }
+
+        if (this.recursivePatterns.indexOf(childReference)) {
+            return this._binaryPatterns.map(p => p.getPatterns()).flat();
+        }
+
+        if (this.binaryPatterns.indexOf(childReference)) {
+            const unaryPatterns = this._unaryPatterns.map(p => p.getPatterns()).flat();
+
+            if (this._parent != null) {
+                const nextPatterns = this._parent.getPatternsAfter(this);
+                return [...unaryPatterns, ...nextPatterns];
+            }
+
+            return unaryPatterns;
+        }
+
+        return [];
     }
 
     getNextPatterns(): Pattern[] {
-        throw new Error("Method not implemented.");
+        if (this._parent == null) {
+            return [];
+        }
+
+        return this._parent.getPatternsAfter(this);
     }
 
-    find(predicate: (pattern: Pattern) => boolean): Pattern | null {
-        throw new Error("Method not implemented.");
+    find(predicate: (p: Pattern) => boolean): Pattern | null {
+        return findPattern(this, predicate);
     }
 
-    isEqual(pattern: Pattern): boolean {
-        throw new Error("Method not implemented.");
+    clone(name = this._name): Pattern {
+        const clone = new ExpressionPattern(name, this._originalPatterns);
+        clone._id = this._id;
+        return clone;
     }
-}
+
+    isEqual(pattern: ExpressionPattern): boolean {
+        return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+    }
+}

package/src/patterns/Options.ts

@@ -111,7 +111,6 @@ export class Options implements Pattern {
 
   private _tryToParse(cursor: Cursor): Node | null {
     if (depthCache.getDepth(this._id, this._firstIndex) > 2) {
-      cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
       return null;
     }
 

package/src/patterns/RightAssociatedPattern.ts

@@ -6,13 +6,25 @@ import { Pattern } from "./Pattern";
 let indexId = 0;
 
 export class RightAssociatedPattern implements Pattern {
-    readonly id: string;
-    readonly type: string;
-    readonly name: string;
+    private _id: string;
+    private _type: string;
+    private _name: string;
     private _parent: Pattern | null;
-    readonly children: Pattern[];
+    private _children: Pattern[];
 
-    get parent() {
+    get id(): string {
+        return this._id;
+    }
+
+    get type(): string {
+        return this._type;
+    }
+
+    get name(): string {
+        return this._name;
+    }
+
+    get parent(): Pattern | null {
         return this._parent;
     }
 
@@ -20,12 +32,16 @@ export class RightAssociatedPattern implements Pattern {
         this._parent = pattern;
     }
 
+    get children(): Pattern[] {
+        return this._children;
+    }
+
     constructor(pattern: Pattern) {
-        this.id = `right-associated-${indexId++}`;
-        this.type = "right-associated";
-        this.name = "";
-        this.parent = null;
-        this.children = [pattern];
+        this._id = `right-associated-${indexId++}`;
+        this._type = "right-associated";
+        this._name = "";
+        this._parent = null;
+        this._children = [pattern.clone()];
     }
 
     parse(cursor: Cursor): Node | null {
@@ -41,7 +57,9 @@ export class RightAssociatedPattern implements Pattern {
     }
 
     clone(_name?: string | undefined): Pattern {
-        return new RightAssociatedPattern(this.children[0]);
+        const clone = new RightAssociatedPattern(this.children[0]);
+        clone._id = this._id;
+        return clone;
     }
 
     getTokens(): string[] {