clarity-pattern-parser 5.0.0 → 6.0.2

package/src/intellisense/javascript/infixOperator.ts

@@ -10,8 +10,10 @@ const greaterOrEqual = new Literal("greater-or-equal", ">=");
 const lessOrEqual = new Literal("less-or-equal", "<=");
 const greater = new Literal("greater", ">");
 const less = new Literal("less", "<");
-const equal = new Literal("equal", "===");
-const notEqual = new Literal("not-equal", "!==");
+const equal = new Literal("equal", "==");
+const notEqual = new Literal("not-equal", "!=");
+const strictEqual = new Literal("strict-equal", "===");
+const strictNotEqual = new Literal("strict-not-equal", "!==");
 const logicalOr = new Literal("logical-or", "||");
 const logicalAnd = new Literal("logical-and", "&&");
 
@@ -25,6 +27,8 @@ const infixOperator = new Or("infix-operator", [
     lessOrEqual,
     greater,
     less,
+    strictEqual,
+    strictNotEqual,
     equal,
     notEqual,
     logicalOr,

package/src/intellisense/javascript/keywords.ts

@@ -0,0 +1,3 @@
+import { Literal } from "../../patterns/Literal";
+
+export const nullKeyword = new Literal("null", "null");

package/src/intellisense/javascript/objectAccess.ts

@@ -0,0 +1,9 @@
+import { And } from "../../patterns/And";
+import { Reference } from "../../patterns/Reference";
+import { name } from "./name";
+import { propertyAccess } from "./propertyAccess";
+
+export const objectAccess = new And("object-access", [
+    name.clone("variable-name"),
+    propertyAccess,
+]);

package/src/intellisense/javascript/objectLiteral.ts

@@ -8,7 +8,7 @@ import { name } from "./name";
 import { optionalSpaces } from "./optionalSpaces";
 import { stringLiteral } from "./stringLiteral";
 
-const propertyName = new Or("property-name", [stringLiteral, name]);
+const propertyName = new Or("property-name", [stringLiteral.clone("object-property"), name.clone("object-property")]);
 const property = new And("property", [
     propertyName,
     optionalSpaces,
@@ -17,12 +17,12 @@ const property = new And("property", [
     new Reference("expression"),
 ]);
 const divider = new Regex("property-divider", "\\s*,\\s*");
-const properties = new Repeat("properties", property, divider, true);
+const optionalProperties = new Repeat("properties", property, divider, true);
 
 const objectLiteral = new And("object-literal", [
     new Literal("open-curly-bracket", "{"),
     optionalSpaces,
-    properties,
+    optionalProperties,
     optionalSpaces,
     new Literal("close-curly-bracket", "}"),
 ]);

package/src/intellisense/javascript/propertyAccess.ts

@@ -6,7 +6,7 @@ import { name } from "./name";
 
 const dotPropertyAccess = new And("dot-property-access", [
     new Literal("period", "."),
-    name
+    name.clone("property-name")
 ]);
 
 const bracketPropertyAccess = new And("bracket-property-access", [
@@ -15,9 +15,14 @@ const bracketPropertyAccess = new And("bracket-property-access", [
     new Literal("close-square-bracket", "]"),
 ]);
 
-const propertyAccess = new Or("property-access", [
+const propertyAccessTypes = new Or("property-access-types", [
     dotPropertyAccess,
-    bracketPropertyAccess,
+    bracketPropertyAccess
+]);
+
+const propertyAccess = new And("property-access", [
+    propertyAccessTypes,
+    new Reference("property-access", true)
 ]);
 
 export { propertyAccess }

package/src/intellisense/javascript/stringLiteral.ts

@@ -7,19 +7,27 @@ import { escapedCharacter } from "./escapedCharacter";
 
 const doubleQuoteStringLiteral = new And("double-string-literal", [
     new Literal("double-quote", "\""),
-    new Repeat("characters", new Or("characters", [
-        new Regex("normal-characters", "[^\\\"]+"),
-        escapedCharacter
-    ])),
+    new Repeat("characters",
+        new Or("characters", [
+            new Regex("normal-characters", "[^\\\"]+"),
+            escapedCharacter
+        ]),
+        undefined,
+        true
+    ),
     new Literal("double-quote", "\""),
 ]);
 
 const singleQuoteStringLiteral = new And("single-string-literal", [
     new Literal("single-quote", "'"),
-    new Repeat("characters", new Or("characters", [
-        new Regex("normal-characters", "[^\\']+"),
-        escapedCharacter
-    ])),
+    new Repeat("characters",
+        new Or("characters", [
+            new Regex("normal-characters", "[^\\']+"),
+            escapedCharacter
+        ]),
+        undefined,
+        true
+    ),
     new Literal("single-quote", "'"),
 ]);
 

package/src/patterns/And.test.ts

@@ -77,7 +77,7 @@ describe("And", () => {
         const sequence = new And("sequence", [
             new Literal("a", "A"),
             new Literal("b", "B", true)
-        ], true);
+        ]);
         const cursor = new Cursor("AD");
         const result = sequence.parse(cursor);
         const expected = new Node("and", "sequence", 0, 0, [
@@ -93,7 +93,7 @@ describe("And", () => {
         const sequence = new And("sequence", [
             new Literal("a", "A"),
             new Literal("b", "B", true)
-        ], true);
+        ]);
         const cursor = new Cursor("A");
         const result = sequence.parse(cursor);
         const expected = new Node("and", "sequence", 0, 0, [
@@ -105,7 +105,7 @@ describe("And", () => {
         expect(cursor.index).toBe(0);
     });
 
-    test("Incomplete Parse", () => {
+    test("Incomplete Parse (Optional)", () => {
         const sequence = new And("sequence", [
             new Literal("a", "A"),
             new Literal("b", "B")
@@ -175,6 +175,32 @@ describe("And", () => {
         expect(sequence.children[0].name).toBe("a");
     });
 
+    test("Exec", () => {
+        const sequence = new And("sequence", [new Literal("a", "A")]);
+
+        const { ast: result, cursor } = sequence.exec("A");
+        const expected = new Node("and", "sequence", 0, 0, [
+            new Node("literal", "a", 0, 0, undefined, "A")
+        ]);
+
+        expect(result).toEqual(expected)
+        expect(cursor).not.toBeNull();
+    });
+
+    test("Test With Match", () => {
+        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const hasMatch = sequence.test("A");
+
+        expect(hasMatch).toBeTruthy();
+    });
+
+    test("Test With No Match", () => {
+        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const hasMatch = sequence.test("B");
+
+        expect(hasMatch).toBeFalsy();
+    });
+
     test("Set Parent", () => {
         const a = new Literal("a", "A", true)
         const sequence = new And("sequence", [
@@ -186,33 +212,6 @@ describe("And", () => {
         expect(parent.children[0].type).toBe("and");
     });
 
-    test("Reduce Ast", () => {
-        const sequence = new And("sequence", [
-            new Literal("a", "A"),
-        ], true);
-        sequence.enableAstReduction();
-
-        const cursor = new Cursor("A");
-        let result = sequence.parse(cursor);
-        let expected = new Node("and", "sequence", 0, 0, [], "A");
-
-        expect(result).toEqual(expected);
-        expect(cursor.error).toBe(null)
-        expect(cursor.index).toBe(0);
-
-        sequence.disableAstReduction()
-
-        cursor.moveTo(0)
-        result = sequence.parse(cursor);
-        expected = new Node("and", "sequence", 0, 0, [
-            new Node("literal", "a", 0, 0, [], "A"),
-        ]);
-
-        expect(result).toEqual(expected);
-        expect(cursor.error).toBe(null)
-        expect(cursor.index).toBe(0);
-    });
-
     test("Get Tokens", () => {
         const sequence = new And("sequence", [
             new Literal("a", "A", true),
@@ -224,76 +223,101 @@ describe("And", () => {
         expect(tokens).toEqual(expected);
     });
 
-    test("Get Next Tokens", () => {
+    test("Get Tokens After", () => {
         const sequence = new And("sequence", [
             new Literal("a", "A"),
             new Literal("b", "B", true),
             new Literal("c", "C"),
         ], true);
 
-        const tokens = sequence.getNextTokens(sequence.children[0])
+        const tokens = sequence.getTokensAfter(sequence.children[0])
         const expected = ["B", "C"];
 
         expect(tokens).toEqual(expected);
     });
 
-    test("Get Next Tokens With Invalid Pattern", () => {
+    test("Get Tokens After With Invalid Pattern", () => {
         const sequence = new And("sequence", [
             new Literal("a", "A"),
             new Literal("b", "B", true),
             new Literal("c", "C"),
         ], true);
 
-        const tokens = sequence.getNextTokens(new Literal("not-child", "not-child"))
+        const tokens = sequence.getTokensAfter(new Literal("not-child", "not-child"))
 
         expect(tokens).toEqual([]);
     });
 
-    test("Get Next Tokens With Last Child", () => {
+    test("Get Tokens After With Last Child", () => {
         const sequence = new And("sequence", [
             new Literal("a", "A"),
         ], true);
         const parent = new And("parent", [sequence, new Literal("b", "B")]);
 
 
-        const tokens = parent.children[0].getNextTokens(parent.children[0].children[0])
+        const tokens = parent.children[0].getTokensAfter(parent.children[0].children[0])
 
         expect(tokens).toEqual(["B"]);
     });
 
-    test("Get Next Tokens With Last Optional Child", () => {
+    test("Get Tokens After With Last Optional Child", () => {
         const sequence = new And("sequence", [
             new Literal("a", "A"),
             new Literal("b", "B", true),
         ], true);
         const parent = new And("parent", [sequence, new Literal("c", "C")]);
 
-
-        const tokens = parent.children[0].getNextTokens(parent.children[0].children[0])
+        const tokens = parent.children[0].getTokensAfter(parent.children[0].children[0])
 
         expect(tokens).toEqual(["B", "C"]);
     });
 
-    test("Parse Text", () => {
+    test("Get Next Tokens", () => {
         const sequence = new And("sequence", [new Literal("a", "A")]);
-        sequence.enableAstReduction();
+        const parent = new And("parent", [sequence, new Literal("b", "B")]);
 
-        const { ast: result } = sequence.parseText("A");
-        const expected = new Node("and", "sequence", 0, 0, [], "A");
+        const sequenceClone = parent.findPattern(p => p.name === "sequence");
+        const tokens = sequenceClone?.getNextTokens() || [];
 
-        expect(result).toEqual(expected)
+        expect(tokens[0]).toBe("B");
+    });
+
+    test("Get Next Tokens With Null Parent", () => {
+        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const tokens = sequence.getNextTokens();
+
+        expect(tokens.length).toBe(0);
     });
 
-    test("Get Next Pattern", () => {
+    test("Get Patterns", () => {
         const sequence = new And("sequence", [
-            new Literal("a", "A"),
-            new Literal("b", "B", true),
+            new Literal("a", "A", true),
+            new Literal("b", "B"),
         ], true);
-        const parent = new And("parent", [sequence, new Literal("c", "C")]);
+        const tokens = sequence.getPatterns();
+        const a = sequence.findPattern(p=>p.name === "a");
+        const b = sequence.findPattern(p=>p.name === "b");
+        const expected = [a, b]
 
+        expect(tokens).toEqual(expected);
+    });
 
-        const nextPattern = parent.children[0].getNextPattern()
+    test("Get Next Patterns", () => {
+        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const parent = new And("parent", [sequence, new Literal("b", "B")]);
+
+        const sequenceClone = parent.findPattern(p => p.name === "sequence");
+        const nextPatterns = sequenceClone?.getNextPatterns() || [];
+        const b = parent.findPattern(p => p.name === "b")
 
-        expect(nextPattern?.name).toBe("c");
+        expect(nextPatterns[0]).toBe(b);
     });
+
+    test("Get Next Patterns With Null Parent", () => {
+        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const nextPatterns = sequence.getNextPatterns()
+
+        expect(nextPatterns.length).toBe(0);
+    });
+
 });

package/src/patterns/And.ts

@@ -3,7 +3,6 @@ import { Pattern } from "./Pattern";
 import { Node } from "../ast/Node";
 import { clonePatterns } from "./clonePatterns";
 import { filterOutNull } from "./filterOutNull";
-import { getNextPattern } from "./getNextPattern";
 import { findPattern } from "./findPattern";
 
 export class And implements Pattern {
@@ -14,7 +13,6 @@ export class And implements Pattern {
   private _isOptional: boolean;
   private _nodes: (Node | null)[];
   private _firstIndex: number;
-  private _shouldReduceAst: boolean;
 
   get type(): string {
     return this._type;
@@ -54,7 +52,6 @@ export class And implements Pattern {
     this._parent = null;
     this._children = children;
     this._firstIndex = -1
-    this._shouldReduceAst = false;
     this._nodes = [];
   }
 
@@ -64,12 +61,19 @@ export class And implements Pattern {
     }
   }
 
-  parseText(text: string) {
+  test(text: string) {
     const cursor = new Cursor(text);
-    const ast = this.parse(cursor)
+    const ast = this.parse(cursor);
+
+    return ast?.value === text;
+  }
+
+  exec(text: string) {
+    const cursor = new Cursor(text);
+    const ast = this.parse(cursor);
 
     return {
-      ast,
+      ast: ast?.value === text ? ast : null,
       cursor
     };
   }
@@ -115,32 +119,41 @@ export class And implements Pattern {
         if (hasMorePatterns) {
           if (hadMatch) {
             if (cursor.hasNext()) {
+              // We had a match. Increment the cursor and use the next pattern.
               cursor.next();
               continue;
             } 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)) {
                 passed = true;
                 break;
               }
 
+              // We didn't finish the parsing sequence.
               cursor.recordErrorAt(cursor.index + 1, this);
               break;
             }
           } else {
+            // An optional pattern did not matched, try from the same spot on the next
+            // pattern.
             cursor.moveTo(runningCursorIndex);
             continue;
           }
         } else {
+          // If we don't have any results from what we parsed then record error.
           const lastNode = this.getLastValidNode();
           if (lastNode === null) {
             cursor.recordErrorAt(cursor.index, this);
             break;
           }
 
+          // The sequence was parsed fully.
           passed = true;
           break;
         }
       } else {
+        // The pattern failed.
         cursor.moveTo(this._firstIndex);
         break;
       }
@@ -181,28 +194,15 @@ export class And implements Pattern {
 
     cursor.moveTo(lastIndex)
 
-    if (this._shouldReduceAst) {
-      children.length = 0;
-    }
-
     return new Node(
       "and",
       this._name,
       this._firstIndex,
       lastIndex,
-      children,
-      this._shouldReduceAst ? value : undefined
+      children
     );
   }
 
-  enableAstReduction(): void {
-    this._shouldReduceAst = true;
-  }
-
-  disableAstReduction(): void {
-    this._shouldReduceAst = false;
-  }
-
   getTokens(): string[] {
     const tokens: string[] = [];
 
@@ -217,14 +217,45 @@ export class And implements Pattern {
     return tokens;
   }
 
-  getNextTokens(lastMatched: Pattern): string[] {
+  getTokensAfter(childReference: Pattern): string[] {
+    const patterns = this.getPatternsAfter(childReference);
+    const tokens: string[] = [];
+
+    patterns.forEach(p => tokens.push(...p.getTokens()));
+
+    return tokens;
+  }
+
+  getNextTokens(): string[] {
+    if (this.parent == null) {
+      return []
+    }
+
+    return this.parent.getTokensAfter(this);
+  }
+
+  getPatterns(): Pattern[] {
+    const patterns: Pattern[] = [];
+
+    for (const pattern of this._children) {
+      patterns.push(...pattern.getPatterns());
+
+      if (!pattern.isOptional) {
+        break;
+      }
+    }
+
+    return patterns;
+  }
+
+  getPatternsAfter(childReference: Pattern): Pattern[] {
     let nextSibling: Pattern | null = null;
     let nextSiblingIndex = -1;
     let index = -1;
-    const tokens: string[] = [];
+    const patterns: Pattern[] = [];
 
     for (let i = 0; i < this._children.length; i++) {
-      if (this._children[i] === lastMatched) {
+      if (this._children[i] === childReference) {
         if (i + 1 < this._children.length) {
           nextSibling = this._children[i + 1];
         }
@@ -234,48 +265,53 @@ export class And implements Pattern {
       }
     }
 
+    // The child reference isn't one of the child patterns.
     if (index === -1) {
       return [];
     }
 
+    // The reference pattern is the last child. So ask the parent for the next pattern.
     if (nextSiblingIndex === this._children.length && this._parent !== null) {
-      return this._parent.getNextTokens(this);
+      return this._parent.getPatternsAfter(this);
     }
 
+    // Next pattern isn't optional so send it back as the next patterns.
     if (nextSibling !== null && !nextSibling.isOptional) {
-      return nextSibling.getTokens();
+      return [nextSibling];
     }
 
+    // Send back as many optional patterns as possible.
     if (nextSibling !== null && nextSibling.isOptional) {
       for (let i = nextSiblingIndex; i < this._children.length; i++) {
         const child = this._children[i];
-        tokens.push(...child.getTokens());
+        patterns.push(child);
 
         if (!child.isOptional) {
           break;
         }
 
         if (i === this._children.length - 1 && this._parent !== null) {
-          tokens.push(...this._parent.getNextTokens(this));
+          patterns.push(...this._parent.getPatternsAfter(this));
         }
       }
     }
 
-    return tokens;
+    return patterns;
   }
 
-  getNextPattern(): Pattern | null {
-    return getNextPattern(this)
+  getNextPatterns(): Pattern[] {
+    if (this.parent == null) {
+      return [];
+    }
+
+    return this.parent.getPatternsAfter(this)
   }
 
-  findPattern(isMatch: (p: Pattern)=>boolean): Pattern | null{
-    return findPattern(this, isMatch);
+  findPattern(predicate: (p: Pattern) => boolean): Pattern | null {
+    return findPattern(this, predicate);
   }
 
   clone(name = this._name, isOptional = this._isOptional): Pattern {
-    const and = new And(name, this._children, isOptional)
-    and._shouldReduceAst = this._shouldReduceAst;
-
-    return and
+    return new And(name, this._children, isOptional)
   }
 }

package/src/patterns/Cursor.ts

@@ -1,5 +1,7 @@
-import { Pattern, Node, ParseError } from "..";
+import { Node } from "../ast/Node";
 import { CursorHistory, Match } from "./CursorHistory";
+import { ParseError } from "./ParseError";
+import { Pattern } from "./Pattern";
 
 export class Cursor {
   private _text: string;
@@ -16,21 +18,21 @@ export class Cursor {
   }
 
   get isOnLast(): boolean {
-    return this._index === this._getLastIndex();
+    return this._index === this.getLastIndex();
   }
 
   get isRecording(): boolean {
     return this._history.isRecording;
   }
 
-  get leafMatch(): Match {
-    return this._history.leafMatch;
-  }
-
   get rootMatch(): Match {
     return this._history.rootMatch;
   }
 
+  get leafMatch(): Match {
+    return this._history.leafMatch;
+  }
+
   get furthestError(): ParseError | null {
     return this._history.furthestError;
   }
@@ -70,16 +72,16 @@ export class Cursor {
     return this._index + 1 < this._length;
   }
 
-  hasPrevious(): boolean {
-    return this._index - 1 >= 0;
-  }
-
   next(): void {
     if (this.hasNext()) {
       this._index++;
     }
   }
 
+  hasPrevious(): boolean {
+    return this._index - 1 >= 0;
+  }
+
   previous(): void {
     if (this.hasPrevious()) {
       this._index--;
@@ -97,7 +99,11 @@ export class Cursor {
   }
 
   moveToLastChar(): void {
-    this._index = this._getLastIndex();
+    this._index = this.getLastIndex();
+  }
+
+  getLastIndex(): number {
+    return this._length - 1;
   }
 
   getChars(first: number, last: number): string {
@@ -124,7 +130,4 @@ export class Cursor {
     this._history.stopRecording();
   }
 
-  private _getLastIndex(): number {
-    return this._length - 1;
-  }
 }

package/src/patterns/CursorHistory.ts

@@ -17,6 +17,14 @@ export class CursorHistory {
   private _nodes: Node[] = [];
   private _errors: ParseError[] = [];
 
+  get isRecording(): boolean {
+    return this._isRecording;
+  }
+
+  get rootMatch(): Match {
+    return this._rootMatch;
+  }
+
   get leafMatch(): Match {
     return this._leafMatch;
   }
@@ -25,10 +33,6 @@ export class CursorHistory {
     return this._furthestError;
   }
 
-  get isRecording(): boolean {
-    return this._isRecording;
-  }
-
   get errors(): ParseError[] {
     return this._errors;
   }
@@ -45,10 +49,6 @@ export class CursorHistory {
     return this._patterns;
   }
 
-  get rootMatch(): Match {
-    return this._rootMatch;
-  }
-
   recordMatch(pattern: Pattern, node: Node): void {
     if (this._isRecording) {
       this._patterns.push(pattern);