fable 3.0.30 → 3.0.32

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

@@ -6,11 +6,89 @@ class FableServiceRestClient extends libFableServiceBase
 {
 	constructor(pFable, pOptions, pServiceHash)
 	{
-        super(pFable, pOptions, pServiceHash);
+		super(pFable, pOptions, pServiceHash);
 
-        this.serviceType = 'RestClient';
+		this.TraceLog = false;
+		if (this.options.TraceLog || this.fable.TraceLog)
+		{
+			this.TraceLog = true;
+		}
 
-        this._SimpleGet = new libSimpleGet();
+		this.dataFormat = this.fable.defaultServices.DataFormat;
+
+		this.serviceType = 'RestClient';
+	}
+
+	getJSON(pOptionsOrURL, fCallback)
+	{
+		return this.getRaw(pOptionsOrURL, 
+			(pError, pResponse, pResult) =>
+			{
+				if (pError)
+				{
+					return fCallback(pError, pResponse, pResult);
+				}
+
+				if (pResponse.statusCode != 200)
+				{
+					return fCallback(new Error(`Invalid status code ${pResponse.statusCode}`), pResponse, pResult);
+				}
+
+				return fCallback(pError, pResponse, JSON.parse(pResult));
+			});
+	}
+
+	getRaw(pOptionsOrURL, fCallback)
+	{
+		let tmpRequestOptions = (typeof(pOptions) == 'object') ? pOptions : {};
+		if (typeof(pOptionsOrURL) == 'string')
+		{
+			tmpRequestOptions.url = pOptionsOrURL;
+		}
+
+		let tmpRequestStartTime = this.fable.log.getTimeStamp();
+		if (this.TraceLog)
+		{
+			let tmpConnectTime = this.fable.log.getTimeStamp();
+			this.fable.log.debug(`Beginning GET request to ${tmpRequestOptions.url} at ${tmpRequestStartTime}`);
+		}
+
+		libSimpleGet.get(tmpRequestOptions,
+			(pError, pResponse)=>
+			{
+				if (pError)
+				{
+					return fCallback(pError, pResponse, tmpRequestOptions);
+				}
+
+				if (this.TraceLog)
+				{
+					let tmpConnectTime = this.fable.log.getTimeStamp();
+					this.fable.log.debug(`--> GET connected in ${this.dataFormat.formatTimeDelta(tmpRequestStartTime, tmpConnectTime)}ms code ${pResponse.statusCode}`);
+				}
+
+				let tmpData = '';
+
+				pResponse.on('data', (pChunk)=>
+					{
+						if (this.TraceLog)
+						{
+							let tmpChunkTime = this.fable.log.getTimeStamp();
+							this.fable.log.debug(`--> GET data chunk size ${pChunk.length}b received in ${this.dataFormat.formatTimeDelta(tmpRequestStartTime, tmpChunkTime)}ms`);
+						}
+						tmpData += pChunk;
+					});
+
+				pResponse.on('end', ()=>
+					{
+						if (this.TraceLog)
+						{
+							let tmpCompletionTime = this.fable.log.getTimeStamp();
+							this.fable.log.debug(`==> GET completed data size ${tmpData.length}b received in ${this.dataFormat.formatTimeDelta(tmpRequestStartTime, tmpCompletionTime)}ms`);
+						}
+						return fCallback(pError, pResponse, tmpData);
+					});
+			});
 	}
 }
 

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

@@ -77,6 +77,76 @@ class FableServiceUtility extends libFableServiceBase
 
 		return tmpChunkCache;
 	}
