fable 3.0.149 → 3.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fable",
-    "version": "3.0.149",
+    "version": "3.1.0",
     "description": "A service dependency injection, configuration and logging library.",
     "main": "source/Fable.js",
     "scripts": {
@@ -50,7 +50,7 @@
     },
     "homepage": "https://github.com/stevenvelozo/fable",
     "devDependencies": {
-        "quackage": "^1.0.36"
+        "quackage": "^1.0.38"
     },
     "dependencies": {
         "async.eachlimit": "^0.5.2",

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

@@ -83,7 +83,13 @@
 		"Name": "Round",
 		"Address": "fable.Math.roundPrecise"
 	},
-	"countSetElements": {
+
+	"cumulativesummation": {
+		"Name": "Count Set Elements in a Histogram or Value Map",
+		"Address": "fable.Math.cumulativeSummation"
+	},
+
+	"countsetelements": {
 		"Name": "Count Set Elements in a Histogram or Value Map",
 		"Address": "fable.Math.countSetElements"
 	},
@@ -93,6 +99,15 @@
 		"Address": "fable.Utility.getInternalValueByHash"
 	},
 
+	"aggregationhistogram": {
+		"Name": "Generate a Histogram by Exact Value Aggregation",
+		"Address": "fable.Math.histogramAggregationByExactValueFromInternalState"
+	},
+	"distributionhistogram": {
+		"Name": "Generate a Histogram Based on Value Distribution",
+		"Address": "fable.Math.histogramDistributionByExactValueFromInternalState"
+	},
+
 	"getvaluearray": {
 		"Name": "Get Value Array from Application State or Services (AppData, etc.)",
 		"Address": "fable.Utility.createValueArrayByHashParametersFromInternal"

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

@@ -204,7 +204,11 @@ class ExpressionParserSolver extends libExpressionParserOperationBase
 			delete tmpResults.fable;
 		}
 
-		if (typeof(tmpSolverResultValue) !== 'undefined')
+		if (typeof(tmpSolverResultValue) === 'object')
+		{
+			return tmpSolverResultValue;
+		}
+		else if (typeof(tmpSolverResultValue) !== 'undefined')
 		{
 			return tmpSolverResultValue.toString();
 		}

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

@@ -24,6 +24,13 @@ class FableServiceFilePersistence extends libFableServiceBase
 	}
 
 	joinPath(...pPathArray)
+	{
+		// TODO: Fix anything that's using this before changing this to the new true node join
+		// return libPath.join(...pPathArray);
+		return libPath.resolve(...pPathArray);
+	}
+
+	resolvePath(...pPathArray)
 	{
 		return libPath.resolve(...pPathArray);
 	}
@@ -35,8 +42,7 @@ class FableServiceFilePersistence extends libFableServiceBase
 
 	exists(pPath, fCallback)
 	{
-		let tmpFileExists = this.existsSync(pPath);;
-
+		let tmpFileExists = this.existsSync(pPath);
 		return fCallback(null, tmpFileExists);
 	}
 

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

@@ -621,6 +621,171 @@ class FableServiceMath extends libFableServiceBase
 		return tmpCleanedObject;
 	}
 
