fable 3.0.133 → 3.0.134

package/example_applications/data/Fruit-Manyfest.json

@@ -0,0 +1,56 @@
+{
+	"Scope": "FruitsOfTheWorld",
+	"Descriptors":
+	{
+		"FruityVice[].name":
+		{
+			"Name": "Fruit Name",
+			"Hash": "Name",
+			"DataType": "String",
+			"Default": "(unnamed fruit)"
+		},
+		"FruityVice[].family":
+		{
+			"Name": "Family",
+			"Hash": "Family",
+			"DataType": "String"
+		},
+		"FruityVice[].order":
+		{
+			"Name": "Order",
+			"Hash": "Order",
+			"DataType": "String"
+		},
+		"FruityVice[].genus":
+		{
+			"Name": "Genus",
+			"Hash": "Genus",
+			"DataType": "String"
+		},
+		"FruityVice[].nutritions.calories":
+		{
+			"Name": "Calories",
+			"Hash": "Calories"
+		},
+		"FruityVice[].nutritions.fat":
+		{
+			"Name": "Fat",
+			"Hash": "Fat"
+		},
+		"FruityVice[].nutritions.protein":
+		{
+			"Name": "Protein",
+			"Hash": "Protein"
+		},
+		"FruityVice[].nutritions.carbohydrates":
+		{
+			"Name": "Carbohydrates",
+			"Hash": "Carbohydrates"
+		},
+		"FruityVice[].nutritions.sugar":
+		{
+			"Name": "Sugar",
+			"Hash": "Sugar"
+		}
+	}
+}

package/example_applications/mathematical_playground/AppData.json

@@ -0,0 +1,8 @@
+{
+	"PR": 1.5,
+	"Z": "20.036237",
+	"C": -13,
+
+	"Depth": 100.203,
+	"Width": 10.5
+}

package/example_applications/mathematical_playground/Equations.json

@@ -0,0 +1,12 @@
+{
+	"Expressions":
+		[
+			{ "Equation":"Result = 5+3 - sqrt(75 / (3 + Depth) * Width)^ 3", "ExpectedResult":"-13.078386362213538715906797395732300153182132216343566001917247" },
+			{ "Equation":"Result = (160 * PR * Z) / (C / 100) * PR * Z + (160 * (1 - C / 100))", "ExpectedResult":"-1111529.088640468" },
+			{ "Equation":"1.5 * sqrt(8 * 2.423782342^2) / 10", "ExpectedResult":"1.02832375808904701855" },
+			{ "Equation":"Result = ((15000 * 2) / 4)^2 + 100 - 10 * (35 + 5)", "ExpectedResult":"562500" },
+			{ "Equation":"Result = 1 * sqrt(16)", "ExpectedResult":"4" },
+			{ "Equation":"Result = sqrt(100 * (C + 30)) + sin(Depth - Width) / 10", "ExpectedResult":"41.32965489638783839821" },
+			{ "Equation":"Result = 3.5 + 50 + 10 * 10 / 5 - 1.5", "ExpectedResult":"72" }
+		]
+}

package/example_applications/mathematical_playground/Math-Solver-Harness.js

