fable 3.0.51 → 3.0.52

package/package.json

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

package/source/Fable.js

@@ -54,6 +54,7 @@ class Fable
 		this.serviceManager.addServiceType('CSVParser', require('./services/Fable-Service-CSVParser.js'));
 		this.serviceManager.addServiceType('Manifest', require('manyfest'));
 		this.serviceManager.addServiceType('ObjectCache', require('cachetrax'));
+		this.serviceManager.addServiceType('FilePersistence', require('./services/Fable-Service-FilePersistence.js'));
 	}
 
 	get isFable()

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

@@ -8,75 +8,80 @@ 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`;
+		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;
-        libFS.writeFileSync(pFileName, pFileContent, tmpOptions);
-    }
-
-    appendFileSync(pFileName, pAppendContent, pOptions)
-    {
-        let tmpOptions = (typeof(pOptions) === 'undefined') ? 'utf8' : pOptions;
-        libFS.appendFileSync(pFileName, pAppendContent, tmpOptions);
-    }
-
-    writeFileSyncFromObject(pFileName, pObject)
-    {
-        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++)
-            {
-                this.appendFileSync(pFileName, `${pFileArray[i]}\n`);
-            }
-        }
-    }
-
-    // Default folder behaviors
-
-    getDefaultOutputPath(pFileName)
-    {
-        return libPath.join(this.currentOutputFolder, pFileName);
-    }
+	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`);
+			}
+		}
+	}
+
+	// Default folder behaviors
+
+	getDefaultOutputPath(pFileName)
+	{
+		return libPath.join(this.currentOutputFolder, pFileName);
+	}
 
 	dataFolderWriteSync(pFileName, pFileContent)
 	{
@@ -93,100 +98,100 @@ class FableServiceFilePersistence extends libFableServiceBase
 		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);
-                }
-            }
-        );
-    }
+	// 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/DataGeneration_tests.js

@@ -27,7 +27,7 @@ suite
 								{
 									let testFable = new libFable();
 									let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
-									Expect(tmpDataGeneration.randomIntegerUpTo(100)).to.be.within(0, 99);
+									Expect(tmpDataGeneration.randomIntegerUpTo(100)).to.be.within(0, 100);
 									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();
 					}
 				);
 			}