fable 3.0.50 → 3.0.52

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

@@ -8,120 +8,190 @@ class FableServiceFilePersistence extends libFableServiceBase
 {
 	constructor(pFable, pOptions, pServiceHash)
 	{
-        super(pFable, pOptions, pServiceHash);
+		super(pFable, pOptions, pServiceHash);
 
-        this.serviceType = 'FilePersistence';
+		this.serviceType = 'FilePersistence';
 
-        if (!this.options.hasOwnProperty('Mode'))
-        {
-            this.options.Mode = parseInt('0777', 8) & ~process.umask();
-        }
+		if (!this.options.hasOwnProperty('Mode'))
+		{
+			this.options.Mode = parseInt('0777', 8) & ~process.umask();
+		}
+
+		this.currentInputFolder = `/tmp`;
+		this.currentOutputFolder = `/tmp`;
+	}
+
+	joinPath(pPathArray)
+	{
+		return libPath.resolve(...pPathArray);
+	}
+
+	existsSync(pPath)
+	{
+		return libFS.existsSync(pPath);
+	}
+
+	exists(pPath, fCallback)
+	{
+		let tmpFileExists = this.existsSync(pPath);;
+
+		return fCallback(null, tmpFileExists);
+	}
+
+	writeFileSync(pFileName, pFileContent, pOptions)
+	{
+		let tmpOptions = (typeof(pOptions) === 'undefined') ? 'utf8' : pOptions;
+		return libFS.writeFileSync(pFileName, pFileContent, tmpOptions);
+	}
+
+	appendFileSync(pFileName, pAppendContent, pOptions)
+	{
+		let tmpOptions = (typeof(pOptions) === 'undefined') ? 'utf8' : pOptions;
+		return libFS.appendFileSync(pFileName, pAppendContent, tmpOptions);
+	}
+
+	deleteFileSync(pFileName)
+	{
+		return libFS.unlinkSync(pFileName);
+	}
+
+	writeFileSyncFromObject(pFileName, pObject)
+	{
+		return this.writeFileSync(pFileName, JSON.stringify(pObject, null, 4));
+	}
+
+	writeFileSyncFromArray(pFileName, pFileArray)
+	{
+		if (!Array.isArray(pFileArray))
+		{
+			this.log.error(`File Persistence Service attempted to write ${pFileName} from array but the expected array was not an array (it was a ${typeof(pFileArray)}).`);
+			return Error('Attempted to write ${pFileName} from array but the expected array was not an array (it was a ${typeof(pFileArray)}).');
+		}
+		else
+		{
+			for (let i = 0; i < pFileArray.length; i++)
+			{
+				return this.appendFileSync(pFileName, `${pFileArray[i]}\n`);
+			}
+		}
 	}
 
-    existsSync(pPath)
-    {
-        return libFS.existsSync(pPath);
-    }
-
-    exists(pPath, fCallback)
-    {
-        let tmpFileExists = this.existsSync(pPath);;
-
-        return fCallback(null, tmpFileExists);
-    }
-
-    makeFolderRecursive (pParameters, fCallback)
-    {
-        let tmpParameters = pParameters;
-
-        if (typeof(pParameters) == 'string')
-        {
-            tmpParameters = { Path: pParameters };
-        }
-        else if (typeof(pParameters) !== 'object')
-        {
-            fCallback(new Error('Parameters object or string not properly passed to recursive folder create.'));
-            return false;
-        }
-
-        if ((typeof(tmpParameters.Path) !== 'string'))
-        {
-            fCallback(new Error('Parameters object needs a path to run the folder create operation.'));
-            return false;
-        }
-
-        if (!tmpParameters.hasOwnProperty('Mode'))
-        {
-            tmpParameters.Mode = this.options.Mode;
-        }
-
-        // Check if we are just starting .. if so, build the initial state for our recursive function
-        if (typeof(tmpParameters.CurrentPathIndex) === 'undefined')
-        {
-            // Build the tools to start recursing
-            tmpParameters.ActualPath = libPath.normalize(tmpParameters.Path);
-            tmpParameters.ActualPathParts = tmpParameters.ActualPath.split(libPath.sep);
-            tmpParameters.CurrentPathIndex = 0;
-            tmpParameters.CurrentPath = '';
-        }
-        else
-        {
-            // This is not our first run, so we will continue the recursion.
-            // Build the new base path
-            if (tmpParameters.CurrentPath == libPath.sep)
-            {
-                tmpParameters.CurrentPath = tmpParameters.CurrentPath + tmpParameters.ActualPathParts[tmpParameters.CurrentPathIndex];
-            }
-            else
-            {
-                tmpParameters.CurrentPath = tmpParameters.CurrentPath + libPath.sep + tmpParameters.ActualPathParts[tmpParameters.CurrentPathIndex];
-            }
-
-            // Increment the path index
-            tmpParameters.CurrentPathIndex++;
-        }
-
-        // Check if the path is fully complete
-        if (tmpParameters.CurrentPathIndex >= tmpParameters.ActualPathParts.length)
-        {
-            fCallback(null);
-            return true;
-        }
-
-        // Check if the path exists
-        libFS.open(tmpParameters.CurrentPath + libPath.sep + tmpParameters.ActualPathParts[tmpParameters.CurrentPathIndex], 'r',
-            function(pError, pFileDescriptor)
-            {
-                if (pFileDescriptor)
-                {
-                    libFS.closeSync(pFileDescriptor);
-                }
-
-                if (pError && pError.code=='ENOENT')
-                {
-                    /* Path doesn't exist, create it */
-                    libFS.mkdir(tmpParameters.CurrentPath + libPath.sep + tmpParameters.ActualPathParts[tmpParameters.CurrentPathIndex], tmpParameters.Mode,
-                        (pCreateError) =>
-                        {
-                            if (!pCreateError)
-                            {
-                                // We have now created our folder and there was no error -- continue.
-                                return this.makeFolderRecursive(tmpParameters, fCallback);
-                            }
-                            else
-                            {
-                                fCallback(pCreateError);
-                                return false;
-                            }
-                        });
-                }
-                else
-                {
-                    return this.makeFolderRecursive(tmpParameters, fCallback);
-                }
-            }
-        );
-    }
+	// Default folder behaviors
+
+	getDefaultOutputPath(pFileName)
+	{
+		return libPath.join(this.currentOutputFolder, pFileName);
+	}
+
+	dataFolderWriteSync(pFileName, pFileContent)
+	{
+		return this.writeFileSync(this.getDefaultOutputPath(pFileName), pFileContent);
+	}
+
+	dataFolderWriteSyncFromObject(pFileName, pObject)
+	{
+		return this.writeFileSyncFromObject(this.getDefaultOutputPath(pFileName), pObject);
+	}
+
+	dataFolderWriteSyncFromArray(pFileName, pFileArray)
+	{
+		return this.writeFileSyncFromArray(this.getDefaultOutputPath(pFileName), pFileArray);
+	}
+
+	// Folder management
+
+	makeFolderRecursive (pParameters, fCallback)
+	{
+		let tmpParameters = pParameters;
+
+		if (typeof(pParameters) == 'string')
+		{
+			tmpParameters = { Path: pParameters };
+		}
+		else if (typeof(pParameters) !== 'object')
+		{
+			fCallback(new Error('Parameters object or string not properly passed to recursive folder create.'));
+			return false;
+		}
+
+		if ((typeof(tmpParameters.Path) !== 'string'))
+		{
+			fCallback(new Error('Parameters object needs a path to run the folder create operation.'));
+			return false;
+		}
+
+		if (!tmpParameters.hasOwnProperty('Mode'))
+		{
+			tmpParameters.Mode = this.options.Mode;
+		}
+
+		// Check if we are just starting .. if so, build the initial state for our recursive function
+		if (typeof(tmpParameters.CurrentPathIndex) === 'undefined')
+		{
+			// Build the tools to start recursing
+			tmpParameters.ActualPath = libPath.normalize(tmpParameters.Path);
+			tmpParameters.ActualPathParts = tmpParameters.ActualPath.split(libPath.sep);
+			tmpParameters.CurrentPathIndex = 0;
+			tmpParameters.CurrentPath = '';
+		}
+		else
+		{
+			// This is not our first run, so we will continue the recursion.
+			// Build the new base path
+			if (tmpParameters.CurrentPath == libPath.sep)
+			{
+				tmpParameters.CurrentPath = tmpParameters.CurrentPath + tmpParameters.ActualPathParts[tmpParameters.CurrentPathIndex];
+			}
+			else
+			{
+				tmpParameters.CurrentPath = tmpParameters.CurrentPath + libPath.sep + tmpParameters.ActualPathParts[tmpParameters.CurrentPathIndex];
+			}
+
+			// Increment the path index
+			tmpParameters.CurrentPathIndex++;
+		}
+
+		// Check if the path is fully complete
+		if (tmpParameters.CurrentPathIndex >= tmpParameters.ActualPathParts.length)
+		{
+			fCallback(null);
+			return true;
+		}
+
+		// Check if the path exists (and is a folder)
+		libFS.open(tmpParameters.CurrentPath + libPath.sep + tmpParameters.ActualPathParts[tmpParameters.CurrentPathIndex], 'r',
+			function(pError, pFileDescriptor)
+			{
+				if (pFileDescriptor)
+				{
+					libFS.closeSync(pFileDescriptor);
+				}
+
+				if (pError && pError.code=='ENOENT')
+				{
+					/* Path doesn't exist, create it */
+					libFS.mkdir(tmpParameters.CurrentPath + libPath.sep + tmpParameters.ActualPathParts[tmpParameters.CurrentPathIndex], tmpParameters.Mode,
+						(pCreateError) =>
+						{
+							if (!pCreateError)
+							{
+								// We have now created our folder and there was no error -- continue.
+								return this.makeFolderRecursive(tmpParameters, fCallback);
+							}
+							else
+							{
+								fCallback(pCreateError);
+								return false;
+							}
+						});
+				}
+				else
+				{
+					return this.makeFolderRecursive(tmpParameters, fCallback);
+				}
+			}
+		);
+	}
 }
 
 module.exports = FableServiceFilePersistence;

