manyfest 1.0.13 → 1.0.15

package/.config/configstore/update-notifier-npm.json

@@ -1,4 +1,4 @@
 {
 	"optOut": false,
-	"lastUpdateCheck": 1666359250724
+	"lastUpdateCheck": 1668357514653
 }

package/README.md

@@ -581,4 +581,6 @@ let _Schema = new libManyfest(schemaArchiveOrg);
 
 console.log(`The URL for "${_Schema.getValueByHash(dataArchiveOrg,'Title')}" is: ${_Schema.getValueByHash(dataArchiveOrg,'Server')}${_Schema.getValueByHash(dataArchiveOrg,'Path')}`);
 ```
+# Architectural TODO:
 
+Change the complex address resolution functions to leverage a single resolver that returns both `container` and `entry`.

package/package.json

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

package/source/Manyfest-CleanWrapCharacters.js

@@ -0,0 +1,28 @@
+// When a boxed property is passed in, it should have quotes of some
+// kind around it.
+//
+// For instance:
+// 		MyValues['Name']
+// 		MyValues["Age"]
+// 		MyValues[`Cost`]
+//
+// This function removes the wrapping quotes.
+//
+// Please note it *DOES NOT PARSE* template literals, so backticks just
+// end up doing the same thing as other quote types.
+//
+// TODO: Should template literals be processed?  If so what state do they have access to?  That should happen here if so.
+// TODO: Make a simple class include library with these
+let cleanWrapCharacters = (pCharacter, pString) =>
+{
+	if (pString.startsWith(pCharacter) && pString.endsWith(pCharacter))
+	{
+		return pString.substring(1, pString.length - 1);
+	}
+	else
+	{
+		return pString;
+	}
+};
+
+module.exports = cleanWrapCharacters;

package/source/Manyfest-ObjectAddress-CheckAddressExists.js

@@ -0,0 +1,217 @@
+/**
+* @license MIT
+* @author <steven@velozo.com>
+*/
+let libSimpleLog = require('./Manyfest-LogToConsole.js');
+
+/**
+* Object Address Resolver
+*
+* 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 ManyfestObjectAddressResolverCheckAddressExists
+*/
+class ManyfestObjectAddressResolverCheckAddressExists
+{
+	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 = {};
+	}
+
+	// Check if an address exists.
+	//
+	// This is necessary because the getValueAtAddress function is ambiguous on
+	// whether the element/property is actually there or not (it returns
+	// undefined whether the property exists or not).  This function checks for
+	// existance and returns true or false dependent.
+	checkAddressExists (pObject, pAddress)
+	{
+		// TODO: Should these throw an error?
+		// Make sure pObject is an object
+		if (typeof(pObject) != 'object') return false;
+		// Make sure pAddress is a string
+		if (typeof(pAddress) != 'string') return false;
+
+		// TODO: Make this work for things like SomeRootObject.Metadata["Some.People.Use.Bad.Object.Property.Names"]
+		let tmpSeparatorIndex = pAddress.indexOf('.');
+
+		// This is the terminal address string (no more dots so the RECUSION ENDS IN HERE somehow)
+		if (tmpSeparatorIndex == -1)
+		{
+			// Check if the address refers to 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);
+
+					// Check if the property exists.
+					return pObject[tmpBoxedPropertyName].hasOwnProperty(tmpBoxedPropertyReference);
+				}
+				else
+				{
+					// Use the new in operator to see if the element is in the array
+					return (tmpBoxedPropertyNumber in pObject[tmpBoxedPropertyName]);
+				}
+			}
+			else
+			{
+				// Check if the property exists
+				return pObject.hasOwnProperty(pAddress);
+			}
+		}
+		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))
+				{
+					// Because this is an impossible address, the property doesn't exist
+					// TODO: Should we throw an error in this condition?
+					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.checkAddressExists(pObject[tmpBoxedPropertyName][tmpBoxedPropertyReference], tmpNewAddress);
+				}
+				else
+				{
+					// We parsed a valid number out of the boxed property name, so recurse into the array
+					return this.checkAddressExists(pObject[tmpBoxedPropertyName][tmpBoxedPropertyNumber], tmpNewAddress);
+				}
+			}
+
+			// 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')
+			{
+				return false;
+			}
+			else if (pObject.hasOwnProperty(tmpSubObjectName))
+			{
+				// If there is already a subobject pass that to the recursive thingy
+				return this.checkAddressExists(pObject[tmpSubObjectName], tmpNewAddress);
+			}
+			else
+			{
+				// Create a subobject and then pass that
+				pObject[tmpSubObjectName] = {};
+				return this.checkAddressExists(pObject[tmpSubObjectName], tmpNewAddress);
+			}
+		}
+	}
+};
+
+module.exports = ManyfestObjectAddressResolverCheckAddressExists;