agency-lang 0.0.1

package/dist/parsers/assignment.js

@@ -0,0 +1,8 @@
+import { capture, char, many1WithJoin, or, seqC, set, trace, } from "tarsec";
+import { accessExpressionParser } from "./access.js";
+import { agencyArrayParser, agencyObjectParser } from "./dataStructures.js";
+import { functionCallParser } from "./functionCall.js";
+import { literalParser } from "./literals.js";
+import { optionalSemicolon } from "./parserUtils.js";
+import { optionalSpaces, varNameChar } from "./utils.js";
+export const assignmentParser = trace("assignmentParser", seqC(set("type", "assignment"), optionalSpaces, capture(many1WithJoin(varNameChar), "variableName"), optionalSpaces, char("="), optionalSpaces, capture(or(functionCallParser, accessExpressionParser, agencyArrayParser, agencyObjectParser, literalParser), "value"), optionalSemicolon));

package/dist/parsers/body.test.js

@@ -0,0 +1,106 @@
+import { describe, expect, it } from "vitest";
+import { bodyParser } from "./function.js";
+describe("functionBodyParser", () => {
+    const testCases = [
+        {
+            input: "foo = 1",
+            expected: {
+                success: true,
+                result: [
+                    {
+                        type: "assignment",
+                        variableName: "foo",
+                        value: { type: "number", value: "1" },
+                    },
+                ],
+            },
+        },
+        {
+            input: 'bar = "hello"',
+            expected: {
+                success: true,
+                result: [
+                    {
+                        type: "assignment",
+                        variableName: "bar",
+                        value: { type: "string", value: "hello" },
+                    },
+                ],
+            },
+        },
+        {
+            input: "bar = `hello`\nfoo",
+            expected: {
+                success: true,
+                result: [
+                    {
+                        type: "assignment",
+                        variableName: "bar",
+                        value: {
+                            type: "prompt",
+                            segments: [{ type: "text", value: "hello" }],
+                        },
+                    },
+                    {
+                        type: "variableName",
+                        value: "foo",
+                    },
+                ],
+            },
+        },
+        {
+            input: "x = 5\ny = 10",
+            expected: {
+                success: true,
+                result: [
+                    {
+                        type: "assignment",
+                        variableName: "x",
+                        value: { type: "number", value: "5" },
+                    },
+                    {
+                        type: "assignment",
+                        variableName: "y",
+                        value: { type: "number", value: "10" },
+                    },
+                ],
+            },
+        },
+        {
+            input: "42",
+            expected: {
+                success: true,
+                result: [
+                    {
+                        type: "number",
+                        value: "42",
+                    },
+                ],
+            },
+        },
+        {
+            input: "",
+            expected: {
+                success: true,
+                result: [],
+            },
+        },
+    ];
+    testCases.forEach(({ input, expected }) => {
+        if (expected.success) {
+            it(`should parse "${input.replace(/\n/g, "\\n")}" successfully`, () => {
+                const result = bodyParser(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 = bodyParser(input);
+                expect(result.success).toBe(false);
+            });
+        }
+    });
+});

package/dist/parsers/comment.js

@@ -0,0 +1,6 @@
+import { seqC, set, str, capture, many1Till, newline } from "tarsec";
+import { optionalSpaces } from "./utils.js";
+export const commentParser = (input) => {
+    const parser = seqC(set("type", "comment"), optionalSpaces, str("//"), capture(many1Till(newline), "content"));
+    return parser(input);
+};

package/dist/parsers/comment.test.js

@@ -0,0 +1,100 @@
+import { describe, expect, it } from "vitest";
+import { commentParser } from "./comment.js";
+describe("commentParser", () => {
+    const testCases = [
+        // Happy path - basic comments
+        {
+            input: "// this is a comment\n",
+            expected: {
+                success: true,
+                result: { type: "comment", content: " this is a comment" },
+            },
+        },
+        {
+            input: "// hello world\n",
+            expected: {
+                success: true,
+                result: { type: "comment", content: " hello world" },
+            },
+        },
+        {
+            input: "//no space after slashes\n",
+            expected: {
+                success: true,
+                result: { type: "comment", content: "no space after slashes" },
+            },
+        },
+        // Comments with special characters
+        {
+            input: "// comment with numbers 123\n",
+            expected: {
+                success: true,
+                result: { type: "comment", content: " comment with numbers 123" },
+            },
+        },
+        {
+            input: "// special chars !@#$%^&*()\n",
+            expected: {
+                success: true,
+                result: { type: "comment", content: " special chars !@#$%^&*()" },
+            },
+        },
+        {
+            input: "// code comment: x = 5\n",
+            expected: {
+                success: true,
+                result: { type: "comment", content: " code comment: x = 5" },
+            },
+        },
+        // Empty comment (fails because many1Till requires at least one char)
+        {
+            input: "//\n",
+            expected: { success: false },
+        },
+        // Comments with tabs and spaces
+        {
+            input: "//   multiple   spaces   \n",
+            expected: {
+                success: true,
+                result: { type: "comment", content: "   multiple   spaces   " },
+            },
+        },
+        {
+            input: "//\ttab character\n",
+            expected: {
+                success: true,
+                result: { type: "comment", content: "\ttab character" },
+            },
+        },
+        // Comments without newline (succeeds, consumes until EOF)
+        {
+            input: "// comment without newline",
+            expected: {
+                success: true,
+                result: { type: "comment", content: " comment without newline" },
+            },
+        },
+        // Failure cases
+        { input: "/ single slash\n", expected: { success: false } },
+        { input: "# not a comment\n", expected: { success: false } },
+        { input: "", expected: { success: false } },
+        { input: "text // comment\n", expected: { success: false } },
+    ];
+    testCases.forEach(({ input, expected }) => {
+        if (expected.success) {
+            it(`should parse "${input.replace(/\n/g, "\\n")}" successfully`, () => {
+                const result = commentParser(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 = commentParser(input);
+                expect(result.success).toBe(false);
+            });
+        }
+    });
+});

package/dist/parsers/dataStructures.js

@@ -0,0 +1,14 @@
+import { capture, char, manyWithJoin, noneOf, optional, or, sepBy, seqC, set, succeed, trace, } from "tarsec";
+import { accessExpressionParser } from "./access.js";
+import { functionCallParser } from "./functionCall.js";
+import { literalParser } from "./literals.js";
+import { comma, optionalSpaces } from "./utils.js";
+export const agencyArrayParser = (input) => {
+    const parser = trace("agencyArrayParser", seqC(set("type", "agencyArray"), char("["), capture(sepBy(comma, or(accessExpressionParser, functionCallParser, literalParser, agencyObjectParser, agencyArrayParser)), "items"), char("]")));
+    return parser(input);
+};
+export const agencyObjectKVParser = (input) => {
+    const parser = trace("agencyObjectKVParser", seqC(optionalSpaces, optional(char('"')), capture(manyWithJoin(noneOf('":\n\t ')), "key"), optional(char('"')), optionalSpaces, char(":"), optionalSpaces, capture(or(accessExpressionParser, functionCallParser, literalParser, agencyObjectParser, agencyArrayParser), "value")));
+    return parser(input);
+};
+export const agencyObjectParser = seqC(set("type", "agencyObject"), char("{"), optionalSpaces, capture(or(sepBy(comma, agencyObjectKVParser), succeed([])), "entries"), optional(char(",")), optionalSpaces, char("}"));