clarity-pattern-parser 5.0.0 → 6.0.0

package/src/intellisense/javascript/Javascript.test.ts

@@ -10,191 +10,191 @@ import { prefixOperator } from "./prefixOperator";
 
 describe("Ecmascript 3", () => {
     test("Escaped Character", () => {
-        let result = escapedCharacter.parseText(`\\"`);
+        let result = escapedCharacter.exec(`\\"`);
         expect(result.ast?.value).toBe(`\\"`)
 
-        result = escapedCharacter.parseText(`\\'`)
+        result = escapedCharacter.exec(`\\'`)
         expect(result.ast?.value).toBe(`\\'`)
 
-        result = escapedCharacter.parseText(`\\\\`)
+        result = escapedCharacter.exec(`\\\\`)
         expect(result.ast?.value).toBe(`\\\\`)
 
-        result = escapedCharacter.parseText(`\\/`)
+        result = escapedCharacter.exec(`\\/`)
         expect(result.ast?.value).toBe(`\\/`)
 
-        result = escapedCharacter.parseText(`\\f`)
+        result = escapedCharacter.exec(`\\f`)
         expect(result.ast?.value).toBe(`\\f`)
 
-        result = escapedCharacter.parseText(`\\t`)
+        result = escapedCharacter.exec(`\\t`)
         expect(result.ast?.value).toBe(`\\t`)
 
-        result = escapedCharacter.parseText(`\\u00E9`)
+        result = escapedCharacter.exec(`\\u00E9`)
         expect(result.ast?.value).toBe(`\\u00E9`)
     });
 
     test("Exponent", () => {
-        let result = exponent.parseText("e+1");
+        let result = exponent.exec("e+1");
         expect(result.ast?.value).toBe("e+1")
 
-        result = exponent.parseText("e-1");
+        result = exponent.exec("e-1");
         expect(result.ast?.value).toBe("e-1")
 
-        result = exponent.parseText("E+1");
+        result = exponent.exec("E+1");
         expect(result.ast?.value).toBe("E+1")
 
-        result = exponent.parseText("E-1");
+        result = exponent.exec("E-1");
         expect(result.ast?.value).toBe("E-1")
 
-        result = exponent.parseText("e+11");
+        result = exponent.exec("e+11");
         expect(result.ast?.value).toBe("e+11")
 
-        result = exponent.parseText("11");
+        result = exponent.exec("11");
         expect(result.ast).toBeNull()
     });
 
     test("Integer", () => {
-        let result = integer.parseText("0");
+        let result = integer.exec("0");
         expect(result.ast?.value).toBe("0");
 
-        result = integer.parseText("1");
+        result = integer.exec("1");
         expect(result.ast?.value).toBe("1");
 
-        result = integer.parseText("100");
+        result = integer.exec("100");
         expect(result.ast?.value).toBe("100");
 
-        result = integer.parseText(".1");
+        result = integer.exec(".1");
         expect(result.ast).toBeNull();
     });
 
     test("Infix Operator", () => {
-        let result = infixOperator.parseText("*");
+        let result = infixOperator.exec("*");
         expect(result.ast?.value).toBe("*");
 
-        result = infixOperator.parseText("/");
+        result = infixOperator.exec("/");
         expect(result.ast?.value).toBe("/");
 
-        result = infixOperator.parseText("%");
+        result = infixOperator.exec("%");
         expect(result.ast?.value).toBe("%");
 
-        result = infixOperator.parseText("+");
+        result = infixOperator.exec("+");
         expect(result.ast?.value).toBe("+");
 
-        result = infixOperator.parseText("-");
+        result = infixOperator.exec("-");
         expect(result.ast?.value).toBe("-");
 
-        result = infixOperator.parseText(">=");
+        result = infixOperator.exec(">=");
         expect(result.ast?.value).toBe(">=");
 
-        result = infixOperator.parseText("<=");
+        result = infixOperator.exec("<=");
         expect(result.ast?.value).toBe("<=");
 
-        result = infixOperator.parseText(">");
+        result = infixOperator.exec(">");
         expect(result.ast?.value).toBe(">");
 
-        result = infixOperator.parseText("<");
+        result = infixOperator.exec("<");
         expect(result.ast?.value).toBe("<");
 
-        result = infixOperator.parseText("===");
+        result = infixOperator.exec("===");
         expect(result.ast?.value).toBe("===");
 
-        result = infixOperator.parseText("!==");
+        result = infixOperator.exec("!==");
         expect(result.ast?.value).toBe("!==");
 
-        result = infixOperator.parseText("||");
+        result = infixOperator.exec("||");
         expect(result.ast?.value).toBe("||");
 
-        result = infixOperator.parseText("&&");
+        result = infixOperator.exec("&&");
         expect(result.ast?.value).toBe("&&");
 
-        result = infixOperator.parseText("bad");
+        result = infixOperator.exec("bad");
         expect(result.ast).toBeNull();
     });
 
 
     test("Name", () => {
-        let result = name.parseText("p_0");
+        let result = name.exec("p_0");
         expect(result.ast?.value).toBe("p_0");
 
-        result = name.parseText("_0");
+        result = name.exec("_0");
         expect(result.ast?.value).toBe("_0");
 
-        result = name.parseText("0");
+        result = name.exec("0");
         expect(result.ast).toBeNull();
 
-        result = name.parseText("_");
+        result = name.exec("_");
         expect(result.ast?.value).toBe("_");
     });
 
     test("Parameters", () => {
-        let result = parameters.parseText("(param1)");
+        let result = parameters.exec("(param1)");
         expect(result.ast?.value).toBe("(param1)");
 
-        result = parameters.parseText("(param1, param2)");
+        result = parameters.exec("(param1, param2)");
         expect(result.ast?.value).toBe("(param1, param2)");
 
-        result = parameters.parseText("(param1, param2,)");
+        result = parameters.exec("(param1, param2,)");
         expect(result.ast).toBeNull();
     });
 
     test("Prefix Operator", () => {
-        let result = prefixOperator.parseText("typeof ");
+        let result = prefixOperator.exec("typeof ");
         expect(result.ast?.value).toBe("typeof ");
 
-        result = prefixOperator.parseText("+");
+        result = prefixOperator.exec("+");
         expect(result.ast?.value).toBe("+");
 
-        result = prefixOperator.parseText("-");
+        result = prefixOperator.exec("-");
         expect(result.ast?.value).toBe("-");
 
-        result = prefixOperator.parseText("!");
+        result = prefixOperator.exec("!");
         expect(result.ast?.value).toBe("!");
 
-        result = prefixOperator.parseText("a");
+        result = prefixOperator.exec("a");
         expect(result.ast).toBeNull();
     });
 
     test("Object Literal", () => {
-        let result = expression.parseText(`{}`)
+        let result = expression.exec(`{}`)
         expect(result.ast?.value).toBe("{}");
 
-        result = expression.parseText(`{prop:{}}`)
+        result = expression.exec(`{prop:{}}`)
         expect(result.ast?.value).toBe("{prop:{}}");
 
-        result = expression.parseText(`{prop:"value"}`)
+        result = expression.exec(`{prop:"value"}`)
         expect(result.ast?.value).toBe(`{prop:"value"}`);
 
-        result = expression.parseText(`{prop:0.9}`)
+        result = expression.exec(`{prop:0.9}`)
         expect(result.ast?.value).toBe(`{prop:0.9}`);
 
-        result = expression.parseText(`{prop:1}`)
+        result = expression.exec(`{prop:1}`)
         expect(result.ast?.value).toBe(`{prop:1}`);
 
-        result = expression.parseText(`{"prop":1}`)
+        result = expression.exec(`{"prop":1}`)
         expect(result.ast?.value).toBe(`{"prop":1}`);
     });
 
     test("Array Literal", () => {
-        let result = expression.parseText("[]")
+        let result = expression.exec("[]")
         expect(result.ast?.value).toBe("[]");
 
-        result = expression.parseText("[{}, 9, 0.9e-10, [1, 2]]")
+        result = expression.exec("[{}, 9, 0.9e-10, [1, 2]]")
         expect(result.ast?.value).toBe("[{}, 9, 0.9e-10, [1, 2]]");
     });
 
     test("Expression Statement", () => {
-        let result = expressionStatement.parseText(`name = "John"`);
+        let result = expressionStatement.exec(`name = "John"`);
         expect(result.ast?.value).toBe(`name = "John"`);
 
-        result = expressionStatement.parseText(`name = othername = "John"`)
+        result = expressionStatement.exec(`name = othername = "John"`)
         expect(result.ast?.value).toBe(`name = othername = "John"`);
 
-        result = expressionStatement.parseText(`name = othername.prop = "John"`)
+        result = expressionStatement.exec(`name = othername.prop = "John"`)
         expect(result.ast?.value).toBe(`name = othername.prop = "John"`);
 
-        result = expressionStatement.parseText(`name = othername.prop += 2`)
+        result = expressionStatement.exec(`name = othername.prop += 2`)
         expect(result.ast?.value).toBe(`name = othername.prop += 2`);
     
-        result = expressionStatement.parseText(`name.prop().method(blah) = blah.prop()`)
+        result = expressionStatement.exec(`name.prop().method(blah) = blah.prop()`)
         expect(result.ast?.value).toBe(`name.prop().method(blah) = blah.prop()`);
     
     });

package/src/intellisense/javascript/escapedCharacter.ts

@@ -42,7 +42,6 @@ const specialCharacter = new Or("special-character", [
 ]);
 
 const escapedCharacter = new And("escaped-character", [backslash, specialCharacter])
-escapedCharacter.enableAstReduction();
 
 export {
     escapedCharacter

package/src/intellisense/javascript/exponent.ts

@@ -21,6 +21,4 @@ const exponent = new And("exponent", [
     digit,
 ]);
 
-exponent.enableAstReduction();
-
 export { exponent }

package/src/intellisense/javascript/fraction.ts

@@ -6,8 +6,6 @@ const period = new Literal("period", ".");
 const digit = new Regex("digit", "\\d+");
 const fraction = new And("fraction", [period, digit]);
 
-fraction.enableAstReduction();
-
 export {
     fraction
 }

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,88 @@ 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 Pattern", () => {
-        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")]);
+    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 Patterns", () => {
+        const sequence = new And("sequence", [new Literal("a", "A")]);
+        const parent = new And("parent", [sequence, new Literal("b", "B")]);
 
-        const nextPattern = parent.children[0].getNextPattern()
+        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);
+    });
+
 });