agency-lang 0.0.21 → 0.0.22

package/dist/lib/parsers/ifElse.test.js

@@ -0,0 +1,376 @@
+import { describe, it, expect } from "vitest";
+import { ifParser } from "./function.js";
+describe("ifParser", () => {
+    const testCases = [
+        // Happy path - simple if statements with literals as conditions
+        {
+            input: "if (true) {\n  x = 1\n}",
+            expected: {
+                success: true,
+                result: {
+                    type: "ifElse",
+                    condition: { type: "variableName", value: "true" },
+                    thenBody: [
+                        {
+                            type: "assignment",
+                            variableName: "x",
+                            value: { type: "number", value: "1" },
+                        },
+                        {
+                            type: "newLine",
+                        },
+                    ],
+                    elseBody: undefined,
+                },
+            },
+        },
+        {
+            input: "if (false) {\n  y = 2\n}",
+            expected: {
+                success: true,
+                result: {
+                    type: "ifElse",
+                    condition: { type: "variableName", value: "false" },
+                    thenBody: [
+                        {
+                            type: "assignment",
+                            variableName: "y",
+                            value: { type: "number", value: "2" },
+                        },
+                        {
+                            type: "newLine",
+                        },
+                    ],
+                    elseBody: undefined,
+                },
+            },
+        },
+        {
+            input: "if (x) {\n  foo = 1\n}",
+            expected: {
+                success: true,
+                result: {
+                    type: "ifElse",
+                    condition: { type: "variableName", value: "x" },
+                    thenBody: [
+                        {
+                            type: "assignment",
+                            variableName: "foo",
+                            value: { type: "number", value: "1" },
+                        },
+                        {
+                            type: "newLine",
+                        },
+                    ],
+                    elseBody: undefined,
+                },
+            },
+        },
+        {
+            input: "if (1) {\n  x = 2\n}",
+            expected: {
+                success: true,
+                result: {
+                    type: "ifElse",
+                    condition: { type: "number", value: "1" },
+                    thenBody: [
+                        {
+                            type: "assignment",
+                            variableName: "x",
+                            value: { type: "number", value: "2" },
+                        },
+                        {
+                            type: "newLine",
+                        },
+                    ],
+                    elseBody: undefined,
+                },
+            },
+        },
+        {
+            input: 'if ("yes") {\n  x = 3\n}',
+            expected: {
+                success: true,
+                result: {
+                    type: "ifElse",
+                    condition: { type: "string", segments: [{ type: "text", value: "yes" }] },
+                    thenBody: [
+                        {
+                            type: "assignment",
+                            variableName: "x",
+                            value: { type: "number", value: "3" },
+                        },
+                        {
+                            type: "newLine",
+                        },
+                    ],
+                    elseBody: undefined,
+                },
+            },
+        },
+        // Function calls as conditions
+        {
+            input: "if (isValid()) {\n  x = 1\n}",
+            expected: {
+                success: true,
+                result: {
+                    type: "ifElse",
+                    condition: {
+                        type: "functionCall",
+                        functionName: "isValid",
+                        arguments: [],
+                    },
+                    thenBody: [
+                        {
+                            type: "assignment",
+                            variableName: "x",
+                            value: { type: "number", value: "1" },
+                        },
+                        {
+                            type: "newLine",
+                        },
+                    ],
+                    elseBody: undefined,
+                },
+            },
+        },
+        // Access expressions as conditions
+        {
+            input: "if (obj.isReady) {\n  x = 1\n}",
+            expected: {
+                success: true,
+                result: {
+                    type: "ifElse",
+                    condition: {
+                        type: "accessExpression",
+                        expression: {
+                            type: "dotProperty",
+                            object: { type: "variableName", value: "obj" },
+                            propertyName: "isReady",
+                        },
+                    },
+                    thenBody: [
+                        {
+                            type: "assignment",
+                            variableName: "x",
+                            value: { type: "number", value: "1" },
+                        },
+                        {
+                            type: "newLine",
+                        },
+                    ],
+                    elseBody: undefined,
+                },
+            },
+        },
+        // Index access as conditions
+        // TODO fix
+        /* {
+          input: "if (arr[0]) {\n  x = 1\n}",
+          expected: {
+            success: true,
+            result: {
+              type: "ifElse",
+              condition: {
+                type: "indexAccess",
+                object: { type: "variableName", value: "arr" },
+                index: { type: "number", value: "0" },
+              },
+              thenBody: [
+                {
+                  type: "assignment",
+                  variableName: "x",
+                  value: { type: "number", value: "1" },
+                },
+              ],
+              elseBody: undefined,
+            },
+          },
+        },
+     */
+        // Empty bodies
+        {
+            input: "if (true) {\n}",
+            expected: {
+                success: true,
+                result: {
+                    type: "ifElse",
+                    condition: { type: "variableName", value: "true" },
+                    thenBody: [],
+                    elseBody: undefined,
+                },
+            },
+        },
+        // Multiple statements in bodies
+        {
+            input: "if (x) {\n  a = 1\n  b = 2\n  c = 3\n}",
+            expected: {
+                success: true,
+                result: {
+                    type: "ifElse",
+                    condition: { type: "variableName", value: "x" },
+                    thenBody: [
+                        {
+                            type: "assignment",
+                            variableName: "a",
+                            value: { type: "number", value: "1" },
+                        },
+                        {
+                            type: "newLine",
+                        },
+                        {
+                            type: "assignment",
+                            variableName: "b",
+                            value: { type: "number", value: "2" },
+                        },
+                        {
+                            type: "newLine",
+                        },
+                        {
+                            type: "assignment",
+                            variableName: "c",
+                            value: { type: "number", value: "3" },
+                        },
+                        {
+                            type: "newLine",
+                        },
+                    ],
+                    elseBody: undefined,
+                },
+            },
+        },
+        // Whitespace variations
+        {
+            input: "if(x){\n  foo = 1\n}",
+            expected: {
+                success: true,
+                result: {
+                    type: "ifElse",
+                    condition: { type: "variableName", value: "x" },
+                    thenBody: [
+                        {
+                            type: "assignment",
+                            variableName: "foo",
+                            value: { type: "number", value: "1" },
+                        },
+                        {
+                            type: "newLine",
+                        },
+                    ],
+                    elseBody: undefined,
+                },
+            },
+        },
+        {
+            input: "if  (  x  )  {\n  foo = 1\n}",
+            expected: {
+                success: true,
+                result: {
+                    type: "ifElse",
+                    condition: { type: "variableName", value: "x" },
+                    thenBody: [
+                        {
+                            type: "assignment",
+                            variableName: "foo",
+                            value: { type: "number", value: "1" },
+                        },
+                        {
+                            type: "newLine",
+                        },
+                    ],
+                    elseBody: undefined,
+                },
+            },
+        },
+        {
+            input: "if(x){\nfoo=1\n}",
+            expected: {
+                success: true,
+                result: {
+                    type: "ifElse",
+                    condition: { type: "variableName", value: "x" },
+                    thenBody: [
+                        {
+                            type: "assignment",
+                            variableName: "foo",
+                            value: { type: "number", value: "1" },
+                        },
+                        {
+                            type: "newLine",
+                        },
+                    ],
+                    elseBody: undefined,
+                },
+            },
+        },
+        // Failure cases - missing parentheses
+        {
+            input: "if x {\n  foo = 1\n}",
+            expected: { success: false },
+        },
+        {
+            input: "if (x {\n  foo = 1\n}",
+            expected: { success: false },
+        },
+        {
+            input: "if x) {\n  foo = 1\n}",
+            expected: { success: false },
+        },
+        // Failure cases - missing braces
+        {
+            input: "if (x) \n  foo = 1\n",
+            expected: { success: false },
+        },
+        {
+            input: "if (x) {\n  foo = 1",
+            expected: { success: false },
+        },
+        {
+            input: "if (x) \n  foo = 1\n}",
+            expected: { success: false },
+        },
+        // Failure cases - missing condition
+        {
+            input: "if () {\n  foo = 1\n}",
+            expected: { success: false },
+        },
+        // Failure cases - empty or malformed
+        {
+            input: "",
+            expected: { success: false },
+        },
+        {
+            input: "if",
+            expected: { success: false },
+        },
+        {
+            input: "if ()",
+            expected: { success: false },
+        },
+        {
+            input: "if (x)",
+            expected: { success: false },
+        },
+        {
+            input: "if (x) {}else",
+            expected: { success: false },
+        },
+    ];
+    testCases.forEach(({ input, expected }) => {
+        if (expected.success) {
+            it(`should parse "${input.replace(/\n/g, "\\n")}" successfully`, () => {
+                const result = ifParser(input);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.result).toEqual(expected.result);
+                }
+            });
+        }
+        else {
+            it(`should fail to parse "${input.replace(/\n/g, "\\n")}"`, () => {
+                const result = ifParser(input);
+                expect(result.success).toBe(false);
+            });
+        }
+    });
+});

