clarity-pattern-parser 10.1.26 → 10.2.1

package/dist/patterns/ExpressionPattern.d.ts

@@ -0,0 +1,51 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
+import { Pattern } from "./Pattern";
+export declare class ExpressionPattern implements Pattern {
+    private _id;
+    private _type;
+    private _name;
+    private _parent;
+    private _firstIndex;
+    private _originalPatterns;
+    private _patterns;
+    private _unaryPatterns;
+    private _binaryPatterns;
+    private _recursivePatterns;
+    private _recursiveNames;
+    private _binaryAssociation;
+    private _precedenceMap;
+    private _binaryNames;
+    get id(): string;
+    get type(): string;
+    get name(): string;
+    get parent(): Pattern | null;
+    set parent(pattern: Pattern | null);
+    get children(): Pattern[];
+    get unaryPatterns(): readonly Pattern[];
+    get binaryPatterns(): readonly Pattern[];
+    get recursivePatterns(): readonly Pattern[];
+    constructor(name: string, patterns: Pattern[]);
+    private _organizePatterns;
+    private _isBinary;
+    private _isBinaryPattern;
+    private _extractDelimiter;
+    private _extractName;
+    private _isRecursive;
+    private _isRecursivePattern;
+    private _extractRecursiveTail;
+    parse(cursor: Cursor): Node | null;
+    private _tryToParse;
+    test(text: string): boolean;
+    exec(text: string, record?: boolean): ParseResult;
+    getTokens(): string[];
+    getTokensAfter(childReference: Pattern): string[];
+    getNextTokens(): string[];
+    getPatterns(): Pattern[];
+    getPatternsAfter(childReference: Pattern): Pattern[];
+    getNextPatterns(): Pattern[];
+    find(predicate: (p: Pattern) => boolean): Pattern | null;
+    clone(name?: string): Pattern;
+    isEqual(pattern: ExpressionPattern): boolean;
+}

package/package.json

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

package/src/ast/Node.ts

@@ -183,6 +183,17 @@ export class Node {
     return this.findAll(predicate)[0] || null;
   }
 
