manyfest 1.0.13 → 1.0.15

package/source/Manyfest-ObjectAddress-SetValue.js

@@ -0,0 +1,217 @@
+/**
+* @license MIT
+* @author <steven@velozo.com>
+*/
+let libSimpleLog = require('./Manyfest-LogToConsole.js');
+let libPrecedent = require('precedent');
+let fCleanWrapCharacters = require('./Manyfest-CleanWrapCharacters.js');
+
+/**
+* Object Address Resolver - SetValue
+*
+* 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 ManyfestObjectAddressSetValue
+*/
+class ManyfestObjectAddressSetValue
+{
+	constructor(pInfoLog, pErrorLog)
+	{
+		// Wire in logging
+		this.logInfo = (typeof(pInfoLog) == 'function') ? pInfoLog : libSimpleLog;
+		this.logError = (typeof(pErrorLog) == 'function') ? pErrorLog : libSimpleLog;
+
+		this.elucidatorSolver = false;
+		this.elucidatorSolverState = {};
+
+		this.cleanWrapCharacters = fCleanWrapCharacters;
+	}
+
+	// Set the value of an element at an address
+	setValueAtAddress (pObject, pAddress, pValue)
+	{
+		// Make sure pObject is an object
+		if (typeof(pObject) != 'object') return false;
+		// Make sure pAddress is a string
+		if (typeof(pAddress) != 'string') return false;
+
+		let tmpSeparatorIndex = pAddress.indexOf('.');
+
+		if (tmpSeparatorIndex == -1)
+		{
+			// Check if it's a boxed property
+			let tmpBracketStartIndex = pAddress.indexOf('[');
+			let tmpBracketStopIndex = pAddress.indexOf(']');
+			// Boxed elements look like this:
+			// 		MyValues[10]
+			// 		MyValues['Name']
+			// 		MyValues["Age"]
+			// 		MyValues[`Cost`]
+			//
+			// When we are passed SomeObject["Name"] this code below recurses as if it were SomeObject.Name
+			// The requirements to detect a boxed element are:
+			//    1) The start bracket is after character 0
+			if ((tmpBracketStartIndex > 0)
+			//    2) The end bracket has something between them
+				&& (tmpBracketStopIndex > tmpBracketStartIndex)
+			//    3) There is data
+				&& (tmpBracketStopIndex - tmpBracketStartIndex > 1))
+			{
+				// The "Name" of the Object contained too the left of the bracket
+				let tmpBoxedPropertyName = pAddress.substring(0, tmpBracketStartIndex).trim();
+
+				// If the subproperty doesn't test as a proper Object, none of the rest of this is possible.
+				// This is a rare case where Arrays testing as Objects is useful
+				if (typeof(pObject[tmpBoxedPropertyName]) !== 'object')
+				{
+					return false;
+				}
+
+				// The "Reference" to the property within it, either an array element or object property
+				let tmpBoxedPropertyReference = pAddress.substring(tmpBracketStartIndex+1, tmpBracketStopIndex).trim();
+				// Attempt to parse the reference as a number, which will be used as an array element
+				let tmpBoxedPropertyNumber = parseInt(tmpBoxedPropertyReference, 10);
+
+				// Guard: If the referrant is a number and the boxed property is not an array, or vice versa, return undefined.
+				//        This seems confusing to me at first read, so explaination:
+				//        Is the Boxed Object an Array?  TRUE
+				//        And is the Reference inside the boxed Object not a number? TRUE
+				//        -->  So when these are in agreement, it's an impossible access state
+				if (Array.isArray(pObject[tmpBoxedPropertyName]) == isNaN(tmpBoxedPropertyNumber))
+				{
+					return false;
+				}
+
+				//    4) If the middle part is *only* a number (no single, double or backtick quotes) it is an array element,
+				//       otherwise we will try to treat it as a dynamic object property.
+				if (isNaN(tmpBoxedPropertyNumber))
+				{
+					// This isn't a number ... let's treat it as a dynamic object property.
+					// We would expect the property to be wrapped in some kind of quotes so strip them
+					tmpBoxedPropertyReference = this.cleanWrapCharacters('"', tmpBoxedPropertyReference);
+					tmpBoxedPropertyReference = this.cleanWrapCharacters('`', tmpBoxedPropertyReference);
+					tmpBoxedPropertyReference = this.cleanWrapCharacters("'", tmpBoxedPropertyReference);
+
+					// Return the value in the property
+					pObject[tmpBoxedPropertyName][tmpBoxedPropertyReference] = pValue;
+					return true;
+				}
+				else
+				{
+					pObject[tmpBoxedPropertyName][tmpBoxedPropertyNumber] = pValue;
+					return true;
+				}
+			}
+			else
+			{
+				// Now is the time in recursion to set the value in the object
+				pObject[pAddress] = pValue;
+				return true;
+			}
+		}
+		else
+		{
+			let tmpSubObjectName = pAddress.substring(0, tmpSeparatorIndex);
+			let tmpNewAddress = pAddress.substring(tmpSeparatorIndex+1);
+
+			// Test if the tmpNewAddress is an array or object
+			// Check if it's a boxed property
+			let tmpBracketStartIndex = tmpSubObjectName.indexOf('[');
+			let tmpBracketStopIndex = tmpSubObjectName.indexOf(']');
+			// Boxed elements look like this:
+			// 		MyValues[42]
+			// 		MyValues['Color']
+			// 		MyValues["Weight"]
+			// 		MyValues[`Diameter`]
+			//
+			// When we are passed SomeObject["Name"] this code below recurses as if it were SomeObject.Name
+			// The requirements to detect a boxed element are:
+			//    1) The start bracket is after character 0
+			if ((tmpBracketStartIndex > 0)
+			//    2) The end bracket has something between them
+				&& (tmpBracketStopIndex > tmpBracketStartIndex)
+			//    3) There is data
+				&& (tmpBracketStopIndex - tmpBracketStartIndex > 1))
+			{
+				let tmpBoxedPropertyName = tmpSubObjectName.substring(0, tmpBracketStartIndex).trim();
+
+				let tmpBoxedPropertyReference = tmpSubObjectName.substring(tmpBracketStartIndex+1, tmpBracketStopIndex).trim();
+
+				let tmpBoxedPropertyNumber = parseInt(tmpBoxedPropertyReference, 10);
+
+				// Guard: If the referrant is a number and the boxed property is not an array, or vice versa, return undefined.
+				//        This seems confusing to me at first read, so explaination:
+				//        Is the Boxed Object an Array?  TRUE
+				//        And is the Reference inside the boxed Object not a number? TRUE
+				//        -->  So when these are in agreement, it's an impossible access state
+				// This could be a failure in the recursion chain because they passed something like this in:
+				//    StudentData.Sections.Algebra.Students[1].Tardy
+				//       BUT
+				//         StudentData.Sections.Algebra.Students is an object, so the [1].Tardy is not possible to access
+				// This could be a failure in the recursion chain because they passed something like this in:
+				//    StudentData.Sections.Algebra.Students["JaneDoe"].Grade
+				//       BUT
+				//         StudentData.Sections.Algebra.Students is an array, so the ["JaneDoe"].Grade is not possible to access
+				// TODO: Should this be an error or something?  Should we keep a log of failures like this?
+				if (Array.isArray(pObject[tmpBoxedPropertyName]) == isNaN(tmpBoxedPropertyNumber))
+				{
+					return false;
+				}
+
+				//This is a bracketed value
+				//    4) If the middle part is *only* a number (no single, double or backtick quotes) it is an array element,
+				//       otherwise we will try to reat it as a dynamic object property.
+				if (isNaN(tmpBoxedPropertyNumber))
+				{
+					// This isn't a number ... let's treat it as a dynanmic object property.
+					tmpBoxedPropertyReference = this.cleanWrapCharacters('"', tmpBoxedPropertyReference);
+					tmpBoxedPropertyReference = this.cleanWrapCharacters('`', tmpBoxedPropertyReference);
+					tmpBoxedPropertyReference = this.cleanWrapCharacters("'", tmpBoxedPropertyReference);
+
+					// Recurse directly into the subobject
+					return this.setValueAtAddress(pObject[tmpBoxedPropertyName][tmpBoxedPropertyReference], tmpNewAddress, pValue);
+				}
+				else
+				{
+					// We parsed a valid number out of the boxed property name, so recurse into the array
+					return this.setValueAtAddress(pObject[tmpBoxedPropertyName][tmpBoxedPropertyNumber], tmpNewAddress, pValue);
+				}
+			}
+
+			// If there is an object property already named for the sub object, but it isn't an object
+			// then the system can't set the value in there.  Error and abort!
+			if (pObject.hasOwnProperty(tmpSubObjectName) && typeof(pObject[tmpSubObjectName]) !== 'object')
+			{
+				if (!pObject.hasOwnProperty('__ERROR'))
+					pObject['__ERROR'] = {};
+				// Put it in an error object so data isn't lost
+				pObject['__ERROR'][pAddress] = pValue;
+				return false;
+			}
+			else if (pObject.hasOwnProperty(tmpSubObjectName))
+			{
+				// If there is already a subobject pass that to the recursive thingy
+				return this.setValueAtAddress(pObject[tmpSubObjectName], tmpNewAddress, pValue);
+			}
+			else
+			{
+				// Create a subobject and then pass that
+				pObject[tmpSubObjectName] = {};
+				return this.setValueAtAddress(pObject[tmpSubObjectName], tmpNewAddress, pValue);
+			}
+		}
+	}
+};
+
+module.exports = ManyfestObjectAddressSetValue;

