fable 3.0.38 → 3.0.39

package/gulpfile-config.json

@@ -5,7 +5,7 @@
 
 	"LibraryOutputFolder": "./dist/",
 
-	"LibraryUniminifiedFileName": "fable.js",
+	"LibraryUniminifiedFileName": "fable.compatible.js",
 
-	"LibraryMinifiedFileName": "fable.min.js"
+	"LibraryMinifiedFileName": "fable.compatible.min.js"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fable",
-  "version": "3.0.38",
+  "version": "3.0.39",
   "description": "An entity behavior management and API bundling library.",
   "main": "source/Fable.js",
   "scripts": {
@@ -32,7 +32,8 @@
     ]
   },
   "browser": {
-    "./source/service/Fable-Service-EnvironmentData.js": "./source/service/Fable-Service-EnvironmentData-Web.js"
+    "./source/service/Fable-Service-EnvironmentData.js": "./source/service/Fable-Service-EnvironmentData-Web.js",
+    "./source/service/Fable-Service-FilePersistence.js": "./source/service/Fable-Service-FilePersistence-Web.js"
   },
   "repository": {
     "type": "git",
@@ -72,6 +73,7 @@
     "fable-serviceproviderbase": "^3.0.3",
     "fable-settings": "^3.0.5",
     "fable-uuid": "^3.0.5",
+    "manyfest": "^1.0.24",
     "precedent": "^1.0.10",
     "simple-get": "^4.0.1"
   }

package/source/Fable.js

@@ -50,6 +50,12 @@ class Fable
 		this.serviceManager.addServiceType('Operation', require('./services/Fable-Service-Operation.js'));
 		this.serviceManager.addServiceType('RestClient', require('./services/Fable-Service-RestClient.js'));
 		this.serviceManager.addServiceType('CSVParser', require('./services/Fable-Service-CSVParser.js'));
+		this.serviceManager.addServiceType('Manifest', require('manyfest'));
+	}
+
+	get isFable()
+	{
+		return true;
 	}
 
 	get settings()
@@ -85,7 +91,7 @@ class Fable
 	get fable()
 	{
 		return this;
-	}
+	};
 }
 
 // This is for backwards compatibility

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

@@ -0,0 +1,36 @@
+const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+
+class FableServiceFilePersistence extends libFableServiceBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'FilePersistence';
+
+        if (!this.options.hasOwnProperty('Mode'))
+        {
+            this.options.Mode = parseInt('0777', 8) & ~process.umask();
+        }
+	}
+
+    existsSync(pPath)
+    {
+        //return libFS.existsSync(pPath);
+        return false;
+    }
+
+    exists(pPath, fCallback)
+    {
+        let tmpFileExists = this.existsSync(pPath);;
+
+        return fCallback(null, tmpFileExists);
+    }
+
+    makeFolderRecursive (pParameters, fCallback)
+    {
+        return fCallback();
+    }
+}
+
+module.exports = FableServiceFilePersistence;

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

@@ -0,0 +1,127 @@
+const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+
+const libFS = require('fs');
+const libPath = require('path');
+
+
+class FableServiceFilePersistence extends libFableServiceBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'FilePersistence';
+
+        if (!this.options.hasOwnProperty('Mode'))
+        {
+            this.options.Mode = parseInt('0777', 8) & ~process.umask();
+        }
+	}
+
+    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);
+                }
+            }
+        );
+    }
+}
+
+module.exports = FableServiceFilePersistence;

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

@@ -85,8 +85,9 @@ class FableServiceUtility extends libFableServiceBase
 	//                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.