package/dist/lib/parsers/importStatement.js

@@ -1,3 +1,3 @@
-import { capture, many1Till, oneOf, seqC, set, spaces, str, trace, } from "tarsec";
+import { capture, many1Till, newline, oneOf, optional, seqC, set, spaces, str, trace, } from "tarsec";
 import { optionalSemicolon } from "./parserUtils.js";
-export const importStatmentParser = trace("importStatement", seqC(set("type", "importStatement"), str("import"), spaces, capture(many1Till(str("from")), "importedNames"), str("from"), spaces, capture(many1Till(oneOf(";\n")), "modulePath"), optionalSemicolon));
+export const importStatmentParser = trace("importStatement", seqC(set("type", "importStatement"), str("import"), spaces, capture(many1Till(str("from")), "importedNames"), str("from"), spaces, capture(many1Till(oneOf(";\n")), "modulePath"), optionalSemicolon, optional(newline)));

package/dist/lib/parsers/literals.d.ts

@@ -1,6 +1,7 @@
 import { InterpolationSegment, Literal, MultiLineStringLiteral, NumberLiteral, PromptLiteral, StringLiteral, TextSegment, VariableNameLiteral } from "../types.js";
 import { Parser } from "tarsec";
 export declare const textSegmentParser: Parser<TextSegment>;
