manyfest 1.0.6 → 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/.config/configstore/update-notifier-npm.json

@@ -1,4 +1,4 @@
 {
 	"optOut": false,
-	"lastUpdateCheck": 1665932798321
+	"lastUpdateCheck": 1666021392557
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "manyfest",
-  "version": "1.0.6",
+  "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-ObjectAddressResolver.js

@@ -93,7 +93,7 @@ class ManyfestObjectAddressResolver
 			//    2) The end bracket has something between them
 				&& (tmpBracketStopIndex > tmpBracketStartIndex) 
 			//    3) There is data 
-				&& (tmpBracketStopIndex - tmpBracketStartIndex > 0))
+				&& (tmpBracketStopIndex - tmpBracketStartIndex > 1))
 			{
 				// The "Name" of the Object contained too the left of the bracket
 				let tmpBoxedPropertyName = pAddress.substring(0, tmpBracketStartIndex).trim();
@@ -167,7 +167,7 @@ class ManyfestObjectAddressResolver
 			//    2) The end bracket has something between them
 				&& (tmpBracketStopIndex > tmpBracketStartIndex) 
 			//    3) There is data 
-				&& (tmpBracketStopIndex - tmpBracketStartIndex > 0))
+				&& (tmpBracketStopIndex - tmpBracketStartIndex > 1))
 			{
 				let tmpBoxedPropertyName = tmpSubObjectName.substring(0, tmpBracketStartIndex).trim();
 
@@ -237,12 +237,17 @@ class ManyfestObjectAddressResolver
 	}
 
 	// Get the value of an element at an address
-	getValueAtAddress (pObject, pAddress)
+	getValueAtAddress (pObject, pAddress, pParentAddress)
 	{
 		// Make sure pObject is an object
 		if (typeof(pObject) != 'object') return undefined;
 		// Make sure pAddress is a string
 		if (typeof(pAddress) != 'string') return undefined;
+		let tmpParentAddress = "";
+		if (typeof(pParentAddress) == 'string')
+		{
+			tmpParentAddress = pParentAddress;
+		}
 
 		// TODO: Make this work for things like SomeRootObject.Metadata["Some.People.Use.Bad.Object.Property.Names"]
 		let tmpSeparatorIndex = pAddress.indexOf('.');
@@ -253,6 +258,11 @@ class ManyfestObjectAddressResolver
 			// Check if the address refers to a boxed property
 			let tmpBracketStartIndex = pAddress.indexOf('[');
 			let tmpBracketStopIndex = pAddress.indexOf(']');
+
+			// Check for the Object Set Type marker.
+			// Note this will not work with a bracket in the same address box set
+			let tmpObjectTypeMarkerIndex = pAddress.indexOf('{}');
+
 			// Boxed elements look like this:
 			// 		MyValues[10]
 			// 		MyValues['Name']
@@ -266,7 +276,7 @@ class ManyfestObjectAddressResolver
 			//    2) The end bracket has something between them
 				&& (tmpBracketStopIndex > tmpBracketStartIndex) 
 			//    3) There is data 
-				&& (tmpBracketStopIndex - tmpBracketStartIndex > 0))
+				&& (tmpBracketStopIndex - tmpBracketStartIndex > 1))
 			{
 				// The "Name" of the Object contained too the left of the bracket
 				let tmpBoxedPropertyName = pAddress.substring(0, tmpBracketStartIndex).trim();
@@ -311,6 +321,37 @@ class ManyfestObjectAddressResolver
 					return pObject[tmpBoxedPropertyName][tmpBoxedPropertyNumber];
 				}
 			}
