clarity-pattern-parser 11.0.1 → 11.0.3

package/dist/patterns/Context.d.ts

@@ -10,7 +10,6 @@ export declare class Context implements Pattern {
     private _children;
     private _pattern;
     private _patterns;
-    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;

package/dist/patterns/RightAssociatedPattern.d.ts

@@ -0,0 +1,31 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
+import { Pattern } from "./Pattern";
+export declare class RightAssociatedPattern implements Pattern {
+    private _id;
+    private _type;
+    private _name;
+    private _parent;
+    private _children;
+    get id(): string;
+    get type(): string;
+    get name(): string;
+    get parent(): Pattern | null;
+    set parent(pattern: Pattern | null);
+    get children(): Pattern[];
+    get startedOnIndex(): number;
+    constructor(pattern: Pattern);
+    parse(cursor: Cursor): Node | null;
+    exec(text: string, record?: boolean | undefined): ParseResult;
+    test(text: string, record?: boolean | undefined): boolean;
+    clone(_name?: string | undefined): Pattern;
+    getTokens(): string[];
+    getTokensAfter(_childReference: Pattern): string[];
+    getNextTokens(): string[];
+    getPatterns(): Pattern[];
+    getPatternsAfter(_childReference: Pattern): Pattern[];
+    getNextPatterns(): Pattern[];
+    find(predicate: (pattern: Pattern) => boolean): Pattern | null;
+    isEqual(pattern: Pattern): boolean;
+}

package/package.json

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

package/src/grammar/Grammar.test.ts

@@ -584,4 +584,15 @@ describe("Grammar", () => {
         expect(result).toBe(result);
     });
 
+    test("Expression Pattern With Right Association", () => {
+        const { expression } = patterns`
+            variables = "a" | "b" | "c" | "d" | "e"
+            ternary = expression + " ? " + expression + " : " + expression
+            expression = ternary right | variables
+        `;
+        let result = expression.exec("a ? b : c ? d : e");
+        debugger;
+        expect(result).toBe(result);
+    });
+
 });

package/src/grammar/Grammar.ts

@@ -11,7 +11,8 @@ import { Repeat, RepeatOptions } from "../patterns/Repeat";
 import { AutoComplete } from "../intellisense/AutoComplete";
 import { Optional } from "../patterns/Optional";
 import { Context } from "../patterns/Context";
-import {ExpressionPattern} from "../patterns/ExpressionPattern";
+import { ExpressionPattern } from "../patterns/ExpressionPattern";
+import { RightAssociatedPattern } from "../patterns/RightAssociatedPattern";
 
 let anonymousIndexId = 0;
 
@@ -248,14 +249,22 @@ export class Grammar {
     private _buildOptions(name: string, node: Node) {
         const patternNodes = node.children.filter(n => n.name !== "default-divider" && n.name !== "greedy-divider");
         const isGreedy = node.find(n => n.name === "greedy-divider") != null;
-        const patterns = patternNodes.map(n => this._buildPattern(n));
-        const hasRecursivePattern = patterns.some(p=>this._isRecursive(name, p));
+        const patterns = patternNodes.map(n => {
+            const rightAssociated = n.find(n => n.name === "right-associated");
+            if (rightAssociated != null) {
+                return new RightAssociatedPattern(this._buildPattern(n.children[0]));
+            } else {
+                return this._buildPattern(n.children[0]);
+            }
 
-        if (hasRecursivePattern && !isGreedy){
+        });
+        
+        const hasRecursivePattern = patterns.some(p => this._isRecursive(name, p));
+        if (hasRecursivePattern && !isGreedy) {
             try {
                 const expression = new ExpressionPattern(name, patterns);
                 return expression;
-            } catch{}
+            } catch { }
         }
 
         const or = new Options(name, patterns, isGreedy);
@@ -271,10 +280,16 @@ export class Grammar {
     }
 
     private _isRecursivePattern(name: string, pattern: Pattern) {
-        return pattern.type === "sequence" &&
-            pattern.children[0].type === "reference" &&
-            pattern.children[0].name === name &&
-            pattern.children.length > 2;
+        if (pattern.children.length === 0){
+            return false;
+        }
+
+        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.type === "reference" && firstChild.name === name) ||
+            (lastChild.type === "reference" && lastChild.name === name);
     }
 
     private _buildPattern(node: Node): Pattern {

package/src/grammar/patterns/optionsLiteral.ts

@@ -3,11 +3,17 @@ import { Regex } from "../../patterns/Regex";
 import { name } from "./name";
 import { anonymousPattern } from "./anonymousPattern";
 import { Options } from "../../patterns/Options";
+import { Sequence } from "../../patterns/Sequence";
+import { Optional } from "../../patterns/Optional";
+import { Literal } from "../../patterns/Literal";
 
 const patternName = name.clone("pattern-name");
 patternName.setTokens(["[PATTERN_NAME]"]);
 
-const patterns = new Options("options-patterns", [patternName, anonymousPattern]);
+const patterns = new Sequence("patterns", [
+    new Options("options-patterns", [patternName, anonymousPattern]),
+    new Optional("optional-right-associated", new Literal("right-associated", " right"))
+]);
 const defaultDivider = new Regex("default-divider", "\\s*[|]\\s*");
 defaultDivider.setTokens(["|"]);
 

package/src/patterns/Context.ts

@@ -14,8 +14,6 @@ export class Context implements Pattern {
     private _pattern: Pattern;
     private _patterns: Record<string, Pattern>;
 
-    shouldCompactAst = false;
-
     get id(): string {
         return this._id;
     }
@@ -82,7 +80,6 @@ export class Context implements Pattern {
     clone(name = this._name): Pattern {
         const clone = new Context(name, this._pattern, Object.values(this._patterns));
         clone._id = this._id;
-        clone.shouldCompactAst = this.shouldCompactAst;
         return clone;
     }
 

package/src/patterns/ExpressionPattern.ts

@@ -416,8 +416,8 @@ export class ExpressionPattern implements Pattern {
 
                 break;
             } else {
-                cursor.resolveError();
                 cursor.moveTo(onIndex);
+                cursor.resolveError();
             }
         }
 

package/src/patterns/PrecedenceTree.ts

@@ -147,7 +147,7 @@ export class PrecedenceTree {
         let node = this._atomNode;
 
         if (this._prefixNode != null && this._atomNode != null) {
-            node = this._prefixNode;
+            node = this._prefixNode.findRoot();
             this._prefixPlaceholder.replaceWith(this._atomNode);
         }
 

package/src/patterns/RightAssociatedPattern.ts

@@ -12,8 +12,6 @@ export class RightAssociatedPattern implements Pattern {
     private _parent: Pattern | null;
     private _children: Pattern[];
 
-    shouldCompactAst = false;
-
     get id(): string {
         return this._id;
     }