manyfest 1.0.7 → 1.0.8

package/.config/code-server/config.yaml

@@ -1,4 +1,4 @@
 bind-addr: 127.0.0.1:8080
 auth: password
-password: luxury
+password: retold
 cert: false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "manyfest",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "JSON Object Manifest for Data Description and Parsing",
   "main": "source/Manyfest.js",
   "scripts": {

package/source/Manyfest-ObjectAddressGeneration.js

@@ -0,0 +1,123 @@
+/**
+* @license MIT
+* @author <steven@velozo.com>
+*/
+let libSimpleLog = require('./Manyfest-LogToConsole.js');
+
+/**
+* Object Address Generation
+*
+* Automagically generate addresses and properties based on a passed-in object, 
+* to be used for easy creation of schemas.  Meant to simplify the lives of
+* developers wanting to create schemas without typing a bunch of stuff.
+* 
+* IMPORTANT NOTE: This code is intentionally more verbose than necessary, to
+*                 be extremely clear what is going on in the recursion for
+*                 each of the three address resolution functions.
+* 
+*                 Although there is some opportunity to repeat ourselves a
+*                 bit less in this codebase (e.g. with detection of arrays
+*                 versus objects versus direct properties), it can make
+*                 debugging.. challenging.  The minified version of the code
+*                 optimizes out almost anything repeated in here.  So please
+*                 be kind and rewind... meaning please keep the codebase less
+*                 terse and more verbose so humans can comprehend it.
+*                 
+*
+* @class ManyfestObjectAddressGeneration
+*/
+class ManyfestObjectAddressGeneration
+{
+	constructor(pInfoLog, pErrorLog)
+	{
+		// Wire in logging
+		this.logInfo = (typeof(pInfoLog) == 'function') ? pInfoLog : libSimpleLog;
+		this.logError = (typeof(pErrorLog) == 'function') ? pErrorLog : libSimpleLog;
+	}
+
+	// generateAddressses
+	//
+	// This flattens an object into a set of key:value pairs for *EVERY SINGLE
+	// POSSIBLE ADDRESS* in the object.  It can get ... really insane really
+	// quickly.  This is not meant to be used directly to generate schemas, but
+	// instead as a starting point for scripts or UIs.
+	//
+	// This will return a mega set of key:value pairs with all possible schema 
+	// permutations and default values (when not an object) and everything else.
+	generateAddressses (pObject, pBaseAddress, pSchema)
+	{
+		let tmpBaseAddress = (typeof(pBaseAddress) == 'string') ? pBaseAddress : '';
+		let tmpSchema = (typeof(pSchema) == 'object') ? pSchema : {};
+
+		let tmpObjectType = typeof(pObject);
+
+		let tmpSchemaObjectEntry = (
+			{
+				Address: tmpBaseAddress,
+				Hash: tmpBaseAddress,
+				Name: tmpBaseAddress,
+				// This is so scripts and UI controls can force a developer to opt-in.
+				InSchema: false
+			}
+		)
+
+		switch(tmpObjectType)
+		{
+			case 'string':
+				tmpSchemaObjectEntry.DataType = 'String';
+				tmpSchemaObjectEntry.Default = pObject;
+				tmpSchema[tmpBaseAddress] = tmpSchemaObjectEntry;
+				break;
+			case 'number':
+			case 'bigint':
+				tmpSchemaObjectEntry.DataType = 'Number';
+				tmpSchemaObjectEntry.Default = pObject;
+				tmpSchema[tmpBaseAddress] = tmpSchemaObjectEntry;
+				break;
+			case 'undefined':
+				tmpSchemaObjectEntry.DataType = 'Any';
+				tmpSchemaObjectEntry.Default = pObject;
+				tmpSchema[tmpBaseAddress] = tmpSchemaObjectEntry;
+				break;
+			case 'object':
+				if (Array.isArray(pObject))
+				{
+					tmpSchemaObjectEntry.DataType = 'Array';
+					if (tmpBaseAddress != '')
+					{
+						tmpSchema[tmpBaseAddress] = tmpSchemaObjectEntry;
+					}
+	
+					for (let i = 0; i < pObject.length; i++)
+					{
+						this.generateAddressses(pObject[i], `${tmpBaseAddress}[${i}]`, tmpSchema);
+					}
+				}
+				else
+				{
+					tmpSchemaObjectEntry.DataType = 'Object';
+					if (tmpBaseAddress != '')
+					{
+						tmpSchema[tmpBaseAddress] = tmpSchemaObjectEntry;
+						tmpBaseAddress += '.';
+					}
+	
+					let tmpObjectProperties = Object.keys(pObject);
+
+					for (let i = 0; i < tmpObjectProperties.length; i++)
+					{
+						this.generateAddressses(pObject[tmpObjectProperties[i]], `${tmpBaseAddress}${tmpObjectProperties[i]}`, tmpSchema);
+					}			
+				}
+				break;
+			case 'symbol':
+			case 'function':
+				// Symbols and functions neither recurse nor get added to the schema
+				break;
+		}
+
+		return tmpSchema;
+	}
+};
+
+module.exports = ManyfestObjectAddressGeneration;

package/source/Manyfest.js

@@ -3,10 +3,13 @@
 * @author <steven@velozo.com>
 */
 let libSimpleLog = require('./Manyfest-LogToConsole.js');
-let libObjectAddressResolver = require('./Manyfest-ObjectAddressResolver.js');
+
 let libHashTranslation = require('./Manyfest-HashTranslation.js');
+let libObjectAddressResolver = require('./Manyfest-ObjectAddressResolver.js');
+let libObjectAddressGeneration = require('./Manyfest-ObjectAddressGeneration.js');
 let libSchemaManipulation = require('./Manyfest-SchemaManipulation.js');
 
+
 /**
 * Manyfest object address-based descriptions and manipulations.
 *
@@ -54,6 +57,7 @@ class Manyfest
 		}
 
 		this.schemaManipulations = new libSchemaManipulation(this.logInfo, this.logError);
+		this.objectAddressGeneration = new libObjectAddressGeneration(this.logInfo, this.logError);
 
 		this.hashTranslations = new libHashTranslation(this.logInfo, this.logError);
 	}
@@ -256,13 +260,29 @@ class Manyfest
 	// Get the value of an element by its hash
 	getValueByHash (pObject, pHash)
 	{
-		return this.getValueAtAddress(pObject, this.resolveHashAddress(pHash));
+		let tmpValue = this.getValueAtAddress(pObject, this.resolveHashAddress(pHash));
+
+		if (typeof(tmpValue) == 'undefined')
+		{
+			// Try to get a default if it exists
+			tmpValue = this.getDefaultValue(this.getDescriptorByHash(pHash));
+		}
+
+		return tmpValue;
 	}
 
 	// Get the value of an element at an address
 	getValueAtAddress (pObject, pAddress)
 	{
-		return this.objectAddressResolver.getValueAtAddress(pObject, pAddress);
+		let tmpValue = this.objectAddressResolver.getValueAtAddress(pObject, pAddress);
+
+		if (typeof(tmpValue) == 'undefined')
+		{
+			// Try to get a default if it exists
+			tmpValue = this.getDefaultValue(this.getDescriptor(pAddress));
+		}
+
+		return tmpValue;
 	}
 
 	// Set the value of an element by its hash
@@ -304,9 +324,10 @@ class Manyfest
 		for (let i = 0; i < this.elementAddresses.length; i++)
 		{
 			let tmpDescriptor = this.getDescriptor(this.elementAddresses[i]);
+			let tmpValueExists = this.checkAddressExists(pObject, tmpDescriptor.Address);
 			let tmpValue = this.getValueAtAddress(pObject, tmpDescriptor.Address);
 
-			if (typeof(tmpValue) == 'undefined')
+			if ((typeof(tmpValue) == 'undefined') || !tmpValueExists)
 			{
 				// This will technically mean that `Object.Some.Value = undefined` will end up showing as "missing"
 				// TODO: Do we want to do a different message based on if the property exists but is undefined?
@@ -385,6 +406,11 @@ class Manyfest
 	// Returns a default value, or, the default value for the data type (which is overridable with configuration)
 	getDefaultValue(pDescriptor)
 	{
+		if (typeof(pDescriptor) != 'object')
+		{
+			return undefined;
+		}
+
 		if (pDescriptor.hasOwnProperty('Default'))
 		{
 			return pDescriptor.Default;

package/test/Manyfest_Object_Read_tests.js

@@ -57,7 +57,7 @@ suite
 				);
 				test
 				(
-					'Exercise more hash accesss scenarios..',
+					'Return default values when none are supplied.',
 					(fTestComplete)=>
 					{
 						let animalManyfest = new libManyfest(
@@ -79,13 +79,19 @@ suite
 												"Name":"Comfortable Environmental Temperature",
 												"NameShort":"Comf Env Temp",
 												"Hash":"ComfET",
-												"Description":"The most comfortable temperature for this animal to survive in."
+												"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: { 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);
+
+							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);
 
 						fTestComplete();
 					}

package/test/Manyfest_Object_SchemaManipulation_tests.js

@@ -194,6 +194,52 @@ suite
 						Expect(_ClonedManyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Director')).to.equal('General Mills');
 						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Director')).to.equal(undefined);
 	
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Schema definition prototypes should be able to be generated from any JSON object shape.',
+					(fTestComplete)=>
+					{
+						let tmpSchemaDescriptors = (
+							{
+								"a": { "Hash": "a", "Type": "Number" },
+								"b": { "Hash": "b", "Type": "Number" },
+								"TranslationTable":
+								{
+									"a": "CarrotCost",
+									"b": "AppleCost"
+								}
+							});
+						
+						let _Manyfest = new libManyfest();
+						// Now remap the schema (in-place)
+						let tmpSchemaPrototype = _Manyfest.objectAddressGeneration.generateAddressses(tmpSchemaDescriptors);
+
+						// The schema should be fundamentally altered to point these addresses to the old hashes
+						Expect(tmpSchemaPrototype).to.be.an('object');
+
+						Expect(tmpSchemaPrototype['TranslationTable.a'].DataType).to.equal('String');
+
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Make a much bigger schema prototype.',
+					(fTestComplete)=>
+					{						
+						let _Manyfest = new libManyfest();
+						// Now remap the schema (in-place)
+						let tmpSchemaPrototype = _Manyfest.objectAddressGeneration.generateAddressses(_SampleDataArchiveOrgFrankenberry);
+
+						// The schema should be fundamentally altered to point these addresses to the old hashes
+						Expect(tmpSchemaPrototype).to.be.an('object');
+
+						Expect(tmpSchemaPrototype['files_count'].Default).to.equal(17);
+						Expect(tmpSchemaPrototype['files_count'].DataType).to.equal('Number');
+
 						fTestComplete();
 					}
 				);