clarity-pattern-parser 4.0.2 → 5.0.0

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

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

package/src/intellisense/javascript/arrayLiteral.ts

@@ -0,0 +1,25 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Reference } from "../../patterns/Reference";
+import { Regex } from "../../patterns/Regex";
+import { Repeat } from "../../patterns/Repeat";
+import { optionalSpaces } from "./optionalSpaces";
+
+const divider = new Regex("array-divider", "\\s*,\\s*");
+const arrayItems = new Repeat("array-items", new Reference("expression"), divider, true);
+
+export const arrayLiteral = new Or("array-literal",
+    [new And("empty-array-literal", [
+        new Literal("open-square-bracket", "["),
+        optionalSpaces,
+        new Literal("close-square-bracket", "]"),
+    ]),
+    new And("array-literal", [
+        new Literal("open-square-bracket", "["),
+        optionalSpaces,
+        arrayItems,
+        optionalSpaces,
+        new Literal("close-square-bracket", "]"),
+    ])
+    ]);

package/src/intellisense/javascript/deleteStatement.ts

@@ -0,0 +1,14 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Regex } from "../../patterns/Regex";
+import { expression } from "./expression";
+import { propertyAccess } from "./propertyAccess";
+
+const space = new Regex("space", "\\s+");
+export const deleteStatement = new And("delete-statement", [
+    new Literal("delete-keyword", "delete"),
+    space,
+    expression,
+    propertyAccess
+]);
+

package/src/intellisense/javascript/escapedCharacter.ts

@@ -0,0 +1,50 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Regex } from "../../patterns/Regex";
+
+const backslash = new Literal("backslash", "\\");
+const doubleQuote = new Literal("double-quote", "\"");
+const singleQuote = new Literal("single-quote", "'");
+const slash = new Literal("slash", "/");
+const backspace = new Literal("backspace", "b");
+const formFeed = new Literal("form-feed", "f");
+const newLine = new Literal("new-line", "n");
+const carriageReturn = new Literal("carriage-return", "r");
+const tab = new Literal("tab", "t");
+const hexDigit = new Regex("hex-digit", "[0-9a-fA-F]");
+
+hexDigit.setTokens([
+    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
+    "a", "b", "c", "d", "e", "f",
+    "A", "B", "C", "D", "E", "F",
+]);
+
+const unicode = new And("hex", [
+    new Literal("u", "u"),
+    hexDigit,
+    hexDigit,
+    hexDigit,
+    hexDigit
+]);
+
+const specialCharacter = new Or("special-character", [
+    doubleQuote,
+    singleQuote,
+    backslash,
+    slash,
+    backspace,
+    formFeed,
+    newLine,
+    carriageReturn,
+    tab,
+    unicode,
+]);
+
+const escapedCharacter = new And("escaped-character", [backslash, specialCharacter])
+escapedCharacter.enableAstReduction();
+
+export {
+    escapedCharacter
+}
+

package/src/intellisense/javascript/exponent.ts

@@ -0,0 +1,26 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Regex } from "../../patterns/Regex";
+
+const e = new Or("e", [
+    new Literal("e", "e"),
+    new Literal("e", "E")
+]);
+
+const optionalSign = new Or("sign", [
+    new Literal("plus", "+"),
+    new Literal("minus", "-")
+], true);
+
+const digit = new Regex("digit", "\\d+");
+
+const exponent = new And("exponent", [
+    e,
+    optionalSign,
+    digit,
+]);
+
+exponent.enableAstReduction();
+
+export { exponent }

package/src/intellisense/javascript/expression.ts