+export declare const stringTextSegmentParser: Parser<TextSegment>;
 export declare const interpolationSegmentParser: Parser<InterpolationSegment>;
 export declare const promptParser: Parser<PromptLiteral>;
 export declare const numberParser: Parser<NumberLiteral>;

package/dist/lib/parsers/literals.js

@@ -1,13 +1,17 @@
 import { backtick, varNameChar } from "./utils.js";
-import { capture, char, digit, letter, many, many1Till, many1WithJoin, manyTillOneOf, manyTillStr, manyWithJoin, map, or, seq, seqC, set, str, } from "tarsec";
+import { capture, char, digit, letter, many, many1Till, many1WithJoin, manyTillStr, manyWithJoin, map, or, seq, seqC, set, str, } from "tarsec";
 export const textSegmentParser = map(many1Till(or(backtick, char("$"))), (text) => ({
     type: "text",
     value: text,
 }));
+export const stringTextSegmentParser = map(many1Till(or(char('"'), char("$"))), (text) => ({
+    type: "text",
+    value: text,
+}));
 export const interpolationSegmentParser = seqC(set("type", "interpolation"), char("$"), char("{"), capture(manyTillStr("}"), "variableName"), char("}"));
 export const promptParser = seqC(set("type", "prompt"), backtick, capture(many(or(textSegmentParser, interpolationSegmentParser)), "segments"), backtick);
 export const numberParser = seqC(set("type", "number"), capture(many1WithJoin(or(char("-"), char("."), digit)), "value"));
