fable 3.0.49 → 3.0.51

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

@@ -16,8 +16,16 @@ class FableServiceFilePersistence extends libFableServiceBase
         {
             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);
@@ -30,6 +38,63 @@ class FableServiceFilePersistence extends libFableServiceBase
         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);
+    }
+
+	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;
@@ -88,7 +153,7 @@ class FableServiceFilePersistence extends libFableServiceBase
             return true;
         }
 
-        // Check if the path exists
+        // Check if the path exists (and is a folder)
         libFS.open(tmpParameters.CurrentPath + libPath.sep + tmpParameters.ActualPathParts[tmpParameters.CurrentPathIndex], 'r',
             function(pError, pFileDescriptor)
             {

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/DataFormat-StringManipulation_tests.js

@@ -62,6 +62,37 @@ suite
 						return fTestComplete();
 					}
 				)
+				test
+				(
+					'Remove non-alpha characters from a string',
+					(fTestComplete)=>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						Expect(_DataFormat.cleanNonAlphaCharacters('Dogs'))
+							.to.equal('Dogs');
+						Expect(_DataFormat.cleanNonAlphaCharacters('Dogs1'))
+							.to.equal('Dogs');
+						Expect(_DataFormat.cleanNonAlphaCharacters('Dogs-with-guns 12321'))
+							.to.equal('Dogswithguns');
+						return fTestComplete();
+					}
+				)
+				test
+				(
+					'Capitalize each word in a string',
+					(fTestComplete)=>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataFormat = testFable.defaultServices.DataFormat;
+						Expect(_DataFormat.capitalizeEachWord('Dogs-with-guns 12321'))
+							.to.equal('Dogs-With-Guns 12321');
+						Expect(_DataFormat.cleanNonAlphaCharacters(_DataFormat.capitalizeEachWord('meadow-endpoints')))
+							.to.equal('MeadowEndpoints');
+						return fTestComplete();
+					}
+				)
+
 				test
 				(
 					'Clean wrapping characters from a valid enclosure.',
@@ -205,15 +236,15 @@ suite
 							.to.equal('Dogs');
 						Expect(_DataFormat
 							.cleanNonAlphaCharacters('Dogs are cool'))
-							.to.equal('Dogs_are_cool');
+							.to.equal('Dogsarecool');
 						Expect(_DataFormat
 							.cleanNonAlphaCharacters('Dogs are cool!'))
-							.to.equal('Dogs_are_cool_');
+							.to.equal('Dogsarecool');
 						// Test cleaning with no character
-						_DataFormat._Value_Clean_formatterCleanNonAlpha = '';
+						_DataFormat._Value_Clean_formatterCleanNonAlpha = '_';
 						Expect(_DataFormat
 							.cleanNonAlphaCharacters('Dogs are cool!'))
-							.to.equal('Dogsarecool');
+							.to.equal('Dogs_are_cool_');
 						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, 99);
+									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/gulpfile-config.json

@@ -1,11 +0,0 @@
-{
-	"EntrypointInputSourceFile": "./source/Fable-Browser-Shim.js",
-
-	"LibraryObjectName": "Fable",
-
-	"LibraryOutputFolder": "./dist/",
-
-	"LibraryUniminifiedFileName": "fable.js",
-
-	"LibraryMinifiedFileName": "fable.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"
-}