@@ -0,0 +1,89 @@
+const libFable = require('../../source/Fable.js');
+
+const _Fable = new libFable({"Product": "Ti"});
+// This instantiates the ExpressionParser service provider
+_Fable.instantiateServiceProviderIfNotExists('ExpressionParser');
+
+/* * * * * * * * * * * * * * * * *
+ *
+ * Solve a basic math problem.
+ * 
+ */
+_Fable.log.info(`Beginning Basic Math Exercises....`);
+// Just type numbers and watch it go brrr
+_Fable.log.info(`One-liner solve is: ${_Fable.ExpressionParser.solve("Result = 73.5 * 28.8 * 200.5")}`);
+// Let's put it in a variable for easier exercises
+const _ExpressionParser = _Fable.ExpressionParser;
+// Look up somoe variables in an object
+_Fable.log.info(`One-liner solve with variables is: ${_ExpressionParser.solve("Volume = Width * Height * Depth", {"Width": 73.5, "Height": 28.8, "Depth": 200.5})}`);
+
+
+/* * * * * * * * * * * * * * * * *
+ *
+ * A simple run through of some mathematical expressions
+ * 
+ */
+_Fable.log.info(`Beginning Run-through for Set of Test Expressions....`);
+// An array of equations with expected values
+let _Equations = require(`./Equations.json`);
+// The application state is a plain javascript object we pass into the solver to pull variables from
+let _AppData = require(`./AppData.json`);
+// The manifest is a Manyfest which describes hashes for complex addresses in the application state object
+// For example you can't use "Student[0].Age" as a variable in the expression
+// ...but you can use "Student[0].Age" as an address in the manifest with a hash of "StudentAge"
+// ...and then reference "StudentAge" in the expression.
+let tmpManifestConfiguration = { "Scope":"None", "Descriptors":[] };
+let tmpManifest = _Fable.newManyfest(tmpManifestConfiguration);
+// Run each expression in the Equations.json file through the expression parser.
+for (let i = 0; i < _Equations.Expressions.length; i++)
+{
+	let tmpResultValue = _ExpressionParser.solve(_Equations.Expressions[i].Equation, _AppData, {}, tmpManifest);
+	console.log(`Expression [${i}]: [${_Equations.Expressions[i].Equation}] ==> ${tmpResultValue}`);
+	if (tmpResultValue !== _Equations.Expressions[i].ExpectedResult)
+	{
+		console.log(`Error: Equation ${_Equations.Expressions[i].Equation} expected [${_Equations.Expressions[i].ExpectedResult}] but got [${tmpResultValue}]`);
+	}
+}
+
+
+/* * * * * * * * * * * * * * * * *
+ *
+ * A manual run through of each phase of the expression parser
+ * 
+ */
+// Load up some fruit data to play around with
+let _FruitData = require(`../data/Fruit-Data.json`);
+let _FruitManifestDescription = require(`../data/Fruit-Manyfest.json`);
+let _FruitManifest = _Fable.newManyfest(_FruitManifestDescription);
+
+_Fable.log.info(`Beginning Manual Solve with Embedded Fruit Data....`);
+
+// The expression we pass into the solver is just a string
+let tmpExpression = 'HyperMax.HealthIndex = (SUM(Calories) / SUM(Sugar)) * MEDIAN(Fat) + (SQRT(AVG(Protein)) - (PI() + 99)';
+_Fable.log.info(`Solving tmpExpression: [${tmpExpression}]`);
+
+// This is an object where the parser will write out the results of each phase of the compiler/parser/solver
+let tmpExpressionParseOutcome = {};
+let tmpSolverResultsObject = {};
+
+// Step 1: Tokenize the expression
+let complexTokenizedResults = _ExpressionParser.tokenize(tmpExpression, tmpExpressionParseOutcome);
+// Step 2: Lint the tokenized expression (this is optional but very helpful for user feedback)
+let complexLintedResults = _ExpressionParser.lintTokenizedExpression(complexTokenizedResults, tmpExpressionParseOutcome);
+// Step 3: Parse the tokenized expression (this generates a postfix expression)
+let complexPostfixedResults = _ExpressionParser.buildPostfixedSolveList(complexTokenizedResults, tmpExpressionParseOutcome);
+// Step 4: Substitute the values references in the tokenized objects representing data within the postfixed expression
+_ExpressionParser.substituteValuesInTokenizedObjects(tmpExpressionParseOutcome.PostfixTokenObjects, _FruitData, tmpExpressionParseOutcome, _FruitManifest);
+// Now that we have a postfixed expression and the mapped-in values, show the user what the solution steps look like
+for (let i = 0; i < tmpExpressionParseOutcome.PostfixSolveList.length; i++)
+{
+	let tmpToken = tmpExpressionParseOutcome.PostfixSolveList[i];
+	console.log(`${i}: ${tmpToken.VirtualSymbolName} = (${tmpToken.LeftValue.Token}::${tmpToken.LeftValue.Value})  ${tmpToken.Operation.Token}  (${tmpToken.RightValue.Token}::${tmpToken.RightValue.Value}) `)
+}
+// Step 5: Solve the postfixed expression
+let tmpResultValue = _ExpressionParser.solvePostfixedExpression(tmpExpressionParseOutcome.PostfixSolveList, tmpSolverResultsObject, tmpExpressionParseOutcome, _FruitManifest);
+
+// Step 6: Look at the results.
+console.log(`Outcome object: ${JSON.stringify(tmpSolverResultsObject)}`);
+console.log(`Result of ${tmpExpression} solve: ${tmpResultValue}`);
+console.log('QED');

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fable",
-    "version": "3.0.133",
+    "version": "3.0.134",
     "description": "A service dependency injection, configuration and logging library.",
     "main": "source/Fable.js",
     "scripts": {

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-FunctionMap.json

@@ -1,22 +1,82 @@
 {
-	"sqrt":
-		{
-			"Name": "Square Root",
-			"Address": "fable.Math.sqrtPrecise"
-		},
-	"abs":
-		{
-			"Name": "Absolute Value",
-			"Address": "fable.Math.absPrecise"
-		},
-	"rad":
-		{
-			"Name": "Degrees to Radians",
-			"Address": "fable.Math.radPrecise"
-		},
-	"sin":
-		{
-			"Name": "Sine",
-			"Address": "fable.Math.sin"
-		}
+	"sqrt": {
+		"Name": "Square Root",
+		"Address": "fable.Math.sqrtPrecise"
+	},
+
+	"abs": {
+		"Name": "Absolute Value",
+		"Address": "fable.Math.absPrecise"
+	},
+
+	"rad": {
+		"Name": "Degrees to Radians",
+		"Address": "fable.Math.radPrecise"
+	},
+
+	"pi": {
+		"Name": "Pi",
+		"Address": "fable.Math.piPrecise"
+	},
+	"sin": {
+		"Name": "Sine",
+		"Address": "fable.Math.sin"
+	},
+	"cos": {
+		"Name": "Cosine",
+		"Address": "fable.Math.cos"
+	},
+	"tan": {
+		"Name": "Tangent",
+		"Address": "fable.Math.tan"
+	},
+
+	"count": {
+		"Name": "Count Set Elements",
+		"Address": "fable.Math.countSetElements"
+	},
+
+	"sortset": {
+		"Name": "Sort Set",
+		"Address": "fable.Math.sortSetPrecise"
+	},
+	"bucketset": {
+		"Name": "Bucket Set",
+		"Address": "fable.Math.bucketSetPrecise"
+	},
+	"sorthistogram": {
+		"Name": "Sort Histogram",
+		"Address": "fable.Math.sortHistogramPrecise"
+	},
+
+	"max": {
+		"Name": "Maximum",
+		"Address": "fable.Math.maxPrecise"
+	},
+	"min": {
+		"Name": "Minimum",
+		"Address": "fable.Math.minPrecise"
+	},
+
+	"sum": {
+		"Name": "Sum",
+		"Address": "fable.Math.sumPrecise"
+	},
+
+	"avg": {
+		"Name": "Average",
+		"Address": "fable.Math.averagePrecise"
+	},
+	"mean": {
+		"Name": "Mean",
+		"Address": "fable.Math.meanPrecise"
+	},
+	"median": {
+		"Name": "Median",
+		"Address": "fable.Math.medianPrecise"
+	},
+	"mode": {
+		"Name": "Mode",
+		"Address": "fable.Math.modePrecise"
+	}
 }

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-Postfix.js

@@ -564,21 +564,21 @@ class ExpressionParserPostfix extends libExpressionParserOperationBase
 			// If this is a layer with one value, presume it's an assignment.
 			if (tmpSolveLayerTokens.length === 1)
 			{
-				let tmpAbstractMultiplyToken = this.getTokenContainerObject('*');
-				tmpAbstractMultiplyToken.VirtualSymbolName = tmpResults.PostfixLayerstackMap[tmpSolveLayerTokens[0].SolveLayerStack];
+				let tmpAbstractAssignToken = this.getTokenContainerObject('=');
+				tmpAbstractAssignToken.VirtualSymbolName = tmpResults.PostfixLayerstackMap[tmpSolveLayerTokens[0].SolveLayerStack];
 				// If this doesn't have a matching solvelayerstack, get the virtual symbol name from the parenthesis group it's in
-				if (!tmpAbstractMultiplyToken.VirtualSymbolName)
+				if (!tmpAbstractAssignToken.VirtualSymbolName)
 				{
 					for (let i = 0; i < tmpResults.PostfixTokenObjects.length; i++)
 					{
 						if (tmpResults.PostfixTokenObjects[i].ParenthesisStack === tmpSolveLayerTokens[0].SolveLayerStack)
 						{
-							tmpAbstractMultiplyToken.VirtualSymbolName = tmpResults.PostfixTokenObjects[i].VirtualSymbolName;
+							tmpAbstractAssignToken.VirtualSymbolName = tmpResults.PostfixTokenObjects[i].VirtualSymbolName;
 							break;
 						}
 					}
 				}
-				tmpResults.PostfixSolveList.push(this.getPosfixSolveListOperation(tmpAbstractMultiplyToken, this.getTokenContainerObject('1.0'), tmpSolveLayerTokens[0]));
+				tmpResults.PostfixSolveList.push(this.getPosfixSolveListOperation(tmpAbstractAssignToken, tmpSolveLayerTokens[0], this.getTokenContainerObject('0.0')));
 				continue;
 			}
 

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-SolvePostfixedExpression.js

@@ -100,7 +100,7 @@ class ExpressionParserSolver extends libExpressionParserOperationBase
 				}
 				catch (pError)
 				{
-					tmpResults.ExpressionParserLog.push(`ERROR: ExpressionParser.solvePostfixedExpression failed to solve step ${i} with function ${tmpStepResultObject.ExpressionStep.Operation.Token}.`);
+					tmpResults.ExpressionParserLog.push(`ERROR: ExpressionParser.solvePostfixedExpression failed to solve step ${i} with function ${tmpStepResultObject.ExpressionStep.Operation.Token}: ${pError}`);
 					this.log.error(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
 					return false;
 				}

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-TokenMap.json

@@ -3,6 +3,7 @@
 		{
 			"Name": "Equals",
 			"Token": "=",
+			"Function": "fable.Math.assignValue",
 			"Precedence": 0,
 			"Type": "Assignment"
 		},

package/source/services/Fable-Service-ExpressionParser.js

@@ -113,9 +113,18 @@ class FableServiceExpressionParser extends libFableServiceBase
 					}
 					catch(pError)
 					{
-						tmpResults.ExpressionParserLog.push(`ERROR: ExpressionParser.substituteValuesInTokenizedObjects found a non-numeric value for the state address ${tmpToken.Token} at index ${i}`);
-						this.log.error(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
-						tmpToken.Resolved = false;
+						// TODO: Should we allow this to be a function?  Good god the complexity and beauty of that...
+						if (Array.isArray(tmpValue) || (typeof(tmpValue) === 'object'))
+						{
+							tmpToken.Resolved = true;
+							tmpToken.Value = tmpValue;
+						}
+						else
+						{
+							tmpResults.ExpressionParserLog.push(`INFO: ExpressionParser.substituteValuesInTokenizedObjects found a non-numeric, non-set value for the state address ${tmpToken.Token} at index ${i}`);
+							this.log.error(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
+							tmpToken.Resolved = false;
+						}
 					}
 				}
 			}
@@ -190,6 +199,16 @@ class FableServiceExpressionParser extends libFableServiceBase
 		return this.Solver.solvePostfixedExpression(pPostfixedExpression, pDataDestinationObject, pResultObject, pManifest);
 	}
 
+	/**
+	 * Solves the given expression using the provided data and manifest.
+	 * 
+	 * @param {string} pExpression - The expression to solve.
+	 * @param {object} pDataSourceObject - (optional) The data source object (e.g. AppData).
+	 * @param {object} pResultObject - (optional) The result object containing the full postfix expression list, internal variables and solver history.
+	 * @param {object} pManifest - (optional) The manifest object for dereferencing variables.
+	 * @param {object} pDataDestinationObject - (optional) The data destination object for where to marshal the result into.
+	 * @returns {any} - The result of solving the expression.
+	 */
 	solve(pExpression, pDataSourceObject, pResultObject, pManifest, pDataDestinationObject)
 	{
 		let tmpResultsObject = (typeof(pResultObject) === 'object') ? pResultObject : {};