+
+	// Convert an ISO string to a javascript date object
+	// Adapted from https://stackoverflow.com/a/54751179
+	//
+	// Takes strings like: 2022-11-04T11:34:45.000Z
+	//                and: 1986-06-11T09:34:46.012Z+0200
+	// ... and converts them into javascript timestamps, following the directions of the timezone stuff.
+	//
+	// This is not meant to replace the more complex libraries.
+	// This *is* meant to be a simple, small, and fast way to convert ISO strings to dates in engines with limited JS capabilities.
+	isoStringToDate (pISOString)
+	{
+
+		// Split the string into an array based on the digit groups.
+		var tmpDateParts = pISOString.split( /\D+/ );
+
+		// Set up a date object with the current time.
+		var tmpReturnDate = new Date();
+
+		// Manually parse the parts of the string and set each part for the
+		// date. Note: Using the UTC versions of these functions is necessary
+		// because we're manually adjusting for time zones stored in the
+		// string.
+		tmpReturnDate.setUTCFullYear( parseInt( tmpDateParts[ 0 ] ) );
+
+		// The month numbers are one "off" from what normal humans would expect
+		// because January == 0.
+		tmpReturnDate.setUTCMonth( parseInt( tmpDateParts[ 1 ] - 1 ) );
+		tmpReturnDate.setUTCDate( parseInt( tmpDateParts[ 2 ] ) );
+
+		// Set the time parts of the date object.
+		tmpReturnDate.setUTCHours( parseInt( tmpDateParts[ 3 ] ) );
+		tmpReturnDate.setUTCMinutes( parseInt( tmpDateParts[ 4 ] ) );
+		tmpReturnDate.setUTCSeconds( parseInt( tmpDateParts[ 5 ] ) );
+		tmpReturnDate.setUTCMilliseconds( parseInt( tmpDateParts[ 6 ] ) );
+
+		// Track the number of hours we need to adjust the date by based on the timezone.
+		var tmpTimeZoneOffsetInHours = 0;
+
+		// If there's a value for either the hours or minutes offset.
+		if (tmpDateParts[ 7 ] || tmpDateParts[ 8 ])
+		{
+
+			// Track the number of minutes we need to adjust the date by based on the timezone.
+			var tmpTimeZoneOffsetInMinutes = 0;
+
+			// If there's a value for the minutes offset.
+			if (tmpDateParts[8])
+			{
+				// Convert the minutes value into an hours value.
+				tmpTimeZoneOffsetInMinutes = parseInt(tmpDateParts[8]) / 60;
+			}
+
+			// Add the hours and minutes values to get the total offset in hours.
+			tmpTimeZoneOffsetInHours = parseInt(tmpDateParts[7]) + tmpTimeZoneOffsetInMinutes;
+
+			// If the sign for the timezone is a plus to indicate the timezone is ahead of UTC time.
+			if (pISOString.substr( -6, 1 ) == "+")
+			{
+				// Make the offset negative since the hours will need to be subtracted from the date.
+				tmpTimeZoneOffsetInHours *= -1;
+			}
+		}
+
+		// Get the current hours for the date and add the offset to get the correct time adjusted for timezone.
+		tmpReturnDate.setHours( tmpReturnDate.getHours() + tmpTimeZoneOffsetInHours );
+
+		// Return the Date object calculated from the string.
+		return tmpReturnDate;
+	}
 }
 
 module.exports = FableServiceUtility;

package/test/DataFormat-StringDateFormatting_tests.js

