feat(bettermath): Add ref support to lazy evaluation of values, depen…

…ding on external ref-value maps
imnotteixeira · Dec 3, 2023 · f9bf92f · f9bf92f
1 parent fb1e057
commit f9bf92f
Show file tree

Hide file tree

Showing 13 changed files with 354 additions and 129 deletions.
diff --git a/jest.config.js → jest.config.cjs b/jest.config.js → jest.config.cjs
diff --git a/src/grammar/bettermath.ts b/src/grammar/bettermath.ts
@@ -10,6 +10,8 @@ import {
     NumberType,
     IValueType,
     BettermathGrammarParser,
+    IRefType,
+    RefType,
 } from "./definitions";
 import { FunctionType, IFunctionArg } from "./functions/types";
 import { FunctionRegistry } from "./functions";
@@ -262,7 +264,13 @@ const buildGrammar = (functionRegistry: FunctionRegistry): BettermathGrammarPars
         (str: string, indexInfo: Index) => new NumberType(indexInfo, str)
     ).desc("number");
 
-    const ExpressionValue = P.alt<IValueType<number> | IValueType<string>>(Num, QuotedString);
+    const Ref: P.Parser<IRefType> = P.seqMap<string, Index, IRefType>(
+        P.regexp(/[A-Z]+[1-9]+[0-9]*/).notFollowedBy(Word),
+        P.index,
+        (str: string, indexInfo: Index) => new RefType(indexInfo, str)
+    ).desc("ref");
+
+    const ExpressionValue = P.alt<IValueType<number> | IValueType<string>>(Num, QuotedString, Ref);
     const ImmediateValue = P.alt<IValueType<number> | IValueType<string>>(
         Num.notFollowedBy(RawString),
         RawString,

diff --git a/src/grammar/definitions.ts b/src/grammar/definitions.ts
@@ -14,10 +14,41 @@ export enum Types {
 
 type AllowedType = Types;
 
+export class ValueResolvingResult<T> {
+    readonly isError: boolean;
+    readonly value?: T;
+    readonly error?: Error;
+
+    private constructor(isError: boolean, result?: {value? : T, error?: Error}) {
+        this.isError = isError;
+        this.value = result?.value;
+        this.error = result?.error;
+    }
+
+    static success = <T>(value: T) => new ValueResolvingResult(false, {value});
+
+    static error = <T>(error: Error) => new ValueResolvingResult<T>(true, {error});
+
+    get = () => {
+        if (this.isError) {
+            throw new Error(
+                "The ValueResolvingResult is an error. Cannot get value. Inner error is: "
+                + this.error
+            );
+        }
+
+        return this.value as T;
+    }
+
+    getOrElse = (elseValue: T) => this.isError ? elseValue : this.value;
+
+    getError = () => this.error;
+}
+
 export interface IBaseType<T> {
     type: AllowedType;
     indexInfo: Index;
-    getValue: () => T;
+    getValue: (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => ValueResolvingResult<T>;
 
     validate: () => ValidationResult;
 
@@ -28,7 +59,7 @@ export abstract class BaseType<T> implements IBaseType<T> {
     abstract type: AllowedType;
     readonly indexInfo: Index;
 
-    abstract getValue: () => T;
+    abstract getValue: (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => ValueResolvingResult<T>;
     abstract validate: () => ValidationResult;
 
     constructor(indexInfo: Index) {
@@ -69,7 +100,7 @@ export class StringType extends BaseType<string> implements IStringType {
         this.value = str;
     }
 
-    getValue = () => this.value;
+    getValue = () => ValueResolvingResult.success(this.value);
     validate = () => makeSuccess();
 }
 
@@ -87,7 +118,35 @@ export class NumberType extends BaseType<number> implements INumberType {
         this.value = Number(num);
     }
 
-    getValue = () => this.value;
+    getValue = () => ValueResolvingResult.success(this.value);
+    validate = () => makeSuccess();
+}
+
+export interface IRefType extends IBaseType<any|undefined> {
+    type: Types.REF;
+    value: any| undefined;
+}
+
+export class RefType extends BaseType<any | undefined> implements IRefType {
+    readonly type = Types.REF;
+    readonly value: string;
+
+    constructor(indexInfo: Index, refId: string) {
+        super(indexInfo);
+        this.value = refId;
+    }
+
+    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+        const referencedElem = dependencyValueMap.get(this.value);
+        if (!referencedElem) {
+            // Returning undefined value as success, since some functions may take advanatage of this, even though the value does not exist.
+            // Specific ValueResolvingResult.error will be returned if some function is processing an undefined Ref when it can't
+            return ValueResolvingResult.success(undefined)
+        } else {
+            return referencedElem.getValue(dependencyValueMap)
+        }
+    }
+
     validate = () => makeSuccess();
 }
 

diff --git a/src/grammar/functions/base/Add.ts b/src/grammar/functions/base/Add.ts
@@ -1,9 +1,10 @@
 import type { Index } from "parsimmon";
-import { Types } from "../../definitions";
+import { IBaseType, Types, ValueResolvingResult } from "../../definitions";
 import { ValidationError } from "../validator";
 import { FunctionArgsValidator, FunctionType, IFunctionArg } from "../types";
 import { CommonValidators, PipelineValidator } from "../validator/pipeline";
 import { is } from "../validator/argTypeValidator";
+import { resolveValuesOnlyNumbers } from "../util";
 
 export class AddFunction extends FunctionType<number> {
     readonly returnType = Types.NUMBER;
@@ -12,7 +13,14 @@ export class AddFunction extends FunctionType<number> {
         super(indexInfo, "Add", args);
     }
 
-    getValue = () => this.args[0].getValue() + this.args[1].getValue();
+    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+        try {
+            const resolvedValues = resolveValuesOnlyNumbers(this.args.map(arg => arg.getValue(dependencyValueMap)))
+            return ValueResolvingResult.success(resolvedValues[0] + resolvedValues[1]);
+        } catch (e) {
+            return ValueResolvingResult.error<number>(e as Error)
+        }
+    }
 
     protected validateArgs: FunctionArgsValidator = (validator: PipelineValidator, args: IFunctionArg<any>[], onSuccess: () => void, onFailure: (_: ValidationError[]) => void) => {
 

diff --git a/src/grammar/functions/base/Concat.ts b/src/grammar/functions/base/Concat.ts
@@ -1,12 +1,20 @@
 import type { Index } from "parsimmon";
-import { Types } from "../../definitions";
+import { IBaseType, Types, ValueResolvingResult } from "../../definitions";
 import { FunctionType, IFunctionArg } from "../types";
 
 export class ConcatFunction extends FunctionType<string> {
     readonly returnType = Types.STRING;
-    constructor(indexInfo: Index, args: IFunctionArg<string | number>[]) {
+    constructor(indexInfo: Index, args: (IFunctionArg<string> | IFunctionArg<number>)[]) {
         super(indexInfo, "CONCAT", args);
     }
 
-    getValue = () => this.args.reduce((acc, arg) => acc + arg.getValue(), "");
+    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+        try {
+            return ValueResolvingResult.success(
+                this.args.reduce((acc, arg) => acc + arg.getValue(dependencyValueMap).getOrElse(""), "")
+            )
+        } catch (e) {
+            return ValueResolvingResult.error<string>(e as Error)
+        }
+    }
 }
diff --git a/src/grammar/functions/base/Divide.ts b/src/grammar/functions/base/Divide.ts
@@ -1,9 +1,10 @@
 import type { Index } from "parsimmon";
-import { Types } from "../../definitions";
+import { IBaseType, Types, ValueResolvingResult } from "../../definitions";
 import { FunctionArgsValidator, FunctionType, IFunctionArg } from "../types";
 import { ValidationError } from "../validator";
 import { CommonValidators, PipelineValidator } from "../validator/pipeline";
 import { is } from "../validator/argTypeValidator";
+import { resolveValuesOnlyNumbers } from "../util";
 
 export class DivideFunction extends FunctionType<number> {
     readonly returnType = Types.NUMBER;
@@ -12,7 +13,14 @@ export class DivideFunction extends FunctionType<number> {
         super(indexInfo, "Divide", args);
     }
 
-    getValue = () => this.args[0].getValue() / this.args[1].getValue();
+    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+        try {
+            const resolvedValues = resolveValuesOnlyNumbers(this.args.map(arg => arg.getValue(dependencyValueMap)))
+            return ValueResolvingResult.success(resolvedValues[0] / resolvedValues[1]);
+        } catch (e) {
+            return ValueResolvingResult.error<number>(e as Error)
+        }
+    }
 
     protected validateArgs: FunctionArgsValidator = (validator: PipelineValidator, args: IFunctionArg<any>[], onSuccess: () => void, onFailure: (_: ValidationError[]) => void) => {
 

diff --git a/src/grammar/functions/base/Exponentiate.ts b/src/grammar/functions/base/Exponentiate.ts
@@ -1,9 +1,10 @@
 import type { Index } from "parsimmon";
-import { Types } from "../../definitions";
+import { IBaseType, Types, ValueResolvingResult } from "../../definitions";
 import { FunctionArgsValidator, FunctionType, IFunctionArg } from "../types";
 import { ValidationError } from "../validator";
 import { CommonValidators, PipelineValidator } from "../validator/pipeline";
 import { is } from "../validator/argTypeValidator";
+import { resolveValuesOnlyNumbers } from "../util";
 
 export class ExponentiateFunction extends FunctionType<number> {
     readonly returnType = Types.NUMBER;
@@ -12,7 +13,14 @@ export class ExponentiateFunction extends FunctionType<number> {
         super(indexInfo, "Exponentiate", args);
     }
 
-    getValue = () => Math.pow(this.args[0].getValue(), this.args[1].getValue());
+    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+        try {
+            const resolvedValues = resolveValuesOnlyNumbers(this.args.map(arg => arg.getValue(dependencyValueMap)))
+            return ValueResolvingResult.success(Math.pow(resolvedValues[0], resolvedValues[1]));
+        } catch (e) {
+            return ValueResolvingResult.error<number>(e as Error)
+        }
+    }
 
     protected validateArgs: FunctionArgsValidator = (validator: PipelineValidator, args: IFunctionArg<any>[], onSuccess: () => void, onFailure: (_: ValidationError[]) => void) => {
 

diff --git a/src/grammar/functions/base/Factorial.ts b/src/grammar/functions/base/Factorial.ts
@@ -1,9 +1,10 @@
 import { Index } from "parsimmon";
-import { Types } from "../../definitions";
+import { IBaseType, Types, ValueResolvingResult } from "../../definitions";
 import { FunctionArgsValidator, FunctionType, IFunctionArg } from "../types";
 import { ValidationError } from "../validator";
 import { CommonValidators, PipelineValidator } from "../validator/pipeline";
 import { is } from "../validator/argTypeValidator";
+import { resolveValuesOnlyNumbers } from "../util";
 
 export class FactorialFunction extends FunctionType<number> {
     readonly returnType = Types.NUMBER;
@@ -12,7 +13,14 @@ export class FactorialFunction extends FunctionType<number> {
         super(indexInfo, "Factorial", args);
     }
 
-    getValue = () => this.calculateFactorial(this.args[0].getValue());
+    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+        try {
+            const resolvedValues = resolveValuesOnlyNumbers([this.args[0].getValue(dependencyValueMap)])
+            return ValueResolvingResult.success(this.calculateFactorial(resolvedValues[0]));
+        } catch (e) {
+            return ValueResolvingResult.error<number>(e as Error)
+        }
+    }
 
     validateArgs: FunctionArgsValidator = (validator: PipelineValidator, args: IFunctionArg<any>[], onSuccess: () => void, onFailure: (errors: ValidationError[]) => void) => {
 

diff --git a/src/grammar/functions/base/Multiply.ts b/src/grammar/functions/base/Multiply.ts
@@ -1,17 +1,25 @@
 import type { Index } from "parsimmon";
-import { Types } from "../../definitions";
+import { IBaseType, Types, ValueResolvingResult } from "../../definitions";
 import { FunctionArgsValidator, FunctionType, IFunctionArg } from "../types";
 import { ValidationError } from "../validator";
 import { CommonValidators, PipelineValidator } from "../validator/pipeline";
 import { is } from "../validator/argTypeValidator";
+import { resolveValuesOnlyNumbers } from "../util";
 
 export class MultiplyFunction extends FunctionType<number> {
     readonly returnType = Types.NUMBER;
     constructor(indexInfo: Index, args: IFunctionArg<any>[]) {
         super(indexInfo, "Multiply", args);
     }
 
-    getValue = () => this.args[0].getValue() * this.args[1].getValue();
+    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+        try {
+            const resolvedValues = resolveValuesOnlyNumbers(this.args.map(arg => arg.getValue(dependencyValueMap)))
+            return ValueResolvingResult.success(resolvedValues[0] * resolvedValues[1]);
+        } catch (e) {
+            return ValueResolvingResult.error<number>(e as Error)
+        }
+    }
 
     protected validateArgs: FunctionArgsValidator = (validator: PipelineValidator, args: IFunctionArg<any>[], onSuccess: () => void, onFailure: (_: ValidationError[]) => void) => {
 

diff --git a/src/grammar/functions/base/Negate.ts b/src/grammar/functions/base/Negate.ts
@@ -1,9 +1,10 @@
 import type { Index } from "parsimmon";
-import { Types } from "../../definitions";
+import { IBaseType, Types, ValueResolvingResult } from "../../definitions";
 import { ValidationError } from "../validator";
 import { FunctionArgsValidator, FunctionType, IFunctionArg } from "../types";
 import { CommonValidators, PipelineValidator } from "../validator/pipeline";
 import { is } from "../validator/argTypeValidator";
+import { resolveValuesOnlyNumbers } from "../util";
 
 export class NegateFunction extends FunctionType<number> {
     readonly returnType = Types.NUMBER;
@@ -12,7 +13,16 @@ export class NegateFunction extends FunctionType<number> {
         super(indexInfo, "Negate", args);
     }
 
-    getValue = () => -this.args[0].getValue();
+
+    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+        try {
+            const resolvedValues = resolveValuesOnlyNumbers([this.args[0].getValue(dependencyValueMap)])
+            return ValueResolvingResult.success(-resolvedValues[0]);
+        } catch (e) {
+            return ValueResolvingResult.error<number>(e as Error)
+        }
+    }
+
 
     validateArgs: FunctionArgsValidator = (validator: PipelineValidator, args: IFunctionArg<any>[], onSuccess: () => void, onFailure: (errors: ValidationError[]) => void) => {
 

diff --git a/src/grammar/functions/base/Subtract.ts b/src/grammar/functions/base/Subtract.ts
@@ -1,9 +1,10 @@
 import type { Index } from "parsimmon";
-import { Types } from "../../definitions";
+import { IBaseType, Types, ValueResolvingResult } from "../../definitions";
 import { FunctionArgsValidator, FunctionType, IFunctionArg } from "../types";
 import { ValidationError } from "../validator";
 import { CommonValidators, PipelineValidator } from "../validator/pipeline";
 import { is } from "../validator/argTypeValidator";
+import { resolveValuesOnlyNumbers } from "../util";
 
 export class SubtractFunction extends FunctionType<number> {
     readonly returnType = Types.NUMBER;
@@ -12,7 +13,14 @@ export class SubtractFunction extends FunctionType<number> {
         super(indexInfo, "Subtract", args);
     }
 
-    getValue = () => this.args[0].getValue() - this.args[1].getValue();
+    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
+        try {
+            const resolvedValues = resolveValuesOnlyNumbers(this.args.map(arg => arg.getValue(dependencyValueMap)))
+            return ValueResolvingResult.success(resolvedValues[0] - resolvedValues[1]);
+        } catch (e) {
+            return ValueResolvingResult.error<number>(e as Error)
+        }
+    }
 
     protected validateArgs: FunctionArgsValidator = (validator: PipelineValidator, args: IFunctionArg<any>[], onSuccess: () => void, onFailure: (_: ValidationError[]) => void) => {
 

diff --git a/src/grammar/functions/util/index.ts b/src/grammar/functions/util/index.ts
@@ -0,0 +1,17 @@
+import { ValueResolvingResult } from "../../definitions"
+
+export const resolveValuesOnlyNumbers = <T>(values: ValueResolvingResult<T>[]) => {
+
+    const anyError = values.find(val => val.isError)
+
+    if (anyError) {
+        throw anyError.getError()
+    }
+
+    const resolvedValues = values.map(result => result.get())
+    if (resolvedValues.some(val => !Number.isFinite(val))) {
+        throw new Error("Arguments must be numbers.")
+    }
+
+    return resolvedValues
+}