fix(RefType): RefType now returns direct value, instead of value wrap…

…ped in other IBaseType
imnotteixeira · Jan 29, 2024 · ff86d4b · ff86d4b
1 parent f48bdc5
commit ff86d4b
Show file tree

Hide file tree

Showing 2 changed files with 24 additions and 11 deletions.
diff --git a/src/grammar/definitions.ts b/src/grammar/definitions.ts
@@ -48,7 +48,7 @@ export class ValueResolvingResult<T> {
 export interface IBaseType<T> {
     type: AllowedType;
     indexInfo: Index;
-    getValue: (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => ValueResolvingResult<T>;
+    getValue: (dependencyValueMap: Map<string, any>) => ValueResolvingResult<T>;
 
     validate: () => ValidationResult;
 
@@ -59,8 +59,9 @@ export abstract class BaseType<T> implements IBaseType<T> {
     abstract type: AllowedType;
     readonly indexInfo: Index;
 
-    abstract getValue: (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => ValueResolvingResult<T>;
+    abstract getValue: (dependencyValueMap: Map<string, any>) => ValueResolvingResult<T>;
     abstract validate: () => ValidationResult;
+    abstract toString: () => string;
 
     constructor(indexInfo: Index) {
         this.indexInfo = indexInfo;
@@ -102,6 +103,8 @@ export class StringType extends BaseType<string> implements IStringType {
 
     getValue = () => ValueResolvingResult.success(this.value);
     validate = () => makeSuccess();
+
+    toString = () => `StringType(${this.value})`
 }
 
 export interface INumberType extends IBaseType<number> {
@@ -120,6 +123,8 @@ export class NumberType extends BaseType<number> implements INumberType {
 
     getValue = () => ValueResolvingResult.success(this.value);
     validate = () => makeSuccess();
+
+    toString = () => `NumberType(${this.value})`
 }
 
 export interface IRefType extends IBaseType<any|undefined> {
@@ -136,18 +141,22 @@ export class RefType extends BaseType<any | undefined> implements IRefType {
         this.value = refId;
     }
 
-    getValue = (dependencyValueMap: Map<string, IBaseType<any> | undefined>) => {
-        const referencedElem = dependencyValueMap.get(this.value);
-        if (!referencedElem) {
+    getValue = (dependencyValueMap: Map<string, any>) => {
+        const referencedValue = dependencyValueMap.get(this.value);
+        console.debug(`This is the referencedValue with id <${this.value}>:`, referencedValue)
+        if (!referencedValue) {
             // 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)
-        }
+        } 
+
+        return ValueResolvingResult.success(referencedValue);
+
     }
 
     validate = () => makeSuccess();
+
+    toString = () => `RefType(${this.value})`
 }
 
 export type IValueType<T> = IBaseType<T>;

diff --git a/tst/grammar/bettermath.test.ts b/tst/grammar/bettermath.test.ts
@@ -72,7 +72,7 @@ describe("Grammar", () => {
                 const refId = "R1";
                 const refElem = new NumberType(INDEX_INFO, "11");
                 const dependencyValueMap = new Map([
-                    [refId, refElem]
+                    [refId, refElem.getValue().get()]
                 ]);
 
                 expect(grammar.tryParse(`=${refId}`).getValue(dependencyValueMap).get()).toBe(
@@ -819,7 +819,9 @@ describe("Grammar", () => {
                                 R1: new NumberType(INDEX_INFO, "1"),
                                 R2: new NumberType(INDEX_INFO, "2"),
                             };
-                            const dependencyValueMap = new Map(Object.entries(refs));
+                            const dependencyValueMap = new Map(Object.entries(refs)
+                                .map(([k,v]) => ([k, v.getValue().get()]))
+                            );
 
                             const expectedExpression = new AddFunction(INDEX_INFO, Object.values(refs));
 
@@ -832,7 +834,9 @@ describe("Grammar", () => {
                             const refs = {
                                 R1: new NumberType(INDEX_INFO, "1"),
                             };
-                            const dependencyValueMap = new Map(Object.entries(refs));
+                            const dependencyValueMap = new Map(Object.entries(refs)
+                                .map(([k,v]) => ([k, v.getValue().get()]))
+                            );
 
                             const expectedExpression = new NegateFunction(INDEX_INFO, Object.values(refs));