+	/**
+	 * Make a histogram of representative counts for exact values (.tostring() is the keys to count)
+	 * @param {Array} pValueSet 
+	 * @param {string} pValueAddress 
+	 */
+	histogramDistributionByExactValue(pValueObjectSet, pValueAddress, pManifest)
+	{
+		if (!Array.isArray(pValueObjectSet))
+		{
+			return pValueObjectSet;
+		}
+
+		if (!pValueAddress)
+		{
+			return {};
+		}
+
+		let tmpHistogram = {};
+		for (let i = 0; i < pValueObjectSet.length; i++)
+		{
+			let tmpValue = this.fable.Utility.getValueByHash(pValueObjectSet[i], pValueAddress, pManifest).toString();
+
+			if (!(tmpValue in tmpHistogram))
+			{
+				tmpHistogram[tmpValue] = 0;
+			}
+			tmpHistogram[tmpValue] = tmpHistogram[tmpValue] + 1;
+		}
+
+		return tmpHistogram;
+	}
+
+	histogramDistributionByExactValueFromInternalState(pValueObjectSetAddress, pValueAddress)
+	{
+		if (!pValueObjectSetAddress)
+		{
+			return {};
+		}
+
+		let tmpValueObjectSet = this.fable.Utility.getInternalValueByHash(pValueObjectSetAddress);
+		return this.histogramDistributionByExactValue(tmpValueObjectSet, pValueAddress);
+	}
+
+	/**
+	 * Make a histogram of representative counts for exact values (.tostring() is the keys to count)
+	 * @param {Array} pValueSet 
+	 * @param {string} pValueAddress 
+	 */
+	histogramAggregationByExactValue(pValueObjectSet, pValueAddress, pValueAmountAddress, pManifest)
+	{
+		if (!Array.isArray(pValueObjectSet))
+		{
+			return pValueObjectSet;
+		}
+
+		if (!pValueAddress || !pValueAmountAddress)
+		{
+			return {};
+		}
+
+		let tmpHistogram = {};
+		for (let i = 0; i < pValueObjectSet.length; i++)
+		{
+			let tmpValue = this.fable.Utility.getValueByHash(pValueObjectSet[i], pValueAddress, pManifest).toString();
+			let tmpAmount = this.parsePrecise(this.fable.Utility.getValueByHash(pValueObjectSet[i], pValueAmountAddress, pManifest), NaN);
+
+			if (!(tmpValue in tmpHistogram))
+			{
+				tmpHistogram[tmpValue] = 0;
+			}
+
+			if (!isNaN(tmpAmount))
+			{
+				tmpHistogram[tmpValue] = this.addPrecise(tmpHistogram[tmpValue], tmpAmount);
+			}
+		}
+
+		return tmpHistogram;
+	}
+
+	histogramAggregationByExactValueFromInternalState(pValueObjectSetAddress, pValueAddress, pValueAmountAddress)
+	{
+		if (!pValueObjectSetAddress)
+		{
+			return {};
+		}
+
+		let tmpValueObjectSet = this.fable.Utility.getInternalValueByHash(pValueObjectSetAddress);
+		return this.histogramAggregationByExactValue(tmpValueObjectSet, pValueAddress, pValueAmountAddress);
+	}
+
+	/**
+	 * Given a value object set (an array of objects), find a specific entry when 
+	 * sorted by a specific value address.  Supports -1 syntax for last entry.
+	 * @param {Array} pValueObjectSet 
+	 * @param {string} pValueAddress 
+	 * @param {Object} pManifest 
+	 */
+	entryInSet(pValueObjectSet, pValueAddress, pEntryIndex)
+	{
+		if (!Array.isArray(pValueObjectSet))
+		{
+			return pValueObjectSet;
+		}
+
+		if (!pValueAddress)
+		{
+			return false;
+		}
+
+		if (isNaN(pEntryIndex) || pEntryIndex >= pValueObjectSet.length)
+		{
+			return false;
+		}
+
+		let tmpValueArray = pValueObjectSet.toSorted((pLeft, pRight) => { return this.comparePrecise(pLeft, pRight); });
+		let tmpIndex = (pEntryIndex === -1) ? tmpValueArray.length - 1 : pEntryIndex;
+		return tmpValueArray[tmpIndex];
+	}
+
+	smallestInSet(pValueObjectSet, pValueAddress)
+	{
+		return this.entryInSet(pValueObjectSet, pValueAddress, 0);
+	}
+
+	largestInSet(pValueObjectSet, pValueAddress)
+	{
+		return this.entryInSet(pValueObjectSet, pValueAddress, -1);
+	}
+
+	/**
+	 * Expects an array of objects, and an address in each object to sum.  Expects 
+	 * an address to put the cumulative summation as well.
+	 * @param {Array} pValueObjectSet 
+	 */
+	cumulativeSummation(pValueObjectSet, pValueAddress, pCumulationResultAddress, pManifest)
+	{
+		if (!Array.isArray(pValueObjectSet))
+		{
+			return pValueObjectSet;
+		}
+
+		if (!pValueAddress || !pCumulationResultAddress)
+		{
+			return pValueObjectSet;
+		}
+
+		let tmpSummationValue = '0.0';
+		for (let i = 0; i < pValueObjectSet.length; i++)
+		{
+			let tmpValue = this.parsePrecise(this.fable.Utility.getValueByHash(pValueObjectSet[i], pValueAddress, pManifest));
+
+			if (isNaN(tmpValue))
+			{
+				this.fable.Utility.setValueByHash(pValueObjectSet[i], pCumulationResultAddress, tmpSummationValue, pManifest);
+				continue;
+			}
+
+			tmpSummationValue = this.addPrecise(tmpValue, tmpSummationValue);
+			this.fable.Utility.setValueByHash(pValueObjectSet[i], pCumulationResultAddress, tmpSummationValue, pManifest);
+		}
+
+		return pValueObjectSet;
+	}
+
 	/**
 	 * Finds the maximum value from a set of precise values.
 	 * 

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

@@ -128,6 +128,32 @@ class FableServiceUtility extends libFableServiceBase
 		return tmpManifest.getValueByHash(pObject, pValueAddress);
 	}
 
+	/**
+	 * Set a value to an object by hash/address
+	 * @param {object} pObject - The object to get the value from
+	 * @param {string} pValueAddress - The manyfest hash/address of the value to get
+	 * @param {object} pValue - The value to set
+	 * @param {object} [pManifest] - The manyfest object to use; constructs one inline if not provided
+	 * @returns {object} - The value from the object
+	 */
+	setValueByHash(pObject, pValueAddress, pValue, pManifest)
+	{
+		let tmpManifest = pManifest;
+
+		if (typeof(tmpManifest) == 'undefined')
+		{
+			// Lazily create a manifest if it doesn't exist
+			if (!this.manifest)
+			{
+				this.manifest = this.fable.newManyfest();
+			}
+			tmpManifest = this.manifest;
+		}
+
+		// Get the value from the internal manifest and return it
+		return tmpManifest.setValueByHash(pObject, pValueAddress, pValue);
+	}
+
 	/**
 	 * Get a value array from an object by hash/address list
 	 * @param {object} pObject - The object to get the value from
@@ -177,6 +203,11 @@ class FableServiceUtility extends libFableServiceBase
 
 	createValueArrayByHashParametersFromInternal()
 	{
+		if (arguments.length < 2)
+		{
+			return [];
+		}
+		
 		let tmpValueHashes = Array.prototype.slice.call(arguments);
 		return this.createValueArrayByHashes(this.fable, tmpValueHashes);
 	}

package/test/ExpressionParser_tests.js

@@ -331,6 +331,40 @@ suite
 						Expect(parseFloat(tmpResult)).to.be.at.most(13.78);
 
 
+						return fDone();
+					}
+				);
+				test
+				(
+					'Complex Histogram Arithmatic',
+					(fDone)=>
+					{
+						let testFable = new libFable();
+
+						let testCityData = require('./data/cities.json');
+						testFable.AppData = { Cities: testCityData };
+
+						// let tmpDistribution = testFable.Math.histogramDistributionByExactValue(testFable.AppData.Cities, 'state');
+
+						// Expect(tmpDistribution.Alabama).to.equal(12);
+						// Expect(tmpDistribution.Colorado).to.equal(21);
+						// Expect(tmpDistribution.Florida).to.equal(73);
+						// Expect(tmpDistribution.Georgia).to.equal(18);
+
+						// Now through the solver
+
+						let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+						let tmpResultsObject = {};
+						let tmpDestinationObject = {};
+						
+						_Parser.solve('DistributionResult = distributionhistogram("AppData.Cities", "state")', this.fable, tmpResultsObject, false, tmpDestinationObject);
+						_Parser.solve('AggregationResult = aggregationHistogram("AppData.Cities", "state", "population")', this.fable, tmpResultsObject, false, tmpDestinationObject);
+
+						Expect(tmpDestinationObject.DistributionResult.Alabama).to.equal(12);
+						Expect(tmpDestinationObject.DistributionResult.Colorado).to.equal(21);
+
+						Expect(tmpDestinationObject.AggregationResult.Alabama).to.equal('1279813');
+
 						return fDone();
 					}
 				);

package/test/FilePersistence_tests.js

@@ -116,6 +116,20 @@ suite
 					}
 				);
 				test
+				(
+					'Resolve a path.',
+					function(fTestComplete)
+					{
+						let testFable = new libFable();
+						let tmpFilePersistence = testFable.instantiateServiceProvider('FilePersistence');
+
+						Expect(tmpFilePersistence.resolvePath('tmp/tests/../othertests/names/'))
+							.to.equal(process.cwd()+'/tmp/othertests/names');
+
+						return fTestComplete();
+					}
+				);
+				test
 				(
 					'Create a recursive folder.',
 					function(fTestComplete)

package/test/Math_test.js

@@ -80,6 +80,37 @@ suite
 					}
 				);
 				test
+				(
+					'Cumulative Summation',
+					function(fDone)
+					{
+						let testFable = new libFable();
+
+						let tmpTestValueSet = (
+							[
+								{ Item: 'Lettuce', Quantity: 2, Price: "7.99" },
+								{ Item: 'Tomato', Quantity: 3, Price: "3.99" },
+								{ Item: 'Onion', Quantity: 1, Price: "1.99" },
+								{ Item: 'Cucumber', Quantity: 4, Price: "2.99" },
+								{ Item: 'Carrot', Quantity: 3, Price: "1.99" },
+								{ Item: 'Radish', Quantity: 2, Price: "1.49" },
+								{ Item: 'Celery', Quantity: 1, Price: "0.99" },
+								{ Item: 'Parsley', Quantity: 2, Price: "0.49" }
+							]);
+
+						testFable.Math.cumulativeSummation(tmpTestValueSet, 'Price', 'RunningTotal');
+
+						Expect(tmpTestValueSet[0].RunningTotal).to.equal('7.99');
+						Expect(tmpTestValueSet[1].RunningTotal).to.equal('11.98');
+						Expect(tmpTestValueSet[2].RunningTotal).to.equal('13.97');
+						Expect(tmpTestValueSet[3].RunningTotal).to.equal('16.96');
+						Expect(tmpTestValueSet[4].RunningTotal).to.equal('18.95');
+						Expect(tmpTestValueSet[5].RunningTotal).to.equal('20.44');
+
+						return fDone();
+					}
+				);
+				test
 				(
 					'Parse Numbers',
 					function(fDone)
@@ -95,6 +126,35 @@ suite
 					}
 				);
 
+				test
+				(
+					'Histograms by Count',
+					function(fDone)
+					{
+
+						let testFable = new libFable();
+
+						let tmpTestValueSet = (
+							[
+								{ City: 'New York', State: 'NY', GDP: 1000000 },
+								{ City: 'Seattle', State: 'WA', GDP: 500000 },
+								{ City: 'Portland', State: 'OR', GDP: 250000 },
+								{ City: 'San Francisco', State: 'CA', GDP: 750000 },
+								{ City: 'Los Angeles', State: 'CA', GDP: 500000 },
+								{ City: 'San Diego', State: 'CA', GDP: 250000 },
+								{ City: 'Atlanta', State: 'GA', GDP: 100000 },
+								{ City: 'Savannah', State: 'GA', GDP: 50000 },
+								{ City: 'Athens', State: 'GA', GDP: 25000 }
+							]);
+
+						let tmpHistogramByDistribution = testFable.Math.histogramDistributionByExactValue(tmpTestValueSet, 'State');
+						Expect(tmpHistogramByDistribution).to.deep.equal({ CA: 3, GA: 3, NY: 1, OR: 1, WA: 1 });
+						let tmpHistogramByAggregation = testFable.Math.histogramAggregationByExactValue(tmpTestValueSet, 'State', 'GDP');
+						Expect(tmpHistogramByAggregation).to.deep.equal({ CA: "1500000", GA: "175000", NY: "1000000", OR: "250000", WA: "500000" });
+						return fDone();
+					}
+				);
+
 				test
 				(
 					'Round Numbers',