agency-lang 0.0.15 → 0.0.16

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

@@ -0,0 +1,279 @@
+import { describe, it, expect } from "vitest";
+import { assignmentParser } from "./assignment.js";
+describe("assignmentParser", () => {
+    const testCases = [
+        // Happy path - simple literal assignments
+        {
+            input: "x = 5",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "x",
+                    value: { type: "number", value: "5" },
+                },
+            },
+        },
+        {
+            input: 'name = "Alice"',
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "name",
+                    value: { type: "string", value: "Alice" },
+                },
+            },
+        },
+        {
+            input: "bar = `the number 1`",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "bar",
+                    value: {
+                        type: "prompt",
+                        segments: [{ type: "text", value: "the number 1" }],
+                    },
+                },
+            },
+        },
+        {
+            input: "result = someVariable",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "result",
+                    value: { type: "variableName", value: "someVariable" },
+                },
+            },
+        },
+        // With optional semicolon
+        {
+            input: "x = 42;",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "x",
+                    value: { type: "number", value: "42" },
+                },
+            },
+        },
+        // With optional spaces
+        {
+            input: "  x  =  5  ",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "x",
+                    value: { type: "number", value: "5" },
+                },
+            },
+        },
+        {
+            input: "x=5",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "x",
+                    value: { type: "number", value: "5" },
+                },
+            },
+        },
+        // Variable names with underscores and numbers
+        {
+            input: "my_var_123 = 999",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "my_var_123",
+                    value: { type: "number", value: "999" },
+                },
+            },
+        },
+        {
+            input: "_privateVar = true",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "_privateVar",
+                    value: { type: "variableName", value: "true" },
+                },
+            },
+        },
+        // Function call assignment
+        {
+            input: "result = foo()",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "result",
+                    value: {
+                        type: "functionCall",
+                        functionName: "foo",
+                        arguments: [],
+                    },
+                },
+            },
+        },
+        {
+            input: 'output = calculate(1, "test")',
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "output",
+                    value: {
+                        type: "functionCall",
+                        functionName: "calculate",
+                        arguments: [
+                            { type: "number", value: "1" },
+                            { type: "string", value: "test" },
+                        ],
+                    },
+                },
+            },
+        },
+        // Array assignment
+        {
+            input: "arr = [1, 2, 3]",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "arr",
+                    value: {
+                        type: "agencyArray",
+                        items: [
+                            { type: "number", value: "1" },
+                            { type: "number", value: "2" },
+                            { type: "number", value: "3" },
+                        ],
+                    },
+                },
+            },
+        },
+        {
+            input: "empty = []",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "empty",
+                    value: {
+                        type: "agencyArray",
+                        items: [],
+                    },
+                },
+            },
+        },
+        // Object assignment
+        {
+            input: 'obj = { key: "value" }',
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "obj",
+                    value: {
+                        type: "agencyObject",
+                        entries: [
+                            {
+                                key: "key",
+                                value: { type: "string", value: "value" },
+                            },
+                        ],
+                    },
+                },
+            },
+        },
+        {
+            input: "emptyObj = {}",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "emptyObj",
+                    value: {
+                        type: "agencyObject",
+                        entries: [],
+                    },
+                },
+            },
+        },
+        // Access expression assignment
+        {
+            input: "value = obj.property",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "value",
+                    value: {
+                        type: "accessExpression",
+                        expression: {
+                            type: "dotProperty",
+                            object: { type: "variableName", value: "obj" },
+                            propertyName: "property",
+                        },
+                    },
+                },
+            },
+        },
+        // Negative numbers
+        {
+            input: "negative = -42",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "negative",
+                    value: { type: "number", value: "-42" },
+                },
+            },
+        },
+        // Decimal numbers
+        {
+            input: "pi = 3.14",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "pi",
+                    value: { type: "number", value: "3.14" },
+                },
+            },
+        },
+        // Failure cases
+        { input: "=5", expected: { success: false } },
+        { input: "x =", expected: { success: false } },
+        { input: "", expected: { success: false } },
+        { input: "x", expected: { success: false } },
+        { input: "x ==5", expected: { success: false } },
+    ];
+    testCases.forEach(({ input, expected }) => {
+        if (expected.success) {
+            it(`should parse "${input}" successfully`, () => {
+                const result = assignmentParser(input);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.result).toEqual(expected.result);
+                }
+            });
+        }
+        else {
+            it(`should fail to parse "${input}"`, () => {
+                const result = assignmentParser(input);
+                expect(result.success).toBe(false);
+            });
+        }
+    });
+});

package/dist/lib/parsers/dataStructures.js

@@ -1,14 +1,14 @@
 import { capture, char, manyWithJoin, noneOf, optional, or, sepBy, seqC, set, succeed, trace, } from "tarsec";