+  findRoot() {
+    let pattern: Node | null = this;
+
+    while (true) {
+      if (pattern.parent == null) {
+        return pattern;
+      }
+      pattern = pattern.parent;
+    }
+  }
+
   findAll(predicate: (node: Node) => boolean): Node[] {
     const matches: Node[] = [];
 
@@ -284,7 +295,7 @@ export class Node {
     if (this.children.length === 0) {
       length = this._value.length;
     } else {
-      length = this.children.reduce((acc, c) => acc + c.normalize(acc + startIndex), startIndex);
+      length = this.children.reduce((acc, c) => acc + c.normalize(acc + startIndex), startIndex) - startIndex;
     }
 
     this._firstIndex = startIndex;

package/src/grammar/Grammar.test.ts

@@ -9,6 +9,7 @@ import { Repeat } from "../patterns/Repeat";
 import { Grammar } from "./Grammar";
 import { Optional } from "../patterns/Optional";
 import { Context } from "../patterns/Context";
+import { patterns } from "./patterns";
 
 describe("Grammar", () => {
     test("Literal", () => {
@@ -569,4 +570,18 @@ describe("Grammar", () => {
         const result = fullname.exec("John  Doe");
         expect(result?.ast?.value).toBe("John  Doe");
     });
+
+    test("Expression Pattern", ()=>{
+        const {variables, expression} = patterns`
+            variables = "a" | "b" | "c"
+            ternary = expression + " ? " + expression + " : " + expression
+            expression = ternary | variables
+
+            bad-ternary = bad-expression + " ? " + bad-expression + " : " + bad-expression
+            bad-expression = bad-ternary | bad-ternary
+        `;
+        let result = expression.exec("a ? b : c");
+        debugger;
+        expect(result).toBe(result);
+    });
 });

package/src/grammar/Grammar.ts

@@ -11,6 +11,7 @@ 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";
 
 let anonymousIndexId = 0;
 
@@ -248,11 +249,34 @@ export class Grammar {
         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 or = new Options(name, patterns, isGreedy);
+        const hasRecursivePattern = patterns.some(p=>this._isRecursive(name, p));
+
+        if (hasRecursivePattern && !isGreedy){
+            try {
+                const expression = new ExpressionPattern(name, patterns);
+                return expression;
+            } catch{}
+        }
 
+        const or = new Options(name, patterns, isGreedy);
         return or;
     }
 
+    private _isRecursive(name: string, pattern: Pattern) {
+        if (pattern.type === "right-associated" && this._isRecursivePattern(name, pattern.children[0])) {
+            return true;
+        }
+
+        return this._isRecursivePattern(name, pattern);
+    }
+
+    private _isRecursivePattern(name: string, pattern: Pattern) {
+        return pattern.type === "sequence" &&
+            pattern.children[0].type === "reference" &&
+            pattern.children[0].name === name &&
+            pattern.children.length > 2;
+    }
+
     private _buildPattern(node: Node): Pattern {
         const type = node.name;
         const name = `anonymous-pattern-${anonymousIndexId++}`;

package/src/index.ts

@@ -19,6 +19,7 @@ import { ParseResult } from "./patterns/ParseResult";
 import { grammar } from "./grammar/patterns/grammar";
 import { patterns } from "./grammar/patterns";
 import { Context } from "./patterns/Context";
+import { ExpressionPattern } from "./patterns/ExpressionPattern";
 
 export {
   Node,
@@ -32,6 +33,7 @@ export {
   CursorHistory,
   Match,
   Context,
+  ExpressionPattern,
   Literal,
   Not,
   Options,

package/src/patterns/ExpressionPattern.test.ts

@@ -0,0 +1,132 @@
+import { Options } from "./Options";
+import { Literal } from './Literal';
+import { ExpressionPattern } from './ExpressionPattern';
+import { Reference } from "./Reference";
+import { Sequence } from './Sequence';
+import { Regex } from './Regex';
+import { Optional } from "./Optional";
+import { AutoComplete } from "../intellisense/AutoComplete";
+import { RightAssociatedPattern } from "./RightAssociatedPattern";
+
+function createExpressionPattern() {
+    const spaces = new Regex("spaces", "\\s+");
+    spaces.setTokens([" "]);
+
+    const optionalSpaces = new Optional("optional-spaces", spaces);
+
+    const variables = new Options("variables", [
+        new Literal("a", "a"),
+        new Literal("b", "b"),
+        new Literal("c", "c"),
+        new Literal("d", "d"),
+        new Literal("e", "e"),
+    ]);
+
+    const mulDivOperator = new Options("mult-div", [
+        new Literal("mult", " * "),
+        new Literal("div", " / "),
+    ]);
+
+    const addSubOperator = new Options("add-sub", [
+        new Literal("add", " + "),
+        new Literal("sub", " - "),
+    ]);
+
+    const boolOperator = new Options("and-or", [
+        new Literal("and", " && "),
+        new Literal("or", " || "),
+    ]);
+
+    const group = new Sequence("group", [
+        new Literal("open-paren", "("),
+        optionalSpaces,
+        new Reference("expression"),
+        optionalSpaces,
+        new Literal("close-paren", ")"),
+    ]);
+
+    const ternary = new Sequence("ternary", [
+        new Reference("expression"),
+        optionalSpaces,
+        new Literal("question-mark", "?"),
+        optionalSpaces,
+        new Reference("expression"),
+        optionalSpaces,
+        new Literal("colon", ":"),
+        optionalSpaces,
+        new Reference("expression"),
+    ]);
+
+    const multDivExpression = new Sequence("mult-div-expression", [
+        new Reference("expression"),
+        mulDivOperator,
+        new Reference("expression"),
+    ]);
+
+    const addSubExpression = new Sequence("add-sub-expression", [
+        new Reference("expression"),
+        addSubOperator,
+        new Reference("expression"),
+    ]);
+
+    const boolExpression = new Sequence("bool-expression", [
+        new Reference("expression"),
+        boolOperator,
+        new Reference("expression"),
+    ]);
+
+    const expression = new ExpressionPattern("expression", [
+        multDivExpression,
+        addSubExpression,
+        boolExpression,
+        ternary,
+        group,
+        variables,
+    ]);
+
+    return expression;
+}
+
+function createOptionsExpression() {
+    const a = new Literal("a", "a");
+    const b = new Literal("b", "b");
+    const c = new Literal("c", "c");
+
+    const expressionPattern = new ExpressionPattern("expression", [a, b, c]);
+    return expressionPattern;
+}
+
+describe("Expression Pattern", () => {
+    test("Single Expression", () => {
+        const expression = createExpressionPattern();
+        let result = expression.exec("a || c || b / c * a + d");
+         result = expression.exec("a + b");
+         result = expression.exec("a + b * c * d");
+         result = expression.exec("a + b * c || d + e");
+         result = expression.exec("(a + b) * (c + d)");
+         result = expression.exec("(a + b) * c + (d + e)");
+         result = expression.exec("a + b * c ? d : e");
+         result = expression.exec("a + b * (a + b * c ? d : e) ? d : e");
+         result = expression.exec("a + b * a + b * c ? d : e ? d : e");
+         result = expression.exec("a + b * ?");
+
+        expect(result).toBe(result);
+    });
+
+    test("Options like", ()=>{
+        const expression = createOptionsExpression();
+        const autoComplete = new AutoComplete(expression);
+        const suggestion = autoComplete.suggestFor("a");
+
+        expect(suggestion).toBe(suggestion);
+    });
+
+    test("Suggest", () => {
+        const expression = createExpressionPattern();
+
+        const autoComplete = new AutoComplete(expression);
+        const suggestion = autoComplete.suggestFor("a");
+
+        expect(suggestion).toBe(suggestion);
+    });
+});