-export const stringParser = seqC(set("type", "string"), char('"'), capture(manyTillOneOf(['"', "\n"]), "value"), char('"'));
+export const stringParser = seqC(set("type", "string"), char('"'), capture(many(or(stringTextSegmentParser, interpolationSegmentParser)), "segments"), char('"'));
 export const multiLineStringParser = seqC(set("type", "multiLineString"), str('"""'), capture(manyTillStr('"""'), "value"), str('"""'));
 export const variableNameParser = seq([
     set("type", "variableName"),

package/dist/lib/parsers/literals.test.js

@@ -363,62 +363,143 @@ describe("literals parsers", () => {
             // Happy path
             {
                 input: '"hello"',
-                expected: { success: true, result: { type: "string", value: "hello" } },
+                expected: {
+                    success: true,
+                    result: {
+                        type: "string",
+                        segments: [{ type: "text", value: "hello" }],
+                    },
+                },
             },
             {
                 input: '"world"',
-                expected: { success: true, result: { type: "string", value: "world" } },
+                expected: {
+                    success: true,
+                    result: {
+                        type: "string",
+                        segments: [{ type: "text", value: "world" }],
+                    },
+                },
             },
             {
                 input: '"Hello, World!"',
                 expected: {
                     success: true,
-                    result: { type: "string", value: "Hello, World!" },
+                    result: {
+                        type: "string",
+                        segments: [{ type: "text", value: "Hello, World!" }],
+                    },
                 },
             },
             // Empty string
             {
                 input: '""',
-                expected: { success: true, result: { type: "string", value: "" } },
+                expected: {
+                    success: true,
+                    result: { type: "string", segments: [] },
+                },
             },
             // Strings with special characters
             {
                 input: '"123"',
-                expected: { success: true, result: { type: "string", value: "123" } },
+                expected: {
+                    success: true,
+                    result: {
+                        type: "string",
+                        segments: [{ type: "text", value: "123" }],
+                    },
+                },
             },
             {
                 input: '"  spaces  "',
                 expected: {
                     success: true,
-                    result: { type: "string", value: "  spaces  " },
+                    result: {
+                        type: "string",
+                        segments: [{ type: "text", value: "  spaces  " }],
+                    },
                 },
             },
             {
                 input: '"tab\there"',
                 expected: {
                     success: true,
-                    result: { type: "string", value: "tab\there" },
+                    result: {
+                        type: "string",
+                        segments: [{ type: "text", value: "tab\there" }],
+                    },
                 },
             },
             {
-                input: '"special!@#$%^&*()"',
+                input: '"special!@#%^&*()"',
                 expected: {
                     success: true,
-                    result: { type: "string", value: "special!@#$%^&*()" },
+                    result: {
+                        type: "string",
+                        segments: [{ type: "text", value: "special!@#%^&*()" }],
+                    },
                 },
             },
             {
                 input: '"single\'quote"',
                 expected: {
                     success: true,
-                    result: { type: "string", value: "single'quote" },
+                    result: {
+                        type: "string",
+                        segments: [{ type: "text", value: "single'quote" }],
+                    },
                 },
             },
             {
                 input: '"`backtick`"',
                 expected: {
                     success: true,
-                    result: { type: "string", value: "`backtick`" },
+                    result: {
+                        type: "string",
+                        segments: [{ type: "text", value: "`backtick`" }],
+                    },
+                },
+            },
+            // Strings with interpolation
+            {
+                input: '"Hello ${name}"',
+                expected: {
+                    success: true,
+                    result: {
+                        type: "string",
+                        segments: [
+                            { type: "text", value: "Hello " },
+                            { type: "interpolation", variableName: "name" },
+                        ],
+                    },
+                },
+            },
+            {
+                input: '"${greeting} world"',
+                expected: {
+                    success: true,
+                    result: {
+                        type: "string",
+                        segments: [
+                            { type: "interpolation", variableName: "greeting" },
+                            { type: "text", value: " world" },
+                        ],
+                    },
+                },
+            },
+            {
+                input: '"The value is ${x} and ${y}"',
+                expected: {
+                    success: true,
+                    result: {
+                        type: "string",
+                        segments: [
+                            { type: "text", value: "The value is " },
+                            { type: "interpolation", variableName: "x" },
+                            { type: "text", value: " and " },
+                            { type: "interpolation", variableName: "y" },
+                        ],
+                    },
                 },
             },
             // Failure cases
@@ -427,13 +508,6 @@ describe("literals parsers", () => {
             { input: "'hello'", expected: { success: false } },
             { input: "", expected: { success: false } },
             { input: "hello", expected: { success: false } },
-            /// use """ for multi-line strings
-            {
-                input: '"newline\nhere"',
-                expected: {
-                    success: false,
-                },
-            },
         ];
         testCases.forEach(({ input, expected }) => {
             if (expected.success) {
@@ -755,11 +829,20 @@ describe("literals parsers", () => {
             // String literals
             {
                 input: '"hello"',
-                expected: { success: true, result: { type: "string", value: "hello" } },
+                expected: {
+                    success: true,
+                    result: {
+                        type: "string",
+                        segments: [{ type: "text", value: "hello" }],
+                    },
+                },
             },
             {
                 input: '""',
-                expected: { success: true, result: { type: "string", value: "" } },
+                expected: {
+                    success: true,
+                    result: { type: "string", segments: [] },
+                },
             },
             // Variable name literals (lowest precedence)
             {
@@ -784,7 +867,13 @@ describe("literals parsers", () => {
             // Strings vs other types
             {
                 input: '"123"',
-                expected: { success: true, result: { type: "string", value: "123" } },
+                expected: {
+                    success: true,
+                    result: {
+                        type: "string",
+                        segments: [{ type: "text", value: "123" }],
+                    },
+                },
             },
             // Failure cases
             { input: "", expected: { success: false } },

package/dist/lib/parsers/matchBlock.js

@@ -9,16 +9,19 @@ export type MatchBlock = {
 };
 */
 import { capture, char, newline, or, sepBy, seqC, set, str, } from "tarsec";
-import { optionalSpaces } from "./utils.js";
+import { optionalSpaces, optionalSpacesOrNewline } from "./utils.js";
 import { literalParser } from "./literals.js";
-import { assignmentParser } from "./assignment.js";
 import { functionCallParser } from "./functionCall.js";
 import { accessExpressionParser, indexAccessParser } from "./access.js";
 import { optionalSemicolon } from "./parserUtils.js";
 import { agencyArrayParser, agencyObjectParser } from "./dataStructures.js";
 import { commentParser } from "./comment.js";
 import { returnStatementParser } from "./returnStatement.js";
+import { assignmentParser } from "./function.js";
 export const defaultCaseParser = char("_");
-export const matchBlockParserCase = seqC(set("type", "matchBlockCase"), optionalSpaces, capture(or(defaultCaseParser, indexAccessParser, accessExpressionParser, literalParser), "caseValue"), optionalSpaces, str("=>"), optionalSpaces, capture(or(returnStatementParser, agencyArrayParser, agencyObjectParser, accessExpressionParser, assignmentParser, functionCallParser, literalParser), "body"));
+export const matchBlockParserCase = (input) => {
+    const parser = seqC(set("type", "matchBlockCase"), optionalSpaces, capture(or(defaultCaseParser, indexAccessParser, accessExpressionParser, literalParser), "caseValue"), optionalSpaces, str("=>"), optionalSpaces, capture(or(returnStatementParser, agencyArrayParser, agencyObjectParser, accessExpressionParser, assignmentParser, functionCallParser, literalParser), "body"));
+    return parser(input);
+};
 const semicolon = seqC(optionalSpaces, char(";"), optionalSpaces);
-export const matchBlockParser = seqC(set("type", "matchBlock"), str("match"), optionalSpaces, char("("), capture(literalParser, "expression"), char(")"), optionalSpaces, char("{"), optionalSpaces, capture(sepBy(or(semicolon, newline), or(commentParser, matchBlockParserCase)), "cases"), optionalSpaces, char("}"), optionalSemicolon);
+export const matchBlockParser = seqC(set("type", "matchBlock"), str("match"), optionalSpaces, char("("), capture(literalParser, "expression"), char(")"), optionalSpaces, char("{"), optionalSpacesOrNewline, capture(sepBy(or(semicolon, newline), or(commentParser, matchBlockParserCase)), "cases"), optionalSpaces, char("}"), optionalSemicolon);