clarity-pattern-parser 11.0.16 → 11.0.19

package/dist/patterns/Expression.d.ts

@@ -21,6 +21,7 @@ export declare class Expression implements Pattern {
     private _precedenceMap;
     private _shouldStopParsing;
     private _precedenceTree;
+    private _hasOrganized;
     get id(): string;
     get type(): string;
     get name(): string;

package/package.json

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

package/src/grammar/Grammar.ts

@@ -272,8 +272,8 @@ export class Grammar {
     }
 
     private _isRecursive(name: string, pattern: Pattern) {
-        if (pattern.type === "right-associated" && this._isRecursivePattern(name, pattern.children[0])) {
-            return true;
+        if (pattern.type === "right-associated") {
+            pattern = pattern.children[0];
         }
 
         return this._isRecursivePattern(name, pattern);
@@ -287,9 +287,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.type === "reference" && firstChild.name === name) ||
-            (lastChild.type === "reference" && lastChild.name === name);
+        return pattern.type === "reference" ||
+            (pattern.type === "sequence" && isLongEnough &&
+                (firstChild.type === "reference" && firstChild.name === name) ||
+                (lastChild.type === "reference" && lastChild.name === name));
     }
 
     private _buildPattern(node: Node): Pattern {

package/src/patterns/Expression.ts

@@ -7,6 +7,7 @@ import { Sequence } from "./Sequence";
 import { Association, PrecedenceTree } from './PrecedenceTree';
 import { testPattern } from "./testPattern";
 import { execPattern } from "./execPattern";
+import { Reference } from "./Reference";
 
 let indexId = 0;
 
@@ -29,6 +30,7 @@ export class Expression implements Pattern {
     private _precedenceMap: Record<string, number>;
     private _shouldStopParsing: boolean;
     private _precedenceTree: PrecedenceTree;
+    private _hasOrganized: boolean;
 
     get id(): string {
         return this._id;
@@ -94,13 +96,10 @@ export class Expression implements Pattern {
         this._associationMap = {};
         this._precedenceMap = {};
         this._originalPatterns = patterns;
-        this._patterns = this._organizePatterns(patterns);
         this._shouldStopParsing = false;
-        this._precedenceTree = new PrecedenceTree(this._precedenceMap, this._associationMap);
-
-        if (this._atomPatterns.length === 0) {
-            throw new Error("Need at least one terminating pattern with an 'expression' pattern.");
-        }
+        this._hasOrganized = false;
+        this._patterns = [];
+        this._precedenceTree = new PrecedenceTree({}, {});
     }
 
     private _organizePatterns(patterns: Pattern[]) {
@@ -152,6 +151,9 @@ export class Expression implements Pattern {
             }
         });
 
+        this._patterns = finalPatterns;
+        this._precedenceTree = new PrecedenceTree(this._precedenceMap, this._associationMap);
+
         return finalPatterns;
     }
 
@@ -227,7 +229,11 @@ export class Expression implements Pattern {
 
     private _unwrapAssociationIfNecessary(pattern: Pattern) {
         if (pattern.type === "right-associated") {
-            return pattern.children[0];
+            pattern = pattern.children[0];
+        }
+
+        if (pattern.type === "reference") {
+            pattern = (pattern as Reference).getReferencePatternSafely();
         }
 
         return pattern;
@@ -246,6 +252,19 @@ export class Expression implements Pattern {
 
     parse(cursor: Cursor): Node | null {
         this._firstIndex = cursor.index;
+
+        if (!this._hasOrganized) {
+            this._hasOrganized = true;
+            this._organizePatterns(this._originalPatterns);
+        }
+
+        // If there are not any atom nodes then nothing can be found.
+        if (this._atomPatterns.length < 1) {
+            cursor.moveTo(this._firstIndex);
+            cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
+            return null;
+        }
+
         const node = this._tryToParse(cursor);
 
         if (node != null) {

package/src/patterns/Reference.test.ts

@@ -97,13 +97,6 @@ describe("Reference", () => {
         expect(result).toBeNull();
     });
 
-    test("Test With Match", () => {
-        const value = createValuePattern();
-        const reference = findPattern(value, p => p.type === "reference") as Reference;
-        const result = reference.test("[1]");
-        expect(result).toBeTruthy();
-    });
-
     test("Test No Match", () => {
         const value = createValuePattern();
         const reference = findPattern(value, p => p.type === "reference") as Reference;

package/src/patterns/Reference.ts

@@ -104,7 +104,7 @@ export class Reference implements Pattern {
       if (pattern._firstIndex === this._firstIndex) {
         depth++;
 
-        if (depth > 1) {
+        if (depth > 0) {
           return true;
         }
       }