package/source/Manyfest-ObjectAddressGeneration.js

@@ -7,14 +7,14 @@ let libSimpleLog = require('./Manyfest-LogToConsole.js');
 /**
 * Object Address Generation
 *
-* Automagically generate addresses and properties based on a passed-in object, 
+* 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
@@ -22,7 +22,7 @@ let libSimpleLog = require('./Manyfest-LogToConsole.js');
 *                 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
 */
@@ -42,7 +42,7 @@ class ManyfestObjectAddressGeneration
 	// 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 
+	// 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)
 	{
@@ -93,7 +93,7 @@ class ManyfestObjectAddressGeneration
 					{
 						tmpSchema[tmpBaseAddress] = tmpSchemaObjectEntry;
 					}
-	
+
 					for (let i = 0; i < pObject.length; i++)
 					{
 						this.generateAddressses(pObject[i], `${tmpBaseAddress}[${i}]`, tmpSchema);
@@ -107,13 +107,13 @@ class ManyfestObjectAddressGeneration
 						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':

package/source/Manyfest-SchemaManipulation.js

@@ -30,7 +30,7 @@ class ManyfestSchemaManipulation
     // And then an address mapping (basically a Hash->Address map)
     //  {
     //    "a": "New.Address.Of.a",
-    //    "b": "New.Address.Of.b"  
+    //    "b": "New.Address.Of.b"
     //  }
     //
     // NOTE: This mutates the schema object permanently, altering the base hash.
@@ -123,14 +123,14 @@ class ManyfestSchemaManipulation
 		let tmpDescriptorAddresses = Object.keys(tmpSource);
 
 		tmpDescriptorAddresses.forEach(
-			(pDescriptorAddress) => 
+			(pDescriptorAddress) =>
 			{
 				if (!tmpNewManyfestSchemaDescriptors.hasOwnProperty(pDescriptorAddress))
 				{
 					tmpNewManyfestSchemaDescriptors[pDescriptorAddress] = tmpSource[pDescriptorAddress];
 				}
 			});
-		
+
 		return tmpNewManyfestSchemaDescriptors;
 	}
 }

