fable 3.0.110 → 3.0.112

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fable",
-    "version": "3.0.110",
+    "version": "3.0.112",
     "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-Anticipate.js

@@ -25,8 +25,21 @@ class FableServiceAnticipate extends libFableServiceBase
 
 	checkQueue()
 	{
+		// This could be combined with the last else if stanza but the logic for errors and non-errors would be blended and more complex to follow so keeping it unrolled.
+		if (this.lastError)
+		{
+			// If there are no operations left, and we have waiting functions, call them.
+			for (let i = 0; i < this.waitingFunctions.length; i++)
+			{
+				//this.log.trace('Calling waiting function.')
+				this.waitingFunctions[i](this.lastError);
+			}
+			// Reset our state
+			this.lastError = undefined;
+			this.waitingFunctions = [];
+		}
 		// This checks to see if we need to start any operations.
-		if (this.operationQueue.length > 0 && this.executingOperationCount < this.maxOperations)
+		else if (this.operationQueue.length > 0 && this.executingOperationCount < this.maxOperations)
 		{
 			let tmpOperation = this.operationQueue.shift();
 			this.executingOperationCount += 1;
@@ -72,7 +85,7 @@ class FableServiceAnticipate extends libFableServiceBase
 				throw new Error("Anticipation async callback called twice...");
 			}
 			tmpCallbackState.Called = true;
-			tmpCallbackState.error = pError;
+			this.lastError = pError;
 
 			tmpCallbackState.OperationSet.executingOperationCount -= 1;
 			tmpCallbackState.OperationSet.completedOperationCount += 1;

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

@@ -0,0 +1,75 @@
+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';
+	}
+
+	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/test/Anticipate_tests.js

@@ -85,6 +85,60 @@ suite
 									});
 								}
 							);
+						test
+							(
+								'Error bailout',
+								function (fTestComplete)
+								{
+									let testFable = new libFable();
+									let tmpAnticipate = testFable.newAnticipate();
+									let tmpPostErrorMethodCalled = false;
+									tmpAnticipate.anticipate(function (fCallback)
+									{
+										testFable.log.info('Operation First test timeout entered...');
+										setTimeout(function ()
+										{
+											testFable.log.info(`Operation First test timeout done!`);
+											fCallback();
+										}, 500);
+									});
+									tmpAnticipate.anticipate(function (fCallback)
+									{
+										testFable.log.info('Operation Second test timeout entered...');
+										setTimeout(function ()
+										{
+											testFable.log.info(`Operation Second test timeout done!`);
+											fCallback();
+										}, 50);
+									});
+									tmpAnticipate.anticipate(function (fCallback)
+									{
+										testFable.log.info('Operation Second test timeout entered...');
+										setTimeout(function ()
+										{
+											testFable.log.info(`Operation Second test timeout done!`);
+											fCallback(new Error('Bail out or else!'));
+										}, 50);
+									});
+									tmpAnticipate.anticipate(function (fCallback)
+									{
+										testFable.log.info('Operation Third test timeout entered...');
+										setTimeout(function ()
+										{
+											tmpPostErrorMethodCalled = true;
+											testFable.log.info(`Operation Third test timeout done!`);
+											fCallback();
+										}, 50);
+									});
+									tmpAnticipate.wait(function (pError)
+									{
+										Expect(pError).to.be.an('error');
+										Expect(tmpPostErrorMethodCalled).to.equal(false);
+										testFable.log.info(`Wait 1 completed: ${pError}`)
+										return fTestComplete();
+									});
+								}
+							);
 						test
 							(
 								'Huge call stack',

package/test/Math_test.js

@@ -0,0 +1,48 @@
+/**
+* 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();
+					}
+				);
+			}
+		);
+	}
+);