fix(IBaseType): Add toString implementation to all current IBaseTypes…

…, including functions, for better runtime printability
imnotteixeira · Jan 29, 2024 · 87d9c54 · 87d9c54
1 parent ff86d4b
commit 87d9c54
Show file tree

Hide file tree

Showing 9 changed files with 30 additions and 11 deletions.
diff --git a/src/grammar/functions/base/Add.ts b/src/grammar/functions/base/Add.ts
@@ -1,5 +1,5 @@
 import type { Index } from "parsimmon";
-import { IBaseType, Types, ValueResolvingResult } from "../../definitions";
+import { IBaseType, NumberType, Types, ValueResolvingResult } from "../../definitions";
 import { ValidationError } from "../validator";
 import { FunctionArgsValidator, FunctionType, IFunctionArg } from "../types";
 import { CommonValidators, PipelineValidator } from "../validator/pipeline";
@@ -13,7 +13,7 @@ export class AddFunction extends FunctionType<number> {
         super(indexInfo, "Add", args);
     }
 
-    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+    getValue = (dependencyValueMap: Map<string, any>) => {
         try {
             const resolvedValues = resolveValuesOnlyNumbers(this.args.map(arg => arg.getValue(dependencyValueMap)))
             return ValueResolvingResult.success(resolvedValues[0] + resolvedValues[1]);
@@ -32,4 +32,6 @@ export class AddFunction extends FunctionType<number> {
         if(validationResult) return onFailure(validationResult)
         else return onSuccess();
     };
+
+    toString = () => `AddFunction(${this.args.map(arg => arg.toString()).join(",")})`;
 }
diff --git a/src/grammar/functions/base/Concat.ts b/src/grammar/functions/base/Concat.ts
@@ -8,7 +8,7 @@ export class ConcatFunction extends FunctionType<string> {
         super(indexInfo, "CONCAT", args);
     }
 
-    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+    getValue = (dependencyValueMap: Map<string, any>) => {
         try {
             return ValueResolvingResult.success(
                 this.args.reduce((acc, arg) => acc + arg.getValue(dependencyValueMap).getOrElse(""), "")
@@ -17,4 +17,6 @@ export class ConcatFunction extends FunctionType<string> {
             return ValueResolvingResult.error<string>(e as Error)
         }
     }
+
+    toString = () => `ConcatFunction(${this.args.map(arg => arg.toString()).join(",")})`;
 }
diff --git a/src/grammar/functions/base/Divide.ts b/src/grammar/functions/base/Divide.ts
@@ -13,7 +13,7 @@ export class DivideFunction extends FunctionType<number> {
         super(indexInfo, "Divide", args);
     }
 
-    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+    getValue = (dependencyValueMap: Map<string, any>) => {
         try {
             const resolvedValues = resolveValuesOnlyNumbers(this.args.map(arg => arg.getValue(dependencyValueMap)))
             return ValueResolvingResult.success(resolvedValues[0] / resolvedValues[1]);
@@ -32,4 +32,6 @@ export class DivideFunction extends FunctionType<number> {
         if(validationResult) return onFailure(validationResult)
         else return onSuccess();
     };
+
+    toString = () => `DivideFunction(${this.args.map(arg => arg.toString()).join(",")})`;
 }
diff --git a/src/grammar/functions/base/Exponentiate.ts b/src/grammar/functions/base/Exponentiate.ts
@@ -13,7 +13,7 @@ export class ExponentiateFunction extends FunctionType<number> {
         super(indexInfo, "Exponentiate", args);
     }
 
-    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+    getValue = (dependencyValueMap: Map<string, any>) => {
         try {
             const resolvedValues = resolveValuesOnlyNumbers(this.args.map(arg => arg.getValue(dependencyValueMap)))
             return ValueResolvingResult.success(Math.pow(resolvedValues[0], resolvedValues[1]));
@@ -32,4 +32,6 @@ export class ExponentiateFunction extends FunctionType<number> {
         if(validationResult) return onFailure(validationResult)
         else return onSuccess();
     };
+
+    toString = () => `ExponentiateFunction(${this.args.map(arg => arg.toString()).join(",")})`;
 }
diff --git a/src/grammar/functions/base/Factorial.ts b/src/grammar/functions/base/Factorial.ts
@@ -13,7 +13,7 @@ export class FactorialFunction extends FunctionType<number> {
         super(indexInfo, "Factorial", args);
     }
 
-    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+    getValue = (dependencyValueMap: Map<string, any>) => {
         try {
             const resolvedValues = resolveValuesOnlyNumbers([this.args[0].getValue(dependencyValueMap)])
             return ValueResolvingResult.success(this.calculateFactorial(resolvedValues[0]));
@@ -40,4 +40,6 @@ export class FactorialFunction extends FunctionType<number> {
         return num * this.calculateFactorial(num - 1);
     };
 
+    toString = () => `FactorialFunction(${this.args.map(arg => arg.toString()).join(",")})`;
+
 }
diff --git a/src/grammar/functions/base/Multiply.ts b/src/grammar/functions/base/Multiply.ts
@@ -12,7 +12,7 @@ export class MultiplyFunction extends FunctionType<number> {
         super(indexInfo, "Multiply", args);
     }
 
-    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+    getValue = (dependencyValueMap: Map<string, any>) => {
         try {
             const resolvedValues = resolveValuesOnlyNumbers(this.args.map(arg => arg.getValue(dependencyValueMap)))
             return ValueResolvingResult.success(resolvedValues[0] * resolvedValues[1]);
@@ -31,4 +31,6 @@ export class MultiplyFunction extends FunctionType<number> {
         if(validationResult) return onFailure(validationResult)
         else return onSuccess();
     };
+
+    toString = () => `MultiplyFunction(${this.args.map(arg => arg.toString()).join(",")})`;
 }
diff --git a/src/grammar/functions/base/Negate.ts b/src/grammar/functions/base/Negate.ts
@@ -14,7 +14,7 @@ export class NegateFunction extends FunctionType<number> {
     }
 
 
-    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+    getValue = (dependencyValueMap: Map<string, any>) => {
         try {
             const resolvedValues = resolveValuesOnlyNumbers([this.args[0].getValue(dependencyValueMap)])
             return ValueResolvingResult.success(-resolvedValues[0]);
@@ -34,4 +34,6 @@ export class NegateFunction extends FunctionType<number> {
         if(validationResult) return onFailure(validationResult)
         else return onSuccess();
     };
+
+    toString = () => `NegateFunction(${this.args.map(arg => arg.toString()).join(",")})`;
 }
diff --git a/src/grammar/functions/base/Subtract.ts b/src/grammar/functions/base/Subtract.ts
@@ -13,7 +13,7 @@ export class SubtractFunction extends FunctionType<number> {
         super(indexInfo, "Subtract", args);
     }
 
-    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+    getValue = (dependencyValueMap: Map<string, any>) => {
         try {
             const resolvedValues = resolveValuesOnlyNumbers(this.args.map(arg => arg.getValue(dependencyValueMap)))
             return ValueResolvingResult.success(resolvedValues[0] - resolvedValues[1]);
@@ -32,4 +32,6 @@ export class SubtractFunction extends FunctionType<number> {
         if(validationResult) return onFailure(validationResult)
         else return onSuccess();
     };
+
+    toString = () => `SubtractFunction(${this.args.map(arg => arg.toString()).join(",")})`;
 }
diff --git a/src/grammar/functions/types.ts b/src/grammar/functions/types.ts
@@ -5,11 +5,12 @@ import { PipelineValidator, validationPipeline } from "./validator/pipeline";
 
 export type IFunctionArg<T> = IExpressionType<T>;
 
+type ReturnableTypes = Types.NUMBER | Types.STRING
 export interface IFunction<T> extends IBaseType<T> {
     type: Types.FUNCTION;
     fn: string;
     args: IFunctionArg<any>[];
-    returnType: Types;
+    returnType: ReturnableTypes;
 }
 
 export type FunctionArgsValidator = (validator: PipelineValidator, _: IFunctionArg<any>[], onSuccess: () => void, onFailure: (errors: ValidationError[]) => void) => void;
@@ -18,7 +19,7 @@ export abstract class FunctionType<T> extends BaseType<T> implements IFunction<T
     readonly type = Types.FUNCTION;
     readonly fn: string;
     readonly args: IFunctionArg<any>[];
-    abstract readonly returnType: Types;
+    abstract readonly returnType: ReturnableTypes;
 
     constructor(indexInfo: Index, fn: string, args: IFunctionArg<any>[]) {
         super(indexInfo);
@@ -45,4 +46,6 @@ export abstract class FunctionType<T> extends BaseType<T> implements IFunction<T
 
     // Optional function that child-classes can override to define their own validation
     protected validateArgs: FunctionArgsValidator = (validator: PipelineValidator, _: IFunctionArg<any>[], onSuccess: () => void, onFailure: (errors: ValidationError[]) => void) => onSuccess();
+
+    toString = () => `[MISSING TOSTRING IMPL] :: Function(${this.args.map(arg => arg.toString()).join(",")})`;
 }