fable 3.0.111 → 3.0.113

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fable",
-    "version": "3.0.111",
+    "version": "3.0.113",
     "description": "An entity behavior management and API bundling library.",
     "main": "source/Fable.js",
     "scripts": {

package/source/Fable.js

@@ -71,6 +71,7 @@ class Fable extends libFableServiceBase.CoreServiceProviderBase
 		this.addAndInstantiateServiceType('DataFormat', require('./services/Fable-Service-DataFormat.js'));
 		this.addAndInstantiateServiceType('DataGeneration', require('./services/Fable-Service-DataGeneration.js'));
 		this.addAndInstantiateServiceType('Utility', require('./services/Fable-Service-Utility.js'));
+		this.addAndInstantiateServiceType('Math', require('./services/Fable-Service-Math.js'));
 		this.addServiceType('Operation', require('./services/Fable-Service-Operation.js'));
 		this.addServiceType('RestClient', require('./services/Fable-Service-RestClient.js'));
 		this.addServiceType('CSVParser', require('./services/Fable-Service-CSVParser.js'));

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

@@ -8,7 +8,7 @@ class DataFormat extends libFableServiceProviderBase
 {
 	constructor(pFable, pOptions, pServiceHash)
 	{
-		super(pFable, pOptions, pServiceHash)
+		super(pFable, pOptions, pServiceHash);
 
 		this.serviceType = 'DataArithmatic';
 
@@ -60,7 +60,7 @@ class DataFormat extends libFableServiceProviderBase
 	 * @param {*} pString
 	 * @param {*} pSearchString
 	 * @param {*} pStartIndex
-	 * @returns {*}
+	 * @returns {boolean}
 	 */
 	stringStartsWith (pString, pSearchString, pStartIndex)
 	{

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

@@ -0,0 +1,91 @@
+const libFableServiceBase = require('fable-serviceproviderbase');
+
+/**
+* Arbitrary Precision Math Operations
+* @author      Steven Velozo <steven@velozo.com>
+* @description Simple functions that perform arbitrary precision math operations and return string resultant values.
+*/
+
+class FableServiceMath extends libFableServiceBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'Math';
+	}
+
+	parsePrecise(pValue)
+	{
+		let tmpNumber = "0.0";
+
+		try
+		{
+		    tmpNumber = new this.fable.Utility.bigNumber(pValue);
+		}
+		catch(pError)
+		{
+		    console.log(`Error parsing number (type ${typeof(pValue)}): ${pError}`);
+		}
+
+		return tmpNumber.toString();
+	}
+
+	addPrecise(pLeftValue, pRightValue)
+	{
+		let tmpLeftValue = isNaN(pLeftValue) ? 0 : pLeftValue;
+		let tmpRightValue = isNaN(pRightValue) ? 0 : pRightValue;
+
+		let tmpLeftArbitraryValue = new this.fable.Utility.bigNumber(tmpLeftValue);
+		let tmpResult = tmpLeftArbitraryValue.plus(tmpRightValue);
+		return tmpResult.toString();
+	}
+
+	subtractPrecise(pLeftValue, pRightValue)
+	{
+		let tmpLeftValue = isNaN(pLeftValue) ? 0 : pLeftValue;
+		let tmpRightValue = isNaN(pRightValue) ? 0 : pRightValue;
+
+		let tmpLeftArbitraryValue = new this.fable.Utility.bigNumber(tmpLeftValue);
+		let tmpResult = tmpLeftArbitraryValue.minus(tmpRightValue);
+		return tmpResult.toString();
+	}
+
+	multiplyPrecise(pLeftValue, pRightValue)
+	{
+		let tmpLeftValue = isNaN(pLeftValue) ? 0 : pLeftValue;
+		let tmpRightValue = isNaN(pRightValue) ? 0 : pRightValue;
+
+		let tmpLeftArbitraryValue = new this.fable.Utility.bigNumber(tmpLeftValue);
+		let tmpResult = tmpLeftArbitraryValue.times(tmpRightValue);
+		return tmpResult.toString();
+	}
+
+	dividePrecise(pLeftValue, pRightValue)
+	{
+		let tmpLeftValue = isNaN(pLeftValue) ? 0 : pLeftValue;
+		let tmpRightValue = isNaN(pRightValue) ? 0 : pRightValue;
+
+		let tmpLeftArbitraryValue = new this.fable.Utility.bigNumber(tmpLeftValue);
+		let tmpResult = tmpLeftArbitraryValue.div(tmpRightValue);
+		return tmpResult.toString();
+	}
+
+	percentagePrecise(pIs, pOf)
+	{
+		let tmpLeftValue = isNaN(pIs) ? 0 : pIs;
+		let tmpRightValue = isNaN(pOf) ? 0 : pOf;
+
+		if (tmpRightValue == 0)
+		{
+			return '0';
+		}
+
+		let tmpLeftArbitraryValue = new this.fable.Utility.bigNumber(tmpLeftValue);
+		let tmpResult = tmpLeftArbitraryValue.div(tmpRightValue);
+		tmpResult = tmpResult.times(100);
+		return tmpResult.toString();
+	}
+}
+
+module.exports = FableServiceMath;

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

@@ -11,6 +11,7 @@ class FableOperation extends libFableServiceBase
 
 		// Timestamps will just be the long ints
 		this.timeStamps = {};
+
 		// ProgressTrackers have an object format of: {Hash:'SomeHash',EndTime:UINT,CurrentTime:UINT,TotalCount:INT,CurrentCount:INT}
 		this.progressTrackers = {};
 

package/test/Math_test.js

@@ -0,0 +1,63 @@
+/**
+* Unit tests for Fable Math
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var libFable = require('../source/Fable.js');
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+suite
+(
+	'Math',
+	function()
+	{
+		suite
+		(
+			'Math Operations',
+			function()
+			{
+				test
+				(
+					'Exercise Math Tests',
+					function(fDone)
+					{
+						let testFable = new libFable();
+
+						Expect(testFable.Math.addPrecise(1, 1)).to.equal('2');
+						// 3.3333333333333333333333333333333 in the current node.js implementation collapses to 3.3333333333333335
+						Expect(testFable.Math.addPrecise(1, '3.3333333333333333333333333333333')).to.equal('4.3333333333333333333333333333333');
+						// Similarly mantissa problems occur with decimals
+						// So for plain javascript:     0.1 + 0.2 = 0.30000000000000004
+						Expect(testFable.Math.addPrecise(0.1, 0.2)).to.equal('0.3');
+						Expect(testFable.Math.subtractPrecise(1, 1)).to.equal('0');
+						Expect(testFable.Math.multiplyPrecise(1, 1)).to.equal('1');
+						Expect(testFable.Math.dividePrecise(1, 1)).to.equal('1');
+						Expect(testFable.Math.percentagePrecise(1, 1)).to.equal('100');
+						
+						return fDone();
+					}
+				);
+				test
+				(
+					'Parse Numbers',
+					function(fDone)
+					{
+						let testFable = new libFable();
+
+						Expect(testFable.Math.parsePrecise(1)).to.equal('1');
+						// 3.3333333333333333333333333333333 in the current node.js implementation collapses to 3.3333333333333335
+						Expect(testFable.Math.parsePrecise('4.3333333333333333333333333333333')).to.equal('4.3333333333333333333333333333333');
+						Expect(testFable.Math.parsePrecise(undefined)).to.equal('0.0');
+						
+						return fDone();
+					}
+				);
+			}
+		);
+	}
+);