fable 3.0.148 → 3.0.150

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fable",
-    "version": "3.0.148",
+    "version": "3.0.150",
     "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

@@ -83,14 +83,47 @@
 		"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"
 	},
 
 	"getvalue": {
 		"Name": "Get Value from Application State or Services (AppData, etc.)",
-		"Address": "fable.Utility.getValue"
+		"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"
+	},
+	"getvalueobject": {
+		"Name": "Get Value Object from Application State or Services (AppData, etc.)",
+		"Address": "fable.Utility.createValueObjectByHashParametersFromInternal"
+	},
+
+	"cleanvaluearray": {
+		"Name": "Clean Value Array",
+		"Address": "fable.Math.cleanValueArray"
+	},
+	"cleanvalueobject": {
+		"Name": "Clean Value Object",
+		"Address": "fable.Math.cleanValueObject"
 	},
 
 	"randominteger": {

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-Math.js

@@ -582,6 +582,210 @@ class FableServiceMath extends libFableServiceBase
 		return tmpSortedHistogram;
 	}
 
+	cleanValueArray(pValueArray)
+	{
+		if (!Array.isArray(pValueArray))
+		{
+			return [];
+		}
+
+		let tmpCleanedArray = [];
+		for (let i = 0; i < pValueArray.length; i++)
+		{
+			let tmpValue = this.parsePrecise(pValueArray[i], NaN);
+			if (!isNaN(tmpValue))
+			{
+				tmpCleanedArray.push(tmpValue);
+			}
+		}
+		return tmpCleanedArray;
+	}
+
+	cleanValueObject(pValueObject)
+	{
+		if (typeof (pValueObject) !== 'object')
+		{
+			return {};
+		}
+
+		let tmpCleanedObject = {};
+		let tmpKeys = Object.keys(pValueObject);
+		for (let i = 0; i < tmpKeys.length; i++)
+		{
+			let tmpValue = this.parsePrecise(pValueObject[tmpKeys[i]], NaN);
+			if (!isNaN(tmpValue))
+			{
+				tmpCleanedObject[tmpKeys[i]] = tmpValue;
+			}
+		}
+		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

@@ -97,18 +97,179 @@ class FableServiceUtility extends libFableServiceBase
 	 * Get a value from fable/pict by hash/address
 	 * @param {string} pValueAddress - The manyfest hash/address of the value to get
 	 */
-	getValue(pValueAddress)
+	getInternalValueByHash(pValueAddress)
 	{
-		// Lazily create a manifest if it doesn't exist
-		if (!this.manifest)
+		// Get the value from the internal manifest and return it
+		return this.getValueByHash(this.fable, pValueAddress);
+	}
+
+	/**
+	 * Get a value from 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} [pManifest] - The manyfest object to use; constructs one inline if not provided
+	 * @returns {object} - The value from the object
+	 */
+	getValueByHash(pObject, pValueAddress, pManifest)
+	{
+		let tmpManifest = pManifest;
+
+		if (typeof(tmpManifest) == 'undefined')
 		{
-			this.manifest = this.fable.newManyfest();
+			// 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 this.manifest.getValueByHash(this.fable, pValueAddress);
+		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
+	 * @param {string} pValueAddress - The manyfest hash/address of the value to get
+	 * @param {object} [pManifest] - The manyfest object to use; constructs one inline if not provided
+	 * @returns {Array} - The value array built from the hash list
+	 */
+	createValueArrayByHashes(pObject, pValueHashes, 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;
+		}
+
+		if (!Array.isArray(pValueHashes))
+		{
+			return [];
+		}
+
+		let tmpValueArray = [];
+		for (let i = 0; i < pValueHashes.length; i++)
+		{
+			tmpValueArray.push(tmpManifest.getValueByHash(pObject, pValueHashes[i]));
+		}
+
+		// Get the value from the internal manifest and return it
+		return tmpValueArray;
+	}
+
+	/**
+	 * Get a value array by hash/address list from the internal fable/pict state
+	 * @param {string} pValueAddress - The manyfest hash/address of the value to get
+	 * @param {object} [pManifest] - The manyfest object to use; constructs one inline if not provided
+	 * @returns {Array} - The value array built from the hash list
+	 */
+	createValueArrayByHashesFromInternal(pValueHashes, pManifest)
+	{
+		return this.createValueArrayByHashes(this.fable, pValueHashes, pManifest);
+	}
+
+	createValueArrayByHashParametersFromInternal()
+	{
+		if (arguments.length < 2)
+		{
+			return [];
+		}
+		
+		let tmpValueHashes = Array.prototype.slice.call(arguments);
+		return this.createValueArrayByHashes(this.fable, tmpValueHashes);
+	}
+
+	/**
+	 * Get a value object from a list of hash/addressese
+	 * @param {object} pObject - The object to get the value from
+	 * @param {string} pValueAddress - The manyfest hash/address of the value to get
+	 * @param {object} [pManifest] - The manyfest object to use; constructs one inline if not provided
+	 * @returns {Array} - The value object built from the hash list
+	 */
+	createValueObjectByHashes(pObject, pValueHashes, 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;
+		}
+
+		if (!Array.isArray(pValueHashes))
+		{
+			return {};
+		}
+
+		let tmpValueObject = {};
+		for (let i = 0; i < pValueHashes.length; i++)
+		{
+			tmpValueObject[pValueHashes[i]] = tmpManifest.getValueByHash(pObject, pValueHashes[i]);
+		}
+
+		// Get the value from the internal manifest and return it
+		return tmpValueObject;
+	}
+
+	/**
+	 * Get a value object by hash/address list from the internal fable/pict state
+	 * @param {string} pValueAddress - The manyfest hash/address of the value to get
+	 * @param {object} [pManifest] - The manyfest object to use; constructs one inline if not provided
+	 * @returns {object} - The value object built from the hash list
+	 */
+	createValueObjectByHashesFromInternal(pValueHashes, pManifest)
+	{
+		return this.createValueObjectByHashes(this.fable, pValueHashes, pManifest);
+	}
+
+	/**
+	 * Get a value object by hash/address list as parameters from the internal fable/pict state
+	 * @returns {Array} - The value array built from the hash list
+	 */
+	createValueObjectByHashParametersFromInternal()
+	{
+		let tmpValueHashes = Array.prototype.slice.call(arguments);
+		return this.createValueObjectByHashes(this.fable, tmpValueHashes);
+	}
+
+
 	/**
 	 * Check if a value is null or empty
 	 * @param {object} pObject - The object to check

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/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',

package/test/Utility_tests.js

@@ -30,6 +30,83 @@ suite
 			'Utility',
 			function()
 			{
+				test
+				(
+					'Get values and sets by hash from objects or from fable',
+					function()
+					{
+						testFable = new libFable();
+						testFable.AppData = {Name:'Thee Tortoise and the Hare'};
+						Expect(testFable.services.Utility.getValueByHash(testFable.AppData, 'Name')).to.equal('Thee Tortoise and the Hare');
+						Expect(testFable.services.Utility.getInternalValueByHash('AppData.Name')).to.equal('Thee Tortoise and the Hare');
+
+						let tmpDataObject = (
+							{
+								Name:'Thee Tortoise and the Hare',
+								Age: 100,
+								Colors:['Red','Green','Blue'],
+								Details:
+								{
+									ShoeSize: 12,
+									Height: 6.75,
+									Weight: "180.9"
+								}
+							});
+
+						let tmpValueArray = testFable.services.Utility.createValueArrayByHashes(tmpDataObject, ['Name', 'Age', 'Colors[2]', 'Nonce', 'Details.Height']);
+						Expect(tmpValueArray[0]).to.equal('Thee Tortoise and the Hare');
+						Expect(tmpValueArray[1]).to.equal(100);
+						Expect(tmpValueArray[2]).to.equal('Blue');
+						Expect(tmpValueArray[3]).to.equal(undefined);
+						Expect(tmpValueArray[4]).to.equal(6.75);
+
+						testFable.CustomDataLocation = tmpDataObject;
+						Expect(testFable.services.Utility.getInternalValueByHash('CustomDataLocation.Name')).to.equal('Thee Tortoise and the Hare');
+
+						let tmpInternalValueArray = testFable.services.Utility.createValueArrayByHashesFromInternal(['CustomDataLocation.Name', 'CustomDataLocation.Age', 'CustomDataLocation.Colors[1]', 'CustomDataLocation.Nonce', 'CustomDataLocation.Details.Height']);
+						Expect(tmpInternalValueArray[0]).to.equal('Thee Tortoise and the Hare');
+						Expect(tmpInternalValueArray[1]).to.equal(100);
+						Expect(tmpInternalValueArray[2]).to.equal('Green');
+						Expect(tmpInternalValueArray[3]).to.equal(undefined);
+						Expect(tmpInternalValueArray[4]).to.equal(6.75);
+
+						let tmpValueObject = testFable.services.Utility.createValueObjectByHashes(tmpDataObject, ['Name', 'Age', 'Colors[2]', 'Nonce', 'Details.Height']);
+						Expect(tmpValueObject.Name).to.equal('Thee Tortoise and the Hare');
+						Expect(tmpValueObject.Age).to.equal(100);
+						Expect(tmpValueObject['Colors[2]']).to.equal('Blue');
+						Expect(tmpValueObject.Nonce).to.equal(undefined);
+						Expect(tmpValueObject['Details.Height']).to.equal(6.75);
+
+						let tmpInternalValueObject = testFable.services.Utility.createValueObjectByHashesFromInternal(['CustomDataLocation.Name', 'CustomDataLocation.Age', 'CustomDataLocation.Colors[1]', 'CustomDataLocation.Nonce', 'CustomDataLocation.Details.Height']);
+						Expect(tmpInternalValueObject['CustomDataLocation.Name']).to.equal('Thee Tortoise and the Hare');
+						Expect(tmpInternalValueObject['CustomDataLocation.Age']).to.equal(100);
+						Expect(tmpInternalValueObject['CustomDataLocation.Colors[1]']).to.equal('Green');
+						Expect(tmpInternalValueObject['CustomDataLocation.Nonce']).to.equal(undefined);
+						Expect(tmpInternalValueObject['CustomDataLocation.Details.Height']).to.equal(6.75);
+
+						let tmpInternalValueArrayImplicit = testFable.services.Utility.createValueArrayByHashParametersFromInternal('CustomDataLocation.Name', 'CustomDataLocation.Age', 'CustomDataLocation.Colors[1]', 'CustomDataLocation.Nonce', 'CustomDataLocation.Details.Height');
+						Expect(tmpInternalValueArrayImplicit[0]).to.equal('Thee Tortoise and the Hare');
+						Expect(tmpInternalValueArrayImplicit[1]).to.equal(100);
+						Expect(tmpInternalValueArrayImplicit[2]).to.equal('Green');
+						Expect(tmpInternalValueArrayImplicit[3]).to.equal(undefined);
+						Expect(tmpInternalValueArrayImplicit[4]).to.equal(6.75);
+
+						let tmpInternalValueObjectImplicit = testFable.services.Utility.createValueObjectByHashParametersFromInternal('CustomDataLocation.Name', 'CustomDataLocation.Age', 'CustomDataLocation.Colors[1]', 'CustomDataLocation.Nonce', 'CustomDataLocation.Details.Height');
+						Expect(tmpInternalValueObjectImplicit['CustomDataLocation.Name']).to.equal('Thee Tortoise and the Hare');
+						Expect(tmpInternalValueObjectImplicit['CustomDataLocation.Age']).to.equal(100);
+						Expect(tmpInternalValueObjectImplicit['CustomDataLocation.Colors[1]']).to.equal('Green');
+						Expect(tmpInternalValueObjectImplicit['CustomDataLocation.Nonce']).to.equal(undefined);
+						Expect(tmpInternalValueObjectImplicit['CustomDataLocation.Details.Height']).to.equal(6.75);
+
+						let tmpCleanedValueArray = testFable.Math.cleanValueArray(tmpInternalValueArrayImplicit);
+						Expect(tmpCleanedValueArray[0]).to.equal('100');
+						Expect(tmpCleanedValueArray[1]).to.equal('6.75');
+
+						let tmpCleanedValueObject = testFable.Math.cleanValueObject(tmpInternalValueObjectImplicit);
+						Expect(tmpCleanedValueObject['CustomDataLocation.Age']).to.equal('100');
+						Expect(tmpCleanedValueObject['CustomDataLocation.Details.Height']).to.equal('6.75');
+					}
+				);
 				test
 				(
 					'Process Template like Underscore',