+	// This is not meant to replace the more complex libraries such as moment or luxon.
+	// This *is* meant to be a simple, small, and fast way to convert ISO strings to dates in engines
+	// with ultra limited JS capabilities where those don't work.
 	isoStringToDate (pISOString)
 	{
 

package/test/FilePersistence_tests.js

@@ -0,0 +1,37 @@
+/**
+* Unit tests for Fable
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var libFable = require('../source/Fable.js');
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+suite
+(
+	'File Persistence',
+	function()
+	{
+		suite
+		(
+			'Work with Files',
+			function()
+			{
+				test
+				(
+					'Recursively Create a Folder',
+					function(fDone)
+					{
+						let testFable = new libFable();
+
+						return fDone();
+					}
+				);
+			}
+		);
+	}
+);

package/test/Manifest_tests.js

@@ -0,0 +1,79 @@
+/**
+* Unit tests for Fable
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var libFable = require('../source/Fable.js');
+
+const libFS = require('fs');
+const libReadline = require('readline');
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+suite
+(
+	'Manyfest Object Address Resolution',
+	function()
+	{
+		suite
+		(
+			'Manifiesta',
+			function()
+			{
+				test
+				(
+					'Basic object reading and writing',
+					function(fDone)
+					{
+						let testFable = new libFable();
+
+						let animalManyfest = testFable.serviceManager.instantiateServiceProvider('Manifest',
+							{
+								"Scope": "Animal",
+								"Descriptors":
+									{
+										"IDAnimal": { "Name":"Database ID", "Description":"The unique integer-based database identifier for an Animal record.", "DataType":"Integer" },
+										"Name": { "Description":"The animal's colloquial species name (e.g. Rabbit, Dog, Bear, Mongoose)." },
+										"Type": { "Description":"Whether or not the animal is wild, domesticated, agricultural, in a research lab or a part of a zoo.." },
+										"MedicalStats":
+											{
+												"Name":"Medical Statistics", "Description":"Basic medical statistics for this animal"
+											},
+										"MedicalStats.Temps.MinET": { "Name":"Minimum Environmental Temperature", "NameShort":"MinET", "Description":"Safest minimum temperature for this animal to survive in."},
+										"MedicalStats.Temps.MaxET": { "Name":"Maximum Environmental Temperature", "NameShort":"MaxET", "Description":"Safest maximum temperature for this animal to survive in."},
+										"MedicalStats.Temps.CET":
+											{
+												"Name":"Comfortable Environmental Temperature",
+												"NameShort":"Comf Env Temp",
+												"Hash":"ComfET",
+												"Description":"The most comfortable temperature for this animal to survive in.",
+												"Default": "96.8"
+											}
+									}
+							});
+
+						Expect(animalManyfest.getValueByHash({MedicalStats: { Temps: { CET:200 }},Name:'Froggy'}, 'ComfET')).to.equal(200);
+						Expect(animalManyfest.getValueByHash({MedicalStats: { Temps: { MinET:200 }},Name:'Froggy'}, 'ComfET')).to.equal('96.8');
+						Expect(animalManyfest.getValueByHash({MedicalStats: { Temps: { MinET:200 }},Name:'Froggy'}, 'CurrentTemperature')).to.equal(undefined);
+
+						// Now change the comfortable environmental temperature for the Froggy to be 200
+						let tmpRecord = {MedicalStats: { Temps: { MinET:200 }},Name:'Froggy'};
+						animalManyfest.setValueByHash(tmpRecord, 'ComfET', 200);
+						Expect(animalManyfest.getValueByHash(tmpRecord, 'ComfET')).to.equal(200);
+
+						Expect(animalManyfest.getValueAtAddress({MedicalStats: { Temps: { CET:200 }},Name:'Froggy'}, 'MedicalStats.Temps.CET')).to.equal(200);
+						Expect(animalManyfest.getValueAtAddress({MedicalStats: { Temps: { MinET:200 }},Name:'Froggy'}, 'MedicalStats.Temps.CET')).to.equal('96.8');
+						Expect(animalManyfest.getValueAtAddress({MedicalStats: { Temps: { MinET:200 }},Name:'Froggy'}, 'MedicalStats.Temps.HighET')).to.equal(undefined);
+
+
+						return fDone();
+					}
+				);
+			}
+		);
+	}
+);