+			// The requirements to detect a boxed set element are:
+			//    1) The start bracket is after character 0
+			else if ((tmpBracketStartIndex > 0) 
+			//    2) The end bracket is after the start bracket
+				&& (tmpBracketStopIndex > tmpBracketStartIndex) 
+			//    3) There is nothing in the brackets
+				&& (tmpBracketStopIndex - tmpBracketStartIndex == 1))
+			{
+				let tmpBoxedPropertyName = pAddress.substring(0, tmpBracketStartIndex).trim();
+
+				if (!Array.isArray(pObject[tmpBoxedPropertyName]))
+				{
+					// We asked for a set from an array but it isnt' an array.
+					return false;
+				}
+
+				return pObject[tmpBoxedPropertyName];
+			}
+			// The object has been flagged as an object set, so treat it as such
+			else if (tmpObjectTypeMarkerIndex > 0)
+			{
+				let tmpObjectPropertyName = pAddress.substring(0, tmpObjectTypeMarkerIndex).trim();
+
+				if (typeof(pObject[tmpObjectPropertyName]) != 'object')
+				{
+					// We asked for a set from an array but it isnt' an array.
+					return false;
+				}
+
+				return pObject[tmpObjectPropertyName];
+			}
 			else
 			{
 				// Now is the point in recursion to return the value in the address
@@ -322,6 +363,7 @@ class ManyfestObjectAddressResolver
 			let tmpSubObjectName = pAddress.substring(0, tmpSeparatorIndex);
 			let tmpNewAddress = pAddress.substring(tmpSeparatorIndex+1);
 
+			// BOXED ELEMENTS
 			// Test if the tmpNewAddress is an array or object
 			// Check if it's a boxed property
 			let tmpBracketStartIndex = tmpSubObjectName.indexOf('[');
@@ -339,7 +381,7 @@ class ManyfestObjectAddressResolver
 			//    2) The end bracket has something between them
 				&& (tmpBracketStopIndex > tmpBracketStartIndex) 
 			//    3) There is data 
-				&& (tmpBracketStopIndex - tmpBracketStartIndex > 0))
+				&& (tmpBracketStopIndex - tmpBracketStartIndex > 1))
 			{
 				let tmpBoxedPropertyName = tmpSubObjectName.substring(0, tmpBracketStartIndex).trim();
 
@@ -376,15 +418,80 @@ class ManyfestObjectAddressResolver
 					tmpBoxedPropertyReference = this.cleanWrapCharacters('`', tmpBoxedPropertyReference);
 					tmpBoxedPropertyReference = this.cleanWrapCharacters("'", tmpBoxedPropertyReference);
 
+					// Continue to manage the parent address for recursion
+					tmpParentAddress = `${tmpParentAddress}${(tmpParentAddress.length > 0) ? '.' : ''}${tmpSubObjectName}`;
 					// Recurse directly into the subobject
-					return this.getValueAtAddress(pObject[tmpBoxedPropertyName][tmpBoxedPropertyReference], tmpNewAddress);
+					return this.getValueAtAddress(pObject[tmpBoxedPropertyName][tmpBoxedPropertyReference], tmpNewAddress, tmpParentAddress);
 				}
 				else
 				{
+					// Continue to manage the parent address for recursion
+					tmpParentAddress = `${tmpParentAddress}${(tmpParentAddress.length > 0) ? '.' : ''}${tmpSubObjectName}`;
 					// We parsed a valid number out of the boxed property name, so recurse into the array
-					return this.getValueAtAddress(pObject[tmpBoxedPropertyName][tmpBoxedPropertyNumber], tmpNewAddress);
+					return this.getValueAtAddress(pObject[tmpBoxedPropertyName][tmpBoxedPropertyNumber], tmpNewAddress, tmpParentAddress);
 				}
 			}
