chore: overhaul custom function system & return failure when invalid …

…arguments
iyxan23 · Sep 16, 2024 · dec7687 · dec7687
1 parent 9f71aa7
commit dec7687
Show file tree

Hide file tree

Showing 4 changed files with 39 additions and 28 deletions.
diff --git a/src/sheet/expression/evaluate.test.ts b/src/sheet/expression/evaluate.test.ts
@@ -250,11 +250,11 @@ describe("expression evaluation", () => {
               return s((vName: string) =>
                 vName === "world" ? "people!" : undefined,
               );
-            }).call
+            })
           : fName === "ret"
             ? createTemplaterFunction(z.tuple([z.string()]), (s) => {
                 return success(`ret ${s}`);
-              }).call
+              })
             : undefined,
       (_vName) => undefined,
     );
@@ -322,7 +322,7 @@ describe("expression evaluation", () => {
       { col: 0, row: 0, callTree: ["root"] },
       (fName) =>
         fName === "getHow"
-          ? createTemplaterNoArgsFunction(() => "how").call
+          ? createTemplaterNoArgsFunction(() => "how")
           : undefined,
       (vName) =>
         vName === "var"
@@ -396,13 +396,13 @@ describe("expression evaluation", () => {
 
               return success(r, issues);
             },
-          ).call,
+          ),
           join: createTemplaterFunction(
             z.tuple([z.array(z.string()), z.string()]),
             (strings, sep) => {
               return success(strings.join(sep));
             },
-          ).call,
+          ),
         })[fName],
       (vName) =>
         vName === "students"

diff --git a/src/sheet/expression/evaluate.ts b/src/sheet/expression/evaluate.ts
@@ -8,9 +8,16 @@ export type Issue = {
   index?: number;
 };
 
-export type TemplaterFunction<R> = {
-  call: (funcName: string, ...args: any[]) => Result<R>;
+export type TemplaterFunctionContext = {
+  functionName: string;
+  col: number;
+  row: number;
+  callTree: string[];
 };
+export type TemplaterFunction<R> = (
+  context: TemplaterFunctionContext,
+  ...args: any[]
+) => Result<R>;
 
 export type LambdaFunction<T> = (
   lookupLocalVariable?: (name: string) => any,
@@ -21,7 +28,7 @@ export function evaluateExpression(
   context: { col: number; row: number; callTree: string[] },
   lookupFunction: (
     funcName: string,
-  ) => TemplaterFunction<any>["call"] | undefined,
+  ) => TemplaterFunction<any> | undefined,
   lookupVariable: (name: string) => any | undefined,
 ): Result<any | undefined> {
   if (
@@ -112,7 +119,10 @@ export function evaluateExpression(
       ]);
     }
 
-    let result = func(item.identifier, ...funcArgs);
+    let result = func(
+      { functionName: item.identifier, ...context },
+      ...funcArgs,
+    );
 
     if (result.status === "failed") {
       return result;

diff --git a/src/sheet/sheet-templater.ts b/src/sheet/sheet-templater.ts
@@ -105,7 +105,7 @@ export class SheetTemplater<SheetT extends TemplatableCell> {
       const sheetCell = this.sheet.getCell(col, row);
       if (sheetCell === null) {
         throw new Error(
-          `cannot find the cell referenced by variable hoist on` +
+          `fatal: cannot find the cell referenced by variable hoist on` +
             ` col ${col} row ${row}`,
         );
       }
@@ -117,7 +117,7 @@ export class SheetTemplater<SheetT extends TemplatableCell> {
           row,
           callTree: [`hoisted variable \`${expr.identifier}\``],
         },
-        (funcName) => this.functions[funcName]?.call,
+        (funcName) => this.functions[funcName],
         (variableName) => globalVariables[variableName] ?? data[variableName],
       );
 
@@ -138,7 +138,7 @@ export class SheetTemplater<SheetT extends TemplatableCell> {
     const expandBlocksResult = this.expandBlocks(
       parsedExpressions,
       blocks,
-      (fName) => this.functions[fName]?.call,
+      (fName) => this.functions[fName],
       (vName) => globalVariables[vName] ?? data[vName],
       sheetShiftEmitter,
     );
@@ -189,7 +189,7 @@ export class SheetTemplater<SheetT extends TemplatableCell> {
     blocks: Block[],
     lookupFunction: (
       name: string,
-    ) => TemplaterFunction<any>["call"] | undefined,
+    ) => TemplaterFunction<any> | undefined,
     lookupVariable: (name: string) => any | undefined,
     sheetShiftEmitter: SheetShiftEmitter,
   ): Result<Indexable2DArray<Record<string, any>>> {
@@ -451,7 +451,7 @@ export class SheetTemplater<SheetT extends TemplatableCell> {
       const evalResult = evaluateExpression(
         item,
         { ...context, callTree: ["<root>"] },
-        (funcName) => this.functions[funcName]?.call,
+        (funcName) => this.functions[funcName],
         lookupVariable,
       );
 

diff --git a/src/sheet/templater-function.ts b/src/sheet/templater-function.ts
@@ -1,13 +1,11 @@
 import { z } from "zod";
 import { LambdaFunction, TemplaterFunction } from "./expression/evaluate";
-import { Result, success } from "./expression/result";
+import { failure, Result, success } from "./expression/result";
 
 export function createTemplaterNoArgsFunction<R>(
   call: () => R,
 ): TemplaterFunction<R> {
-  return {
-    call: () => success(call()),
-  };
+  return () => success(call());
 }
 
 /**
@@ -80,17 +78,20 @@ export function createTemplaterFunction<T extends z.AnyZodTuple, R>(
   schema: T,
   call: (...args: MapFunctionsToLambdas<z.infer<T>>) => Result<R>,
 ): TemplaterFunction<R> {
-  return {
-    call: (funcName, ...args: any) => {
-      const result = schema.safeParse(args);
+  return ({ functionName, ...context }, ...args: any) => {
+    const result = schema.safeParse(args);
 
-      if (!result.success) {
-        throw new Error(
-          `invalid arguments when evaluating function \`${funcName}\`: ${result.error}`,
-        );
-      }
+    if (!result.success) {
+      return failure(
+        {
+          message: `Invalid arguments while calling ${functionName}. trace: ${context.callTree.join(" > ")}`,
+          col: context.col,
+          row: context.row,
+        },
+        [],
+      );
+    }
 
-      return call(...(result.data as MapFunctionsToLambdas<z.infer<T>>));
-    },
+    return call(...(result.data as MapFunctionsToLambdas<z.infer<T>>));
   };
 }