-import { accessExpressionParser } from "./access.js";
+import { accessExpressionParser, indexAccessParser } 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("]")));
+    const parser = trace("agencyArrayParser", seqC(set("type", "agencyArray"), char("["), capture(sepBy(comma, or(indexAccessParser, 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")));
+    const parser = trace("agencyObjectKVParser", seqC(optionalSpaces, optional(char('"')), capture(manyWithJoin(noneOf('":\n\t ')), "key"), optional(char('"')), optionalSpaces, char(":"), optionalSpaces, capture(or(indexAccessParser, 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("}"));

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

@@ -1,9 +1,11 @@
-import { AgencyNode, DocString, FunctionDefinition } from "../types.js";
+import { AgencyNode, DocString, FunctionDefinition, FunctionParameter } from "../types.js";
 import { Parser } from "tarsec";
 import { GraphNodeDefinition } from "../types/graphNode.js";
 import { WhileLoop } from "../types/whileLoop.js";
 export declare const docStringParser: Parser<DocString>;
 export declare const bodyParser: Parser<AgencyNode[]>;
 export declare const whileLoopParser: Parser<WhileLoop>;
+export declare const functionParameterParserWithTypeHint: Parser<FunctionParameter>;
+export declare const functionParameterParser: Parser<FunctionParameter>;
 export declare const functionParser: Parser<FunctionDefinition>;
 export declare const graphNodeParser: Parser<GraphNodeDefinition>;

package/dist/lib/parsers/function.js

@@ -1,12 +1,12 @@
 import { capture, char, debug, many1, many1Till, many1WithJoin, map, or, sepBy, seqC, set, space, spaces, str, succeed, trace, } from "tarsec";
-import { accessExpressionParser } from "./access.js";
+import { accessExpressionParser, indexAccessParser } from "./access.js";
 import { assignmentParser } from "./assignment.js";
 import { commentParser } from "./comment.js";
 import { functionCallParser } from "./functionCall.js";
 import { literalParser } from "./literals.js";
 import { matchBlockParser } from "./matchBlock.js";
 import { optionalSemicolon } from "./parserUtils.js";
-import { typeAliasParser, typeHintParser } from "./typeHints.js";
+import { typeAliasParser, typeHintParser, variableTypeParser, } from "./typeHints.js";
 import { comma, optionalSpaces, varNameChar } from "./utils.js";
 import { returnStatementParser } from "./returnStatement.js";
 import { usesToolParser } from "./tools.js";
@@ -18,6 +18,8 @@ export const bodyParser = trace("functionBodyParser", (input) => {
     const result = parser(input);
     return result;
 });
-export const whileLoopParser = trace("whileLoopParser", seqC(set("type", "whileLoop"), str("while"), optionalSpaces, char("("), optionalSpaces, capture(or(functionCallParser, accessExpressionParser, literalParser), "condition"), optionalSpaces, char(")"), optionalSpaces, char("{"), spaces, capture(bodyParser, "body"), optionalSpaces, char("}")));
-export const functionParser = trace("functionParser", seqC(set("type", "function"), str("def"), many1(space), capture(many1Till(char("(")), "functionName"), char("("), optionalSpaces, capture(sepBy(comma, many1WithJoin(varNameChar)), "parameters"), optionalSpaces, char(")"), optionalSpaces, char("{"), optionalSpaces, capture(or(docStringParser, succeed(undefined)), "docString"), optionalSpaces, capture(bodyParser, "body"), optionalSpaces, char("}"), optionalSemicolon));
+export const whileLoopParser = trace("whileLoopParser", seqC(set("type", "whileLoop"), str("while"), optionalSpaces, char("("), optionalSpaces, capture(or(indexAccessParser, functionCallParser, accessExpressionParser, literalParser), "condition"), optionalSpaces, char(")"), optionalSpaces, char("{"), spaces, capture(bodyParser, "body"), optionalSpaces, char("}")));
+export const functionParameterParserWithTypeHint = trace("functionParameterParserWithTypeHint", seqC(set("type", "functionParameter"), capture(many1WithJoin(varNameChar), "name"), optionalSpaces, char(":"), optionalSpaces, capture(variableTypeParser, "typeHint")));
+export const functionParameterParser = trace("functionParameterParser", seqC(set("type", "functionParameter"), capture(many1WithJoin(varNameChar), "name")));
+export const functionParser = trace("functionParser", seqC(set("type", "function"), str("def"), many1(space), capture(many1Till(char("(")), "functionName"), char("("), optionalSpaces, capture(sepBy(comma, or(functionParameterParserWithTypeHint, functionParameterParser)), "parameters"), optionalSpaces, char(")"), optionalSpaces, char("{"), optionalSpaces, capture(or(docStringParser, succeed(undefined)), "docString"), optionalSpaces, capture(bodyParser, "body"), optionalSpaces, char("}"), optionalSemicolon));
 export const graphNodeParser = trace("graphNodeParser", seqC(set("type", "graphNode"), str("node"), many1(space), capture(many1Till(char("(")), "nodeName"), char("("), optionalSpaces, capture(or(sepBy(comma, many1WithJoin(varNameChar)), succeed([])), "parameters"), optionalSpaces, char(")"), optionalSpaces, char("{"), optionalSpaces, capture(bodyParser, "body"), optionalSpaces, char("}"), optionalSemicolon));