package/test/Anticipate_tests.js

@@ -0,0 +1,91 @@
+/**
+* Unit tests for the Anticipate pattern
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+const libFable = require('../source/Fable.js');
+
+const Chai = require("chai");
+const Expect = Chai.expect;
+
+suite
+	(
+		'Fable Anticipate',
+		() =>
+		{
+			setup(() => { });
+
+			suite
+				(
+					'Basic Asynchronous Operations',
+					function ()
+					{
+						test
+							(
+								'Setup some async calls and make sure they run',
+								function (fTestComplete)
+								{
+									let testFable = new libFable();
+									let tmpAnticipate = testFable.serviceManager.instantiateServiceProvider('Anticipate');
+									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.wait(function (pError)
+									{
+										testFable.log.info(`Wait 1 completed: ${pError}`)
+										return fTestComplete();
+									});
+								}
+							);
+						test
+							(
+								'Setup some async calls to run together and make sure they run',
+								function (fTestComplete)
+								{
+									let testFable = new libFable();
+									let tmpAnticipate = testFable.serviceManager.instantiateServiceProvider('Anticipate');
+									tmpAnticipate.maxOperations = 2;
+									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.wait(function (pError)
+									{
+										testFable.log.info(`Wait 1 completed: ${pError}`)
+										return fTestComplete();
+									});
+								}
+							);
+					}
+				);
+		}
+	);

package/test/DataGeneration_tests.js

@@ -0,0 +1,109 @@
+/**
+* Unit tests for the Anticipate pattern
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+const libFable = require('../source/Fable.js');
+
+const Chai = require("chai");
+const Expect = Chai.expect;
+
+suite
+	(
+		'Fable Data Generation',
+		() =>
+		{
+			setup(() => { });
+
+			suite
+				(
+					'Generate random numbers and strings',
+					function ()
+					{
+						test
+							(
+								'Just get me a random number',
+								function (fTestComplete)
+								{
+									let testFable = new libFable();
+									let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+									Expect(tmpDataGeneration.randomIntegerUpTo(100)).to.be.within(0, 100);
+									return fTestComplete();
+								}
+							);
+						test
+							(
+								'How about a random number string!',
+								function (fTestComplete)
+								{
+									let testFable = new libFable();
+									let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+									Expect(tmpDataGeneration.randomNumericString()).to.be.a('string');
+									Expect(tmpDataGeneration.randomNumericString().length).to.equal(10);
+									return fTestComplete();
+								}
+							);
+						test
+							(
+								'How about a random color?',
+								function (fTestComplete)
+								{
+									let testFable = new libFable();
+									let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+									testFable.log.info(`Random color: ${tmpDataGeneration.randomColor()}`);
+									Expect(tmpDataGeneration.randomColor()).to.be.a('string');
+									return fTestComplete();
+								}
+							);
+						test
+							(
+								'DayOfWeek',
+								function (fTestComplete)
+								{
+									let testFable = new libFable();
+									let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+									testFable.log.info(`Random Day of Week: ${tmpDataGeneration.randomDayOfWeek()}`);
+									Expect(tmpDataGeneration.randomDayOfWeek()).to.be.a('string');
+									return fTestComplete();
+								}
+							);
+						test
+							(
+								'Month',
+								function (fTestComplete)
+								{
+									let testFable = new libFable();
+									let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+									testFable.log.info(`Random Month: ${tmpDataGeneration.randomMonth()}`);
+									Expect(tmpDataGeneration.randomMonth()).to.be.a('string');
+									return fTestComplete();
+								}
+							);
+						test
+							(
+								'First name',
+								function (fTestComplete)
+								{
+									let testFable = new libFable();
+									let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+									testFable.log.info(`Random Name: ${tmpDataGeneration.randomName()}`);
+									Expect(tmpDataGeneration.randomName()).to.be.a('string');
+									return fTestComplete();
+								}
+							);
+						test
+							(
+								'Surname',
+								function (fTestComplete)
+								{
+									let testFable = new libFable();
+									let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+									testFable.log.info(`Random Surname: ${tmpDataGeneration.randomSurname()}`);
+									Expect(tmpDataGeneration.randomSurname()).to.be.a('string');
+									return fTestComplete();
+								}
+							);
+					}
+				);
+		}
+	);

package/test/FilePersistence_tests.js

@@ -1,5 +1,5 @@
 /**
-* Unit tests for Fable
+* Unit tests for the Fable simple-get RestClient
 *
 * @license     MIT
 *
@@ -11,24 +11,91 @@ var libFable = require('../source/Fable.js');
 var Chai = require("chai");
 var Expect = Chai.expect;
 
+// https://en.wiktionary.org/w/api.php?action=parse&prop=wikitext&format=json&page=dog
+
 suite
 (
-	'File Persistence',
+	'Fable FilePersistence',
 	function()
 	{
+		setup
+		(
+			function() { }
+		);
+
 		suite
 		(
-			'Work with Files',
+			'Basic File Management',
 			function()
 			{
 				test
 				(
-					'Recursively Create a Folder',
-					function(fDone)
+					'Check that a file exists',
+					function(fTestComplete)
+					{
+						let testFable = new libFable();
+						let tmpFilePersistence = testFable.serviceManager.instantiateServiceProvider('FilePersistence');
+						Expect(tmpFilePersistence).is.an('object');
+						Expect(tmpFilePersistence.existsSync(`${__dirname}/../package.json`)).to.equal(true);
+						Expect(tmpFilePersistence.existsSync(`${__dirname}/package.json`)).to.equal(false);
+						return fTestComplete();
+					}
+				);
+				test
+				(
+					'Create, write, read and then delete a file.',
+					function(fTestComplete)
 					{
 						let testFable = new libFable();
+						let tmpFilePersistence = testFable.serviceManager.instantiateServiceProvider('FilePersistence');
+						let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+
+						let tmpLogFilePath = `/tmp/Fable-Test-${tmpDataGeneration.randomNumericString()}.log`;
+						testFable.log.info(`Writing test log file: [${tmpLogFilePath}]`);
+
+						Expect(tmpFilePersistence.existsSync(tmpLogFilePath)).to.equal(false);
+
+						// Now write some data to the file.
+						tmpFilePersistence.writeFileSyncFromObject(tmpLogFilePath, testFable.settings);
+
+						Expect(tmpFilePersistence.existsSync(tmpLogFilePath)).to.equal(true);
+
+						// Now delete the file
+						tmpFilePersistence.deleteFileSync(tmpLogFilePath);
+						
+						Expect(tmpFilePersistence.existsSync(tmpLogFilePath)).to.equal(false);
+
+						return fTestComplete();
+					}
+				);
+				test
+				(
+					'Create, write, read and then delete a file.',
+					function(fTestComplete)
+					{
+						let testFable = new libFable();
+						let tmpFilePersistence = testFable.serviceManager.instantiateServiceProvider('FilePersistence');
+						let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+
+						let tmpLogFilePath = `/tmp/Fable-Test-${tmpDataGeneration.randomNumericString()}.log`;
+						testFable.log.info(`Writing test log file: [${tmpLogFilePath}]`);
+
+						Expect(tmpFilePersistence.existsSync(tmpLogFilePath)).to.equal(false);
+
+						// Now write some data to the file.
+						for (let i = 0; i < 100; i++)
+						{
+							tmpFilePersistence.appendFileSync(tmpLogFilePath, `Line ${i} got a number like ${tmpDataGeneration.randomColor()} ${tmpDataGeneration.randomNumericString(3,789)} for ${tmpDataGeneration.randomName()} ${tmpDataGeneration.randomSurname()}!\n`);
+						}
+
+						Expect(tmpFilePersistence.existsSync(tmpLogFilePath)).to.equal(true);
+
+						// Now delete the file
+						tmpFilePersistence.deleteFileSync(tmpLogFilePath);
+						
+						Expect(tmpFilePersistence.existsSync(tmpLogFilePath)).to.equal(false);
 
-						return fDone();
+						return fTestComplete();
 					}
 				);
 			}

package/gulpfile-config.json

@@ -1,11 +0,0 @@
-{
-	"EntrypointInputSourceFile": "./source/Fable-Browser-Shim.js",
-
-	"LibraryObjectName": "Fable",
-
-	"LibraryOutputFolder": "./dist/",
-
-	"LibraryUniminifiedFileName": "fable.compatible.js",
-
-	"LibraryMinifiedFileName": "fable.compatible.min.js"
-}

package/gulpfile-config_compatible.json

@@ -1,11 +0,0 @@
-{
-	"EntrypointInputSourceFile": "./source/Fable-Browser-Shim.js",
-
-	"LibraryObjectName": "Fable",
-
-	"LibraryOutputFolder": "./dist/",
-
-	"LibraryUniminifiedFileName": "fable.compatible.js",
-
-	"LibraryMinifiedFileName": "fable.compatible.min.js"
-}

package/gulpfile-config_default.json

@@ -1,11 +0,0 @@
-{
-	"EntrypointInputSourceFile": "./source/Fable-Browser-Shim.js",
-
-	"LibraryObjectName": "Fable",
-
-	"LibraryOutputFolder": "./dist/",
-
-	"LibraryUniminifiedFileName": "fable.js",
-
-	"LibraryMinifiedFileName": "fable.min.js"
-}