@@ -0,0 +1,87 @@
+import { Regex } from "../..";
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Reference } from "../../patterns/Reference";
+import { Repeat } from "../../patterns/Repeat";
+import { infixOperator } from "./infixOperator";
+import { invocation } from "./invocation";
+import { literal } from "./literal";
+import { name } from "./name";
+import { optionalSpaces } from "./optionalSpaces";
+import { prefixOperator } from "./prefixOperator";
+import { propertyAccess } from "./propertyAccess";
+
+const space = new Regex("space", "\\s+")
+const newKeyword = new Literal("new-keyword", "new");
+const deleteKeyword = new Literal("delete-keyword", "delete");
+
+const newExpression = new And("new-expression", [
+    newKeyword,
+    space,
+    new Reference("expression")
+]);
+
+const deleteExpression = new And("delete-expression", [
+    deleteKeyword,
+    space,
+    new Reference("expression")
+]);
+
+const groupExpression = new And("group-expression", [
+    new Literal("open-paren", "("),
+    optionalSpaces,
+    new Reference("expression"),
+    optionalSpaces,
+    new Literal("close-paren", ")")
+]);
+
+const prefixExpression = new And("prefix-expression", [
+    prefixOperator,
+    new Reference("expression")
+]);
+
+const optionalInfix = new And("infix-expression", [
+    infixOperator,
+    optionalSpaces,
+    new Reference("expression"),
+], true);
+
+const optionalTernary = new And("ternary", [
+    new Literal("question-mark", "?"),
+    optionalSpaces,
+    new Reference("expression"),
+    optionalSpaces,
+    new Literal("colon", ":"),
+    optionalSpaces,
+    new Reference("expression")
+], true);
+
+const optionalMemberAccesses = new Repeat("object-member-accesses",
+    new Or("object-member-access", [
+        invocation,
+        propertyAccess,
+    ]),
+    undefined, true
+);
+
+var variableName = name.clone("variable-name");
+
+const expressions = new Or("expressions", [
+    newExpression,
+    deleteExpression,
+    groupExpression,
+    prefixExpression,
+    literal,
+    variableName,
+]);
+
+const expression = new And("expression", [
+    expressions,
+    optionalInfix,
+    optionalTernary,
+    optionalMemberAccesses
+]);
+
+export { expression }
+

package/src/intellisense/javascript/expressionStatement.ts

@@ -0,0 +1,29 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Repeat } from "../../patterns/Repeat";
+import { expression } from "./expression";
+import { optionalSpaces } from "./optionalSpaces";
+
+const assignmentOperators = new Or("assignment-operators", [
+    new Literal("assign", "="),
+    new Literal("addition-assign", "+="),
+    new Literal("subtraction-assign", "-="),
+]);
+
+const assignment = new And("assignment", [
+    expression,
+    optionalSpaces,
+    assignmentOperators,
+    optionalSpaces,
+]);
+
+const expressionStatement = new And("expressionStatement", [
+    new Repeat("assignments",
+        assignment),
+    optionalSpaces,
+    expression
+]);
+
+
+export { expressionStatement }

package/src/intellisense/javascript/fraction.ts

@@ -0,0 +1,13 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Regex } from "../../patterns/Regex";
+
+const period = new Literal("period", ".");
+const digit = new Regex("digit", "\\d+");
+const fraction = new And("fraction", [period, digit]);
+
+fraction.enableAstReduction();
+
+export {
+    fraction
+}

package/src/intellisense/javascript/infixOperator.ts

@@ -0,0 +1,36 @@
+import { Literal } from "../../patterns/Literal"
+import { Or } from "../../patterns/Or";
+
+const multiply = new Literal("multiply", "*");
+const divide = new Literal("divide", "/");
+const remainder = new Literal("remainder", "%");
+const add = new Literal("add", "+");
+const subtract = new Literal("subtract", "-");
+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 logicalOr = new Literal("logical-or", "||");
+const logicalAnd = new Literal("logical-and", "&&");
+
+const infixOperator = new Or("infix-operator", [
+    multiply,
+    divide,
+    remainder,
+    add,
+    subtract,
+    greaterOrEqual,
+    lessOrEqual,
+    greater,
+    less,
+    equal,
+    notEqual,
+    logicalOr,
+    logicalAnd
+]);
+
+export { infixOperator }
+
+

package/src/intellisense/javascript/integer.ts

@@ -0,0 +1,7 @@
+import { Regex } from "../../patterns/Regex";
+
+const integer = new Regex("integer", "([1-9][0-9]*)|0");
+
+export {
+    integer
+}

package/src/intellisense/javascript/invocation.ts

@@ -0,0 +1,28 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Reference } from "../../patterns/Reference";
+import { Regex } from "../../patterns/Regex";
+import { Repeat } from "../../patterns/Repeat";
+import { optionalSpaces } from "./optionalSpaces";
+
+const divider = new Regex("invocation-divider", "\\s*,\\s*");
+
+const invocationWithArguments = new And("invocation-with-arguments", [
+    new Literal("open-paren", "("),
+    optionalSpaces,
+    new Repeat("expressions", new Reference("expression"), divider, true),
+    optionalSpaces,
+    new Literal("close-paren", ")"),
+]);
+
+const emptyInvocation = new And("empty-invocation", [
+    new Literal("open-paren", "("),
+    optionalSpaces,
+    new Literal("close-paren", ")"),
+]);
+
+export const invocation = new Or("invocation", [
+    emptyInvocation,
+    invocationWithArguments
+])

package/src/intellisense/javascript/literal.ts

@@ -0,0 +1,14 @@
+import { Or } from "../../patterns/Or";
+import { arrayLiteral } from "./arrayLiteral";
+import { numberLiteral } from "./numberLiteral";
+import { objectLiteral } from "./objectLiteral";
+import { stringLiteral } from "./stringLiteral";
+
+const literal = new Or("literal", [
+    numberLiteral,
+    stringLiteral,
+    arrayLiteral,
+    objectLiteral,
+]);
+
+export { literal }

package/src/intellisense/javascript/name.ts

@@ -0,0 +1,3 @@
+import { Regex } from "../../patterns/Regex";
+
+export const name = new Regex("name", "[a-zA-Z_]+[a-zA-Z0-9_]*");

package/src/intellisense/javascript/numberLiteral.ts

@@ -0,0 +1,10 @@
+import { And } from "../../patterns/And";
+import { exponent } from "./exponent";
+import { fraction } from "./fraction";
+import { integer } from "./integer";
+
+export const numberLiteral = new And("number-literal", [
+    integer,
+    fraction.clone("number-fraction", true),
+    exponent.clone("number-exponent", true)
+]);

package/src/intellisense/javascript/objectLiteral.ts

@@ -0,0 +1,30 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Reference } from "../../patterns/Reference";
+import { Regex } from "../../patterns/Regex";
+import { Repeat } from "../../patterns/Repeat";
+import { name } from "./name";
+import { optionalSpaces } from "./optionalSpaces";
+import { stringLiteral } from "./stringLiteral";
+
+const propertyName = new Or("property-name", [stringLiteral, name]);
+const property = new And("property", [
+    propertyName,
+    optionalSpaces,
+    new Literal("colon", ":"),
+    optionalSpaces,
+    new Reference("expression"),
+]);
+const divider = new Regex("property-divider", "\\s*,\\s*");
+const properties = new Repeat("properties", property, divider, true);
+
+const objectLiteral = new And("object-literal", [
+    new Literal("open-curly-bracket", "{"),
+    optionalSpaces,
+    properties,
+    optionalSpaces,
+    new Literal("close-curly-bracket", "}"),
+]);
+
+export { objectLiteral }

package/src/intellisense/javascript/optionalSpaces.ts

@@ -0,0 +1,3 @@
+import { Regex } from "../../patterns/Regex";
+
+export const optionalSpaces = new Regex("optional-spaces", "\\s+", true);

package/src/intellisense/javascript/parameters.ts

@@ -0,0 +1,20 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Regex } from "../../patterns/Regex";
+import { Repeat } from "../../patterns/Repeat";
+import { name } from "./name";
+
+const divider = new Regex(",", "\\s*[,]\\s*");
+divider.setTokens([", "]);
+
+const optionalSpace = new Regex("optional-space", "\\s", true)
+
+const parameters = new And("parameters", [
+    new Literal("open-paren", "("),
+    optionalSpace,
+    new Repeat("arguments", name, divider),
+    optionalSpace,
+    new Literal("close-paren", ")"),
+]);
+
+export { parameters }

package/src/intellisense/javascript/prefixOperator.ts

@@ -0,0 +1,13 @@
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Regex } from "../../patterns/Regex";
+
+const prefixOperator = new Or("prefix-operator", [
+    new Literal("typeof", "typeof "),
+    new Literal("to-number", "+"),
+    new Literal("negate", "-"),
+    new Literal("logical-not", "!"),
+]);
+
+export { prefixOperator }
+

package/src/intellisense/javascript/propertyAccess.ts

@@ -0,0 +1,23 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Reference } from "../../patterns/Reference";
+import { name } from "./name";
+
+const dotPropertyAccess = new And("dot-property-access", [
+    new Literal("period", "."),
+    name
+]);
+
+const bracketPropertyAccess = new And("bracket-property-access", [
+    new Literal("open-square-bracket", "["),
+    new Reference("expression"),
+    new Literal("close-square-bracket", "]"),
+]);
+
+const propertyAccess = new Or("property-access", [
+    dotPropertyAccess,
+    bracketPropertyAccess,
+]);
+
+export { propertyAccess }