package/source/Manyfest.js

@@ -7,7 +7,10 @@ let libSimpleLog = require('./Manyfest-LogToConsole.js');
 let libPrecedent = require('precedent');
 
 let libHashTranslation = require('./Manyfest-HashTranslation.js');
-let libObjectAddressResolver = require('./Manyfest-ObjectAddressResolver.js');
+let libObjectAddressCheckAddressExists = require('./Manyfest-ObjectAddress-CheckAddressExists.js');
+let libObjectAddressGetValue = require('./Manyfest-ObjectAddress-GetValue.js');
+let libObjectAddressSetValue = require('./Manyfest-ObjectAddress-SetValue.js');
+let libObjectAddressDeleteValue = require('./Manyfest-ObjectAddress-DeleteValue.js');
 let libObjectAddressGeneration = require('./Manyfest-ObjectAddressGeneration.js');
 let libSchemaManipulation = require('./Manyfest-SchemaManipulation.js');
 
@@ -26,12 +29,15 @@ class Manyfest
 		this.logError = (typeof(pErrorLog) === 'function') ? pErrorLog : libSimpleLog;
 
 		// Create an object address resolver and map in the functions
-		this.objectAddressResolver = new libObjectAddressResolver(this.logInfo, this.logError);
+		this.objectAddressCheckAddressExists = new libObjectAddressCheckAddressExists(this.logInfo, this.logError);
+		this.objectAddressGetValue = new libObjectAddressGetValue(this.logInfo, this.logError);
+		this.objectAddressSetValue = new libObjectAddressSetValue(this.logInfo, this.logError);
+		this.objectAddressDeleteValue = new libObjectAddressDeleteValue(this.logInfo, this.logError);
 
 		this.options = (
 			{
 				strict: false,
-				defaultValues: 
+				defaultValues:
 					{
 						"String": "",
 						"Number": 0,
@@ -83,7 +89,19 @@ class Manyfest
 		this.dataSolverState = {};
 
 		this.libElucidator = undefined;
-		this.objectAddressResolver.elucidatorSolver = false;
+	}
+
+	setElucidatorSolvers(pElucidatorSolver, pElucidatorSolverState)
+	{
+		this.objectAddressCheckAddressExists.elucidatorSolver = pElucidatorSolver;
+		this.objectAddressGetValue.elucidatorSolver = pElucidatorSolver;
+		this.objectAddressSetValue.elucidatorSolver = pElucidatorSolver;
+		this.objectAddressDeleteValue.elucidatorSolver = pElucidatorSolver;
+
+		this.objectAddressCheckAddressExists.elucidatorSolverState = pElucidatorSolverState;
+		this.objectAddressGetValue.elucidatorSolverState = pElucidatorSolverState;
+		this.objectAddressSetValue.elucidatorSolverState = pElucidatorSolverState;
+		this.objectAddressDeleteValue.elucidatorSolverState = pElucidatorSolverState;
 	}
 
 	clone()
@@ -168,7 +186,6 @@ class Manyfest
 			// This is mostly meant for if statements to filter.
 				//   Basically on aggregation, if a filter is set it will set "keep record" to true and let the solver decide differently.
 			this.dataSolvers = new libElucidator(pManifest.Solvers, this.logInfo, this.logError);
-			this.objectAddressResolver.elucidatorSolver = this.dataSolvers;
 
 			// Load the solver state in so each instruction can have internal config
 			// TODO: Should this just be a part of the lower layer pattern?
@@ -177,7 +194,8 @@ class Manyfest
 			{
 				this.dataSolverState[tmpSolverKeys] = pManifest.Solvers[tmpSolverKeys[i]];
 			}
-			this.objectAddressResolver.elucidatorSolverState = this.dataSolverState;
+
+			this.setElucidatorSolvers(this.dataSolvers, this.dataSolverState);
 		}
 	}
 
@@ -236,7 +254,7 @@ class Manyfest
 		{
 			this.logError(`(${this.scope}) Error loading object descriptor for address '${pAddress}' from manifest object.  Expecting an object but property was type ${typeof(pDescriptor)}.`);
 			return false;
-		}	
+		}
 	}
 
 	getDescriptorByHash(pHash)
@@ -272,7 +290,7 @@ class Manyfest
 	// Check if an element exists at an address
 	checkAddressExists (pObject, pAddress)
 	{
-		return this.objectAddressResolver.checkAddressExists(pObject, pAddress);
+		return this.objectAddressCheckAddressExists.checkAddressExists(pObject, pAddress);
 	}
 
 	// Turn a hash into an address, factoring in the translation table.
@@ -293,7 +311,7 @@ class Manyfest
 		{
 			tmpAddress = this.elementHashes[this.hashTranslations.translate(pHash)];
 		}
-		// Use the level of indirection only in the Translation Table 
+		// Use the level of indirection only in the Translation Table
 		else if (tmpInTranslationTable)
 		{
 			tmpAddress = this.hashTranslations.translate(pHash);
@@ -325,7 +343,7 @@ class Manyfest
 	// Get the value of an element at an address
 	getValueAtAddress (pObject, pAddress)
 	{
-		let tmpValue = this.objectAddressResolver.getValueAtAddress(pObject, pAddress);
+		let tmpValue = this.objectAddressGetValue.getValueAtAddress(pObject, pAddress);
 
 		if (typeof(tmpValue) == 'undefined')
 		{
@@ -342,11 +360,22 @@ class Manyfest
 		return this.setValueAtAddress(pObject, this.resolveHashAddress(pHash), pValue);
 	}
 
-
 	// Set the value of an element at an address
 	setValueAtAddress (pObject, pAddress, pValue)
 	{
-		return this.objectAddressResolver.setValueAtAddress(pObject, pAddress, pValue);
+		return this.objectAddressSetValue.setValueAtAddress(pObject, pAddress, pValue);
+	}
+
+	// Delete the value of an element by its hash
+	deleteValueByHash(pObject, pHash, pValue)
+	{
+		return this.deleteValueAtAddress(pObject, this.resolveHashAddress(pHash), pValue);
+	}
+
+	// Delete the value of an element at an address
+	deleteValueAtAddress (pObject, pAddress, pValue)
+	{
+		return this.objectAddressDeleteValue.deleteValueAtAddress(pObject, pAddress, pValue);
 	}
 
 	// Validate the consistency of an object against the schema
@@ -438,7 +467,7 @@ class Manyfest
 						{
 							addValidationError(tmpDescriptor.Address, `has a DataType ${tmpDescriptor.DataType} but is not parsable as a Date by Javascript`);
 						}
-	
+
 					default:
 						// Check if this is a string, in the default case
 						// Note this is only when a DataType is specified and it is an unrecognized data type.

package/test/Manyfest_Object_Delete_tests.js

@@ -0,0 +1,96 @@
+/**
+* Unit tests for Manyfest
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+let libManyfest = require('../source/Manyfest.js');
+
+let _SampleDataArchiveOrgFrankenberry = JSON.parse(JSON.stringify(require('./Data-Archive-org-Frankenberry.json')));
+
+suite
+(
+	'Manyfest Object Property Delete',
+	function()
+	{
+		setup (()=> {} );
+
+		suite
+		(
+			'Basic Delete',
+			()=>
+			{
+				test
+				(
+					'It should be trivial to delete subproperties without a schema.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({ Scope:'Archive.org', Descriptors: {'metadata.creator': {Name:'Creator', Hash:'Creator'}}});
+						// Property not in schema:
+						Expect(_Manyfest.deleteValueAtAddress(_SampleDataArchiveOrgFrankenberry, 'metadata.title'))
+							.to.equal(true);
+						Expect(_SampleDataArchiveOrgFrankenberry.metadata.title)
+							.to.equal(undefined);
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'It should be trivial to delete subproperties with a schema by hash.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({ Scope:'Archive.org', Descriptors: {'metadata.creator': {Name:'Creator', Hash:'Creator'}}});
+						// Property not schema, accessed by hash:
+						let tmpDeleted = _Manyfest.deleteValueByHash(_SampleDataArchiveOrgFrankenberry, 'Creator');
+						Expect(_SampleDataArchiveOrgFrankenberry.metadata.creator)
+							.to.equal(undefined);
+						Expect(tmpDeleted)
+							.to.equal(true);
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Nothing bad should happen deleting a non existant property.',
+					(fTestComplete)=>
+					{
+						let animalManyfest = new libManyfest(
+							{
+								"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.deleteValueAtAddress({MedicalStats: { Temps: { MinET:200 }},Name:'Froggy'}, 'MedicalStats.Temps.HighETBUTIDONTEXISTDOI'))
+								.to.equal(true);
+
+						fTestComplete();
+					}
+				);			
+			}
+		);
+	}
+);