@@ -0,0 +1,109 @@
+/**
+* Unit tests for DataArithmatic
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var libFable = require('../source/Fable.js');
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+suite
+(
+	'DataArithmatic Date',
+	function()
+	{
+		setup (()=> {} );
+
+		suite
+		(
+			'Format Dates and Times',
+			()=>
+			{
+				test
+				(
+					'Format a time span in milliseconds to a human readable string',
+					(fTestComplete)=>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						Expect(_DataFormat
+							.formatTimeSpan(1000))
+							.to.equal('00:00:01.000');
+						Expect(_DataFormat
+							.formatTimeSpan(100243231))
+							.to.equal('27:50:43.231');
+						Expect(_DataFormat
+							.formatTimeSpan(100299211))
+							.to.equal('27:51:39.211');
+						Expect(_DataFormat
+							.formatTimeSpan())
+							.to.equal('');
+						return fTestComplete();
+					}
+				);
+				test
+				(
+					'Format a time delta in milliseconds to a human readable string',
+					(fTestComplete) =>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						Expect(_DataFormat
+							.formatTimeDelta(1000, 2000))
+							.to.equal('00:00:01.000');
+						Expect(_DataFormat
+							.formatTimeDelta(10000, 20234320230))
+							.to.equal('5620:38:30.230');
+						Expect(_DataFormat
+							.formatTimeDelta(10000))
+							.to.equal('');
+						Expect(_DataFormat
+							.formatTimeDelta())
+							.to.equal('');
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Get a month string from a date',
+					(fTestComplete) =>
+					{
+						let testFable = new libFable();
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						Expect(_DataFormat
+							.getMonthFromDate(new Date('10/20/1988')))
+							.to.equal('October');
+						Expect(_DataFormat
+							.getMonthFromDate(new Date('3/20/1988')))
+							.to.equal('March');
+						Expect(_DataFormat
+							.getMonthAbbreviatedFromDate(new Date('3/20/1988')))
+							.to.equal('Mar');
+						// TODO: Unsure if this is how we want to deal with these.
+						Expect(_DataFormat
+							.getMonthAbbreviatedFromDate(new Date('13/20/1988')))
+							.to.equal(undefined);
+						return fTestComplete();
+					}
+				);
+				test
+				(
+					'Get a sortable string from a date',
+					(fTestComplete) =>
+					{
+						let testFable = new libFable();
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						Expect(_DataFormat
+							.formatSortableStringFromDate(new Date('10/20/1986')))
+							.to.equal('19860920');
+						return fTestComplete();
+					}
+				)
+			}
+		);
+	}
+);

package/test/{FableDataArithmatic_tests.js → DataFormat-StringManipulation_tests.js}

@@ -1,5 +1,5 @@
 /**
-* Unit tests for Fable's DataArithmatic service
+* Unit tests for DataArithmatic
 *
 * @license     MIT
 *
@@ -29,11 +29,11 @@ suite
 					(fTestComplete)=>
 					{
 						let testFable = new libFable({LogStreams: false});
-						let _DataArithmatic = testFable.defaultServices.DataArithmatic;
-						Expect(_DataArithmatic
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						Expect(_DataFormat
 							.stringReverse('Dogs'))
 							.to.equal('sgoD');
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.stringReverse('Florence and the Machine'))
 							.to.equal('enihcaM eht dna ecnerolF');
 						return fTestComplete();
@@ -45,18 +45,18 @@ suite
 					(fTestComplete)=>
 					{
 						let testFable = new libFable({LogStreams: false});
-						let _DataArithmatic = testFable.defaultServices.DataArithmatic;
-						Expect(_DataArithmatic
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						Expect(_DataFormat
 							.insecureStringHash('Dogs'))
 							.to.equal('HSH2135767');
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.insecureStringHash('Dogs1'))
 							.to.equal('HSH66208826');
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.insecureStringHash('This string is longer'))
 							.to.equal('HSH53260210');
 						// This repeat is intentional, to ensure stable hash generation after multiple runs.
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.insecureStringHash('Dogs'))
 							.to.equal('HSH2135767');
 						return fTestComplete();
@@ -68,29 +68,29 @@ suite
 					(fTestComplete)=>
 					{
 						let testFable = new libFable({LogStreams: false});
-						let _DataArithmatic = testFable.defaultServices.DataArithmatic;
+						let _DataFormat = testFable.defaultServices.DataFormat;
 						// Test the enclosure cleaning function
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.cleanEnclosureWrapCharacters('`', '`Dogs`'))
 							.to.equal('Dogs');
 						// Tests a cleaning where the enclosure is not wrapped with the expected character
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.cleanEnclosureWrapCharacters('"', '`Cats`'))
 							.to.equal('`Cats`');
 						// Tests a cleaning where the enclosure is not wrapped with the expected character
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.cleanEnclosureWrapCharacters('"', '"Dogs"'))
 							.to.equal('Dogs');
 						// Test cleaning an enclosure with multiple enclosures of the same type which are expected to stay intact
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.cleanEnclosureWrapCharacters('[', '[Array[with]weird other] Dogs in it['))
 							.to.equal('Array[with]weird other] Dogs in it');
 						// Test cleaning a string where the enclosure character is on one side but not the other
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.cleanEnclosureWrapCharacters('"', '"Dogs'))
 							.to.equal('"Dogs');
 						// Test cleaning a string where the enclosure character is on one side but not the other
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.cleanEnclosureWrapCharacters('"', 'Dogs"'))
 							.to.equal('Dogs"');
 						return fTestComplete();
@@ -102,17 +102,17 @@ suite
 					(fTestComplete)=>
 					{
 						let testFable = new libFable({LogStreams: false});
-						let _DataArithmatic = testFable.defaultServices.DataArithmatic;
-						Expect(_DataArithmatic
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						Expect(_DataFormat
 							.stringStartsWith('Dogs', 'Do'))
 							.to.equal(true);
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.stringStartsWith('Bats', 'Bats'))
 							.to.equal(true);
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.stringStartsWith('Dogs', 'Dogs are cool'))
 							.to.equal(false);
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.stringStartsWith('Dogs', 'Cats'))
 							.to.equal(false);
 						return fTestComplete();
@@ -124,18 +124,18 @@ suite
 					(fTestComplete)=>
 					{
 						let testFable = new libFable({LogStreams: false});
-						let _DataArithmatic = testFable.defaultServices.DataArithmatic;
-						_DataArithmatic._UseEngineStringStartsWith = false;
-						Expect(_DataArithmatic
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						_DataFormat._UseEngineStringStartsWith = false;
+						Expect(_DataFormat
 							.stringStartsWith('Dogs', 'Do'))
 							.to.equal(true);
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.stringStartsWith('Bats', 'Bats'))
 							.to.equal(true);
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.stringStartsWith('Dogs', 'Dogs are cool'))
 							.to.equal(false);
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.stringStartsWith('Dogs', 'Cats'))
 							.to.equal(false);
 						return fTestComplete();
@@ -147,17 +147,17 @@ suite
 					(fTestComplete)=>
 					{
 						let testFable = new libFable({LogStreams: false});
-						let _DataArithmatic = testFable.defaultServices.DataArithmatic;
-						Expect(_DataArithmatic
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						Expect(_DataFormat
 							.stringEndsWith('Dogs', 'gs'))
 							.to.equal(true);
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.stringEndsWith('Bats', 'Bats'))
 							.to.equal(true);
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.stringEndsWith('Dogs', 'Dogs are cool'))
 							.to.equal(false);
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.stringEndsWith('Dogs', 'Cats'))
 							.to.equal(false);
 						return fTestComplete();
@@ -169,25 +169,25 @@ suite
 					(fTestComplete)=>
 					{
 						let testFable = new libFable({LogStreams: false});
-						let _DataArithmatic = testFable.defaultServices.DataArithmatic;
-						_DataArithmatic._UseEngineStringEndsWith = false;
-						Expect(_DataArithmatic
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						_DataFormat._UseEngineStringEndsWith = false;
+						Expect(_DataFormat
 							.stringEndsWith('Dogs', 'gs'))
 							.to.equal(true);
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.stringEndsWith('Bats', 'Bats'))
 							.to.equal(true);
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.stringEndsWith('Dogs', 'Dogs are cool'))
 							.to.equal(false);
 						// We should be able to tell it a midpoint to "end" the string at
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.stringEndsWith('Start from a median point', 'median', 19))
 							.to.equal(true);
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.stringEndsWith('Start from a median point', 'median', 20))
 							.to.equal(false);
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.stringEndsWith('Dogs', 'Cats'))
 							.to.equal(false);
 						return fTestComplete();
@@ -199,24 +199,66 @@ suite
 					(fTestComplete)=>
 					{
 						let testFable = new libFable({LogStreams: false});
-						let _DataArithmatic = testFable.defaultServices.DataArithmatic;
-						Expect(_DataArithmatic
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						Expect(_DataFormat
 							.cleanNonAlphaCharacters('Dogs'))
 							.to.equal('Dogs');
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.cleanNonAlphaCharacters('Dogs are cool'))
 							.to.equal('Dogs_are_cool');
-						Expect(_DataArithmatic
+						Expect(_DataFormat
 							.cleanNonAlphaCharacters('Dogs are cool!'))
 							.to.equal('Dogs_are_cool_');
 						// Test cleaning with no character
-						_DataArithmatic._Value_Clean_formatterCleanNonAlpha = '';
-						Expect(_DataArithmatic
+						_DataFormat._Value_Clean_formatterCleanNonAlpha = '';
+						Expect(_DataFormat
 							.cleanNonAlphaCharacters('Dogs are cool!'))
 							.to.equal('Dogsarecool');
 						return fTestComplete();
 					}
 				);
+				test
+				(
+					'Pad the beginning of a string',
+					(fTestComplete)=>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						// The usual use case (e.g. for zero padding dates)
+						Expect(_DataFormat.stringPadStart('9', 2, '0'))
+							.to.equal('09');
+						Expect(_DataFormat.stringPadStart('11', 2, '0'))
+							.to.equal('11');
+						// Try some longer paddings
+						Expect(_DataFormat.stringPadStart('8675309', 20, '0'))
+							.to.equal('00000000000008675309');
+						// Should not be destructive
+						Expect(_DataFormat.stringPadStart('8675309', 1, '0'))
+							.to.equal('8675309');
+						// Pad with a longer filler string with shifting data
+						Expect(_DataFormat.stringPadStart('ning', 20, 'aaaaw'))
+							.to.equal('aaaawaaaawaaaawaning');
+						// Table of contents?
+						Expect(_DataFormat.stringPadStart('Chapter 1', 20, '.'))
+							.to.equal('...........Chapter 1');
+
+						return fTestComplete();
+					}
+				);
+				test
+				(
+					'Pad the end of a string',
+					(fTestComplete)=>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						// The usual use case (e.g. for left justifying text in fixed-width scenarios)
+						Expect(_DataFormat.stringPadEnd('Bob', 10, ' '))
+							.to.equal('Bob       ');
+
+						return fTestComplete();
+					}
+				)
 			}
 		);
 	}

package/test/DataFormat-StringNumberFormatting_tests.js

@@ -0,0 +1,110 @@
+/**
+* Unit tests for DataArithmatic
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var libFable = require('../source/Fable.js');
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+suite
+(
+	'DataArithmatic Number',
+	function()
+	{
+		setup (()=> {} );
+
+		suite
+		(
+			'Format Number Strings',
+			()=>
+			{
+				test
+				(
+					'Test adding commas to a number',
+					(fTestComplete)=>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						Expect(_DataFormat
+							.formatterAddCommasToNumber(1000))
+							.to.equal('1,000');
+						Expect(_DataFormat
+							.formatterAddCommasToNumber('This is not a number'))
+							.to.equal('This is not a number');
+						Expect(_DataFormat
+							.formatterAddCommasToNumber(102931021))
+							.to.equal('102,931,021');
+						Expect(_DataFormat
+							.formatterAddCommasToNumber(-100000000.7333312))
+							.to.equal('-100,000,000.7333312');
+						Expect(_DataFormat
+							.formatterAddCommasToNumber(`$8675309.75`))
+							.to.equal('$8675309.75');
+						return fTestComplete();
+					}
+				);
+				test
+				(
+					'Test formatting dollars',
+					(fTestComplete)=>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						Expect(_DataFormat
+							.formatterDollars(1000))
+							.to.equal('$1,000.00');
+						Expect(_DataFormat
+							.formatterDollars('Not dollars!'))
+							.to.equal('--');
+						Expect(_DataFormat
+							.formatterDollars(10000))
+							.to.equal('$10,000.00');
+						Expect(_DataFormat
+							.formatterDollars(-8675309.75))
+							.to.equal('$-8,675,309.75');
+						Expect(_DataFormat
+							.formatterDollars(72.3198))
+							.to.equal('$72.32');
+						Expect(_DataFormat
+							.formatterDollars(72.3119))
+							.to.equal('$72.31');
+						return fTestComplete();
+					}
+				);
+				test
+				(
+					'Test rounding numbers',
+					(fTestComplete)=>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						Expect(_DataFormat
+							.formatterRoundNumber(1000, 2))
+							.to.equal('1000.00');
+						Expect(_DataFormat
+							.formatterRoundNumber(1000.129, 2))
+							.to.equal('1000.13');
+						Expect(_DataFormat
+							.formatterRoundNumber(1000.781))
+							.to.equal('1000.78');
+						Expect(_DataFormat
+							.formatterRoundNumber(867.5309, 3))
+							.to.equal('867.531');
+						Expect(_DataFormat
+							.formatterRoundNumber(-732.777, 2))
+							.to.equal('-732.78');
+						Expect(_DataFormat
+							.formatterRoundNumber('Not a number'))
+							.to.equal('0.00');
+						return fTestComplete();
+					}
+				);
+			}
+		);
+	}
+);