+			// The requirements to detect a boxed set element are:
+			//    1) The start bracket is after character 0
+			else if ((tmpBracketStartIndex > 0) 
+			//    2) The end bracket is after the start bracket
+				&& (tmpBracketStopIndex > tmpBracketStartIndex) 
+			//    3) There is nothing in the brackets
+				&& (tmpBracketStopIndex - tmpBracketStartIndex == 1))
+			{
+				let tmpBoxedPropertyName = pAddress.substring(0, tmpBracketStartIndex).trim();
+
+				if (!Array.isArray(pObject[tmpBoxedPropertyName]))
+				{
+					// We asked for a set from an array but it isnt' an array.
+					return false;
+				}
+
+				// We need to enumerate the array and grab the addresses from there.
+				let tmpArrayProperty = pObject[tmpBoxedPropertyName];
+				// Managing the parent address is a bit more complex here -- the box will be added for each element.
+				tmpParentAddress = `${tmpParentAddress}${(tmpParentAddress.length > 0) ? '.' : ''}${tmpBoxedPropertyName}`;
+				// The container object is where we have the "Address":SOMEVALUE pairs
+				let tmpContainerObject = {};
+				for (let i = 0; i < tmpArrayProperty.length; i++)
+				{
+					let tmpPropertyParentAddress = `${tmpParentAddress}[${i}]`;
+					let tmpValue = this.getValueAtAddress(pObject[tmpBoxedPropertyName][i], tmpNewAddress, tmpPropertyParentAddress);;
+					tmpContainerObject[`${tmpPropertyParentAddress}.${tmpNewAddress}`] = tmpValue;
+				}
+
+				return tmpContainerObject;
+			}
+
+			// OBJECT SET
+			// Note this will not work with a bracket in the same address box set
+			let tmpObjectTypeMarkerIndex = pAddress.indexOf('{}');
+			if (tmpObjectTypeMarkerIndex > 0)
+			{
+				let tmpObjectPropertyName = pAddress.substring(0, tmpObjectTypeMarkerIndex).trim();
+
+				if (typeof(pObject[tmpObjectPropertyName]) != 'object')
+				{
+					// We asked for a set from an array but it isnt' an array.
+					return false;
+				}
+
+				// We need to enumerate the Object and grab the addresses from there.
+				let tmpObjectProperty = pObject[tmpObjectPropertyName];
+				let tmpObjectPropertyKeys = Object.keys(tmpObjectProperty);
+				// Managing the parent address is a bit more complex here -- the box will be added for each element.
+				tmpParentAddress = `${tmpParentAddress}${(tmpParentAddress.length > 0) ? '.' : ''}${tmpObjectPropertyName}`;
+				// The container object is where we have the "Address":SOMEVALUE pairs
+				let tmpContainerObject = {};
+				for (let i = 0; i < tmpObjectPropertyKeys.length; i++)
+				{
+					let tmpPropertyParentAddress = `${tmpParentAddress}.${tmpObjectPropertyKeys[i]}`;
+					let tmpValue = this.getValueAtAddress(pObject[tmpObjectPropertyName][tmpObjectPropertyKeys[i]], tmpNewAddress, tmpPropertyParentAddress);;
+					tmpContainerObject[`${tmpPropertyParentAddress}.${tmpNewAddress}`] = tmpValue;
+				}
+
+				return tmpContainerObject;
+			}
 
 			// 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!
@@ -395,13 +502,17 @@ class ManyfestObjectAddressResolver
 			else if (pObject.hasOwnProperty(tmpSubObjectName))
 			{
 				// If there is already a subobject pass that to the recursive thingy
-				return this.getValueAtAddress(pObject[tmpSubObjectName], tmpNewAddress);
+				// Continue to manage the parent address for recursion
+				tmpParentAddress = `${tmpParentAddress}${(tmpParentAddress.length > 0) ? '.' : ''}${tmpSubObjectName}`;
+				return this.getValueAtAddress(pObject[tmpSubObjectName], tmpNewAddress, tmpParentAddress);
 			}
 			else
 			{
 				// Create a subobject and then pass that
+				// Continue to manage the parent address for recursion
+				tmpParentAddress = `${tmpParentAddress}${(tmpParentAddress.length > 0) ? '.' : ''}${tmpSubObjectName}`;
 				pObject[tmpSubObjectName] = {};
-				return this.getValueAtAddress(pObject[tmpSubObjectName], tmpNewAddress);
+				return this.getValueAtAddress(pObject[tmpSubObjectName], tmpNewAddress, tmpParentAddress);
 			}
 		}
 	}
@@ -434,7 +545,7 @@ class ManyfestObjectAddressResolver
 			//    2) The end bracket has something between them
 				&& (tmpBracketStopIndex > tmpBracketStartIndex) 
 			//    3) There is data 
-				&& (tmpBracketStopIndex - tmpBracketStartIndex > 0))
+				&& (tmpBracketStopIndex - tmpBracketStartIndex > 1))
 			{
 				// The "Name" of the Object contained too the left of the bracket
 				let tmpBoxedPropertyName = pAddress.substring(0, tmpBracketStartIndex).trim();
@@ -510,7 +621,7 @@ class ManyfestObjectAddressResolver
 			//    2) The end bracket has something between them
 				&& (tmpBracketStopIndex > tmpBracketStartIndex) 
 			//    3) There is data 
-				&& (tmpBracketStopIndex - tmpBracketStartIndex > 0))
+				&& (tmpBracketStopIndex - tmpBracketStartIndex > 1))
 			{
 				let tmpBoxedPropertyName = tmpSubObjectName.substring(0, tmpBracketStartIndex).trim();
 

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_ReadSets_tests.js

@@ -0,0 +1,229 @@
+/**
+* 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 = require('./Data-Archive-org-Frankenberry.json');
+
+suite
+(
+	'Manyfest Object Read of Sets',
+	function()
+	{
+		setup (()=> {} );
+
+		suite
+		(
+			'Basic Array Set Reads',
+			()=>
+			{
+				test
+				(
+					'We should be able to access sets of properties from arrays without schema.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest(
+							{
+								Scope:'Archive.org',
+								Descriptors:
+									{
+										'files[]': {Name:'Files', Hash:'FileSet'},
+										'files[].size': {Name:'FileSizes', Hash:'FileSizes'},
+										'metadata.creator': {Name:'Creator', Hash:'Creator'}
+									}
+							});
+						let tmpFileSet = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'FileSet');
+						Expect(Array.isArray(tmpFileSet)).to.equal(true);
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'We should be able to access arrays with or without boxes on the address.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest(
+							{
+								Scope:'Archive.org',
+								Descriptors:
+									{
+										'files[]': {Name:'Files', Hash:'FileSet'},
+										'files[].size': {Name:'FileSizes', Hash:'FileSizes'},
+										'metadata.creator': {Name:'Creator', Hash:'Creator'}
+									}
+							});
+						let tmpFileSet = _Manyfest.getValueAtAddress(_SampleDataArchiveOrgFrankenberry, 'files[]');
+						Expect(Array.isArray(tmpFileSet)).to.equal(true);
+						// There are 17 versions of this damn commercial....
+						Expect(tmpFileSet.length).to.equal(17);
+						let tmpFileSetUnboxed = _Manyfest.getValueAtAddress(_SampleDataArchiveOrgFrankenberry, 'files');
+						Expect(Array.isArray(tmpFileSetUnboxed)).to.equal(true);
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'We should be able to access arrays with a hash.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest(
+							{
+								Scope:'Archive.org',
+								Descriptors:
+									{
+										'files[]': {Name:'Files', Hash:'FileSet'},
+										'files[].size': {Name:'FileSizes', Hash:'FileSizes'},
+										'metadata.creator': {Name:'Creator', Hash:'Creator'}
+									}
+							});
+						let tmpFileSet = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'FileSet');
+						Expect(Array.isArray(tmpFileSet)).to.equal(true);
+						// There are 17 versions of this damn commercial....
+						Expect(tmpFileSet.length).to.equal(17);
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Attempting to access non-array properties as arrays should return false.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest(
+							{
+								Scope:'Archive.org',
+								Descriptors:
+									{
+										'files[]': {Name:'Files', Hash:'FileSet'},
+										'files[].size': {Name:'FileSizes', Hash:'FileSizes'},
+										'metadata.creator': {Name:'Creator', Hash:'Creator'}
+									}
+							});
+						let tmpFileSet = _Manyfest.getValueAtAddress(_SampleDataArchiveOrgFrankenberry, 'metadata.creator[]');
+						Expect(tmpFileSet).to.equal(false);
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Sub-objects in arrays can be parsed and the values will be pulled in magically.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest(
+							{
+								Scope:'Archive.org',
+								Descriptors:
+									{
+										'files[]': {Name:'Files', Hash:'FileSet'},
+										'files[].size': {Name:'FileSizes', Hash:'FileSizes'},
+										'metadata.creator': {Name:'Creator', Hash:'Creator'}
+									}
+							});
+						let tmpFileSet = _Manyfest.getValueAtAddress(_SampleDataArchiveOrgFrankenberry, 'files[].size');
+						Expect(tmpFileSet).to.be.an('object');
+						Expect(tmpFileSet['files[13].size']).to.equal('31625216');
+						fTestComplete();
+					}
+				);
+			}
+		);
+		suite
+		(
+			'Basic Object Set Reads',
+			()=>
+			{
+				test
+				(
+					'We should be able to access sets of properties from objects with schema.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest(
+							{
+								Scope:'Archive.org',
+								Descriptors:
+									{
+										'files[]': {Name:'Files', Hash:'FileSet'},
+										'files[].size': {Name:'FileSizes', Hash:'FileSizes'},
+										'metadata.creator': {Name:'Creator', Hash:'Creator'},
+										'metadata{}': {Name:'Metadata', Hash:'Metadata'}
+									}
+							});
+						let tmpMetadata = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Metadata');
+						Expect(tmpMetadata).to.be.an('object');
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'We should be able to get declared objects without schema.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest(
+							{
+								Scope:'RandomObject',
+								Descriptors:{}
+							});
+						let tmpData = (
+							{
+								Name: "Menu",
+								Ingredients: {
+									"GUID-001": { cost:100, Name:'Carrot' },
+									"GUID-002": { cost:102, Name:'Pea' },
+									"GUID-003": { cost:13, Name:'Potato' },
+									"GUID-004": { cost:1, Name:'Apple' },
+									"GUID-005": { cost:190, Name:'Wine' },
+									"GUID-006": { cost:2500, Name:'Steak' },
+									"GUID-007": { cost:"44", Name:'Gristle' },
+									"GUID-008": { cost:2, Name:'Cherry' },
+									"GUID-009": { cost:14, Name:'Orange' },
+									"GUID-010": { cost:1, Name:'Dandelion' },
+								}
+							});
+						let tmpMetadata = _Manyfest.getValueAtAddress(tmpData, 'Ingredients{}');
+						Expect(tmpMetadata).to.be.an('object');
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'We should be able to declared object subobjects without schema.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest(
+							{
+								Scope:'RandomObject',
+								Descriptors:{}
+							});
+						let tmpData = (
+							{
+								Name: "Menu",
+								Ingredients: {
+									"GUID-001": { cost:100, Name:'Carrot' },
+									"GUID-002": { cost:102, Name:'Pea' },
+									"GUID-003": { cost:13, Name:'Potato' },
+									"GUID-004": { cost:1, Name:'Apple' },
+									"GUID-005": { cost:190, Name:'Wine' },
+									"GUID-006": { cost:2500, Name:'Steak' },
+									"GUID-007": { cost:"44", Name:'Gristle' },
+									"GUID-008": { cost:2, Name:'Cherry' },
+									"GUID-009": { cost:14, Name:'Orange' },
+									"GUID-010": { cost:1, Name:'Dandelion' },
+								}
+							});
+						let tmpMetadata = _Manyfest.getValueAtAddress(tmpData, 'Ingredients{}.cost');
+						Expect(tmpMetadata).to.be.an('object');
+						Expect(tmpMetadata['Ingredients.GUID-003.cost']).to.equal(13);
+						fTestComplete();
+					}
+				);
+			}
+		);
+	}
+);

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();
 					}
 				);