manyfest 1.0.3 → 1.0.5

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

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

package/README.md

@@ -75,13 +75,15 @@ Scope | The scope of this representation; generally the clustered or parent reco
 Schema | The stateful representation of an object's structural definition.
 Element | A defined element of data in an object.
 Address | The address where that data lies in the object.
+Hash | A unique within this scope string-based key for this element.  Used for easy access of data.
 Descriptor | A description of an element including data such as Name, NameShort, Hash, Description, and other important properties.
 Name | The name of the element.  Meant to be the most succinct human readable name possible.
 NameShort | A shorter name for the element.  Meant to be useful enough to identify the property in log lines, tabular views, graphs and anywhere where we don't always want to see the full name.
 Description | A description for the element.  Very useful when consuming other APIs with their own terse naming standards (or no naming standards)!
-Hash | A unique within this scope string-based key for this element.  Used for easy access of data.
 Required | Set to true if this element is required.
 
+Okay so these are a lot of crazy words.  The important two are *Address* and *Hash*.  Every element in a schema must have an address.  Having a hash just multiplies the usefulness of these addresses.
+
 ## A More Advanced Schema Example
 
 Addresses are meant to be kinda magic.  They describe locations in nested JSON just as well as simple objects.  Further, they can allow us to manipulate and read JSON values at specific addresses.
@@ -205,6 +207,10 @@ console.log(animalManyfest.getValueByHash(favAnimal,'ComfET'));
 
 For any elements that haven't defined a Hash, the Address is used.  This allows code to gracefully fall back.
 
+## Hash Translation Tables
+
+Sometimes we want to reuse the structure of a schema, but look up values by hash using translations.
+
 ## Programmatically Defining a Schema
 
 Sometimes we don't have schemas, and want to define object element structure on the fly.  This can be done programmatically.  As a refresher, here is how we loaded our simplest schema manifest above:

package/package.json

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

package/source/Manyfest-HashTranslation.js

@@ -0,0 +1,118 @@
+/**
+* @license MIT
+* @author <steven@velozo.com>
+*/
+let libSimpleLog = require('./Manyfest-LogToConsole.js');
+
+/**
+* Hash Translation
+*
+* This is a very simple translation table for hashes, which allows the same schema to resolve 
+* differently based on a loaded translation table.
+*
+* This is to prevent the requirement for mutating schemas over and over again when we want to
+* reuse the structure but look up data elements by different addresses.
+*
+* One side-effect of this is that a translation table can "override" the built-in hashes, since
+* this is always used to resolve hashes before any of the functionCallByHash(pHash, ...) perform
+* their lookups by hash.
+*
+* @class ManyfestHashTranslation
+*/
+class ManyfestHashTranslation
+{
+	constructor(pInfoLog, pErrorLog)
+	{
+		// Wire in logging
+		this.logInfo = (typeof(pInfoLog) === 'function') ? pInfoLog : libSimpleLog;
+		this.logError = (typeof(pErrorLog) === 'function') ? pErrorLog : libSimpleLog;
+
+        this.translationTable = {};
+	}
+
+    translationCount()
+    {
+        return Object.keys(this.translationTable).length;
+    }
+
+    addTranslation(pTranslation)
+    {
+        // This adds a translation in the form of:
+        // { "SourceHash": "DestinationHash", "SecondSourceHash":"SecondDestinationHash" }
+        if (typeof(pTranslation) != 'object')
+        {
+            this.logError(`Hash translation addTranslation expected a translation be type object but was passed in ${typeof(pTranslation)}`);
+            return false;
+        }
+
+        let tmpTranslationSources = Object.keys(pTranslation)
+
+        tmpTranslationSources.forEach(
+            (pTranslationSource) =>
+            {
+                if (typeof(pTranslation[pTranslationSource]) != 'string')
+                {
+                    this.logError(`Hash translation addTranslation expected a translation destination hash for [${pTranslationSource}] to be a string but the referrant was a ${typeof(pTranslation[pTranslationSource])}`);
+                }
+                else
+                {
+                    this.translationTable[pTranslationSource] = pTranslation[pTranslationSource];
+                }
+            });
+    }
+
+    removeTranslationHash(pTranslationHash)
+    {
+        if (this.translationTable.hasOwnProperty(pTranslationHash))
+        {
+            delete this.translationTable[pTranslationHash];
+        }
+    }
+
+    // This removes translations.
+    // If passed a string, just removes the single one.
+    // If passed an object, it does all the source keys.
+    removeTranslation(pTranslation)
+    {
+        if (typeof(pTranslation) == 'string')
+        {
+            this.removeTranslationHash(pTranslation);
+            return true;
+        }
+        else if (typeof(pTranslation) == 'object')
+        {
+            let tmpTranslationSources = Object.keys(pTranslation)
+
+            tmpTranslationSources.forEach(
+                (pTranslationSource) =>
+                {
+                    this.removeTranslation(pTranslationSource);
+                });
+            return true;
+        }
+        else
+        {
+            this.logError(`Hash translation removeTranslation expected either a string or an object but the passed-in translation was type ${typeof(pTranslation)}`);
+            return false;
+        }
+    }
+
+    clearTranslations()
+    {
+        this.translationTable = {};
+    }
+
+    translate(pTranslation)
+    {
+        if (this.translationTable.hasOwnProperty(pTranslation))
+        {
+            return this.translationTable[pTranslation];
+        }
+        else
+        {
+            return pTranslation;
+        }
+    }
+}
+
+module.exports = ManyfestHashTranslation;

package/source/Manyfest-ObjectAddressResolver.js

@@ -27,8 +27,8 @@ class ManyfestObjectAddressResolver
 	constructor(pInfoLog, pErrorLog)
 	{
 		// Wire in logging
-		this.logInfo = (typeof(pInfoLog) === 'function') ? pInfoLog : libSimpleLog;
-		this.logError = (typeof(pErrorLog) === 'function') ? pErrorLog : libSimpleLog;
+		this.logInfo = (typeof(pInfoLog) == 'function') ? pInfoLog : libSimpleLog;
+		this.logError = (typeof(pErrorLog) == 'function') ? pErrorLog : libSimpleLog;
 	}
 
 	// When a boxed property is passed in, it should have quotes of some
@@ -67,15 +67,15 @@ class ManyfestObjectAddressResolver
 	{
 		// TODO: Should these throw an error?
 		// Make sure pObject is an object
-		if (!typeof(pObject) === 'object') return false;
+		if (typeof(pObject) != 'object') return false;
 		// Make sure pAddress is a string
-		if (!typeof(pAddress) === 'string') return false;
+		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)
+		if (tmpSeparatorIndex == -1)
 		{
 			// Check if the address refers to a boxed property
 			let tmpBracketStartIndex = pAddress.indexOf('[');
@@ -240,15 +240,15 @@ class ManyfestObjectAddressResolver
 	getValueAtAddress (pObject, pAddress)
 	{
 		// Make sure pObject is an object
-		if (!typeof(pObject) === 'object') return undefined;
+		if (typeof(pObject) != 'object') return undefined;
 		// Make sure pAddress is a string
-		if (!typeof(pAddress) === 'string') return undefined;
+		if (typeof(pAddress) != 'string') return undefined;
 
 		// 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)
+		if (tmpSeparatorIndex == -1)
 		{
 			// Check if the address refers to a boxed property
 			let tmpBracketStartIndex = pAddress.indexOf('[');
@@ -410,13 +410,13 @@ class ManyfestObjectAddressResolver
 	setValueAtAddress (pObject, pAddress, pValue)
 	{
 		// Make sure pObject is an object
-		if (!typeof(pObject) === 'object') return false;
+		if (typeof(pObject) != 'object') return false;
 		// Make sure pAddress is a string
-		if (!typeof(pAddress) === 'string') return false;
+		if (typeof(pAddress) != 'string') return false;
 
 		let tmpSeparatorIndex = pAddress.indexOf('.');
 
-		if (tmpSeparatorIndex === -1)
+		if (tmpSeparatorIndex == -1)
 		{
 			// Check if it's a boxed property
 			let tmpBracketStartIndex = pAddress.indexOf('[');

package/source/Manyfest-SchemaManipulation.js

@@ -0,0 +1,112 @@
+/**
+* @license MIT
+* @author <steven@velozo.com>
+*/
+let libSimpleLog = require('./Manyfest-LogToConsole.js');
+
+/**
+* Schema Manipulation Functions
+*
+* @class ManyfestSchemaManipulation
+*/
+class ManyfestSchemaManipulation
+{
+	constructor(pInfoLog, pErrorLog)
+	{
+		// Wire in logging
+		this.logInfo = (typeof(pInfoLog) === 'function') ? pInfoLog : libSimpleLog;
+		this.logError = (typeof(pErrorLog) === 'function') ? pErrorLog : libSimpleLog;
+	}
+
+    // This translates the default address mappings to something different.
+    //
+    // For instance you can pass in manyfest schema descriptor object:
+    // 	{
+	//	  "Address.Of.a": { "Hash": "a", "Type": "Number" },
+	//	  "Address.Of.b": { "Hash": "b", "Type": "Number" }
+	//  }
+    //
+    //
+    // And then an address mapping (basically a Hash->Address map)
+    //  {
+    //    "a": "New.Address.Of.a",
+    //    "b": "New.Address.Of.b"  
+    //  }
+    //
+    // NOTE: This mutates the schema object permanently, altering the base hash.
+    //       If there is a collision with an existing address, it can lead to overwrites.
+    // TODO: Discuss what should happen on collisions.
+	resolveAddressMappings(pManyfestSchemaDescriptors, pAddressMapping)
+	{
+		if (typeof(pManyfestSchemaDescriptors) != 'object')
+		{
+			this.logError(`Attempted to resolve address mapping but the descriptor was not an object.`);
+			return false;
+		}
+
+		if (typeof(pAddressMapping) != 'object')
+		{
+			// No mappings were passed in
+			return true;
+		}
+
+		// Get the arrays of both the schema definition and the hash mapping
+		let tmpManyfestAddresses = Object.keys(pManyfestSchemaDescriptors);
+		let tmpHashMapping = {};
+		tmpManyfestAddresses.forEach(
+			(pAddress) =>
+			{
+				if (pManyfestSchemaDescriptors[pAddress].hasOwnProperty('Hash'))
+				{
+					tmpHashMapping[pManyfestSchemaDescriptors[pAddress].Hash] = pAddress;
+				}
+			});
+
+		let tmpAddressMappingSet = Object.keys(pAddressMapping);
+
+		tmpAddressMappingSet.forEach(
+			(pInputAddress) =>
+			{
+				let tmpNewDescriptorAddress = pAddressMapping[pInputAddress];
+				let tmpOldDescriptorAddress = false;
+				let tmpDescriptor = false;
+
+				// See if there is a matching descriptor either by Address directly or Hash
+				if (pManyfestSchemaDescriptors.hasOwnProperty(pInputAddress))
+				{
+					tmpOldDescriptorAddress = pInputAddress;
+				}
+				else if (tmpHashMapping.hasOwnProperty(pInputAddress))
+				{
+					tmpOldDescriptorAddress = tmpHashMapping[pInputAddress];
+				}
+
+				// If there was a matching descriptor in the manifest, store it in the temporary descriptor
+				if (tmpOldDescriptorAddress)
+				{
+					tmpDescriptor = pManyfestSchemaDescriptors[tmpOldDescriptorAddress];
+					delete pManyfestSchemaDescriptors[tmpOldDescriptorAddress];
+				}
+				else
+				{
+					// Create a new descriptor!  Map it to the input address.
+					tmpDescriptor = { Hash:pInputAddress };
+				}
+
+				// Now re-add the descriptor to the manyfest schema
+				pManyfestSchemaDescriptors[tmpNewDescriptorAddress] = tmpDescriptor;
+			});
+
+		return true;
+	}
+
+	safeResolveAddressMappings(pManyfestSchemaDescriptors, pAddressMapping)
+	{
+		// This returns the descriptors as a new object, safely remapping without mutating the original schema Descriptors
+		let tmpManyfestSchemaDescriptors = JSON.parse(JSON.stringify(pManyfestSchemaDescriptors));
+		this.resolveAddressMappings(tmpManyfestSchemaDescriptors, pAddressMapping);
+		return tmpManyfestSchemaDescriptors;
+	}
+}
+
+module.exports = ManyfestSchemaManipulation;

package/source/Manyfest.js

@@ -4,6 +4,8 @@
 */
 let libSimpleLog = require('./Manyfest-LogToConsole.js');
 let libObjectAddressResolver = require('./Manyfest-ObjectAddressResolver.js');
+let libHashTranslation = require('./Manyfest-HashTranslation.js');
+let libSchemaManipulation = require('./Manyfest-SchemaManipulation.js');
 
 /**
 * Manyfest object address-based descriptions and manipulations.
@@ -50,6 +52,10 @@ class Manyfest
 		{
 			this.loadManifest(pManifest);
 		}
+
+		this.schemaManipulations = new libSchemaManipulation(this.logInfo, this.logError);
+
+		this.hashTranslations = new libHashTranslation(this.logInfo, this.logError);
 	}
 
 	/*************************************************************************
@@ -153,14 +159,18 @@ class Manyfest
 			this.elementDescriptors[pAddress] = pDescriptor;
 
 			// Always add the address as a hash
-			// TODO: Check if this is a good idea or not.
-			//       Collisions are bound to happen with both representations of the address/hash in here.
 			this.elementHashes[pAddress] = pAddress;
 
 			if (pDescriptor.hasOwnProperty('Hash'))
 			{
+				// TODO: Check if this is a good idea or not..
+				//       Collisions are bound to happen with both representations of the address/hash in here and developers being able to create their own hashes.
 				this.elementHashes[pDescriptor.Hash] = pAddress;
 			}
+			else
+			{
+				pDescriptor.Hash = pAddress;
+			}
 
 			return true;
 		}
@@ -173,15 +183,7 @@ class Manyfest
 
 	getDescriptorByHash(pHash)
 	{
-		if (this.elementHashes.hasOwnProperty(pHash))
-		{
-			return this.getDescriptor(this.elementHashes[pHash]);
-		}
-		else
-		{
-			this.logError(`(${this.scope}) Error in getDescriptorByHash; the Hash ${pHash} doesn't exist in the schema.`);
-			return undefined;
-		}
+		return this.getDescriptor(this.resolveHashAddress(pHash));
 	}
 
 	getDescriptor(pAddress)
@@ -195,15 +197,7 @@ class Manyfest
 	// Check if an element exists by its hash
 	checkAddressExistsByHash (pObject, pHash)
 	{
-		if (this.elementHashes.hasOwnProperty(pHash))
-		{
-			return this.checkAddressExists(pObject, this.elementHashes[pHash]);
-		}
-		else
-		{
-			this.logError(`(${this.scope}) Error in checkAddressExistsByHash; the Hash ${pHash} doesn't exist in the schema.`);
-			return undefined;
-		}
+		return this.checkAddressExists(pObject,this.resolveHashAddress(pHash));
 	}
 
 	// Check if an element exists at an address
@@ -212,19 +206,43 @@ class Manyfest
 		return this.objectAddressResolver.checkAddressExists(pObject, pAddress);
 	}
 
-
-	// Get the value of an element by its hash
-	getValueByHash (pObject, pHash)
+	// Turn a hash into an address, factoring in the translation table.
+	resolveHashAddress(pHash)
 	{
-		if (this.elementHashes.hasOwnProperty(pHash))
+		let tmpAddress = undefined;
+
+		let tmpInElementHashTable = this.elementHashes.hasOwnProperty(pHash);
+		let tmpInTranslationTable = this.hashTranslations.translationTable.hasOwnProperty(pHash);
+
+		// The most straightforward: the hash exists, no translations.
+		if (tmpInElementHashTable && !tmpInTranslationTable)
 		{
-			return this.getValueAtAddress(pObject, this.elementHashes[pHash]);
+			tmpAddress = this.elementHashes[pHash];
 		}
+		// There is a translation from one hash to another, and, the elementHashes contains the pointer end
+		else if (tmpInTranslationTable && this.elementHashes.hasOwnProperty(this.hashTranslations.translate(pHash)))
+		{
+			tmpAddress = this.elementHashes[this.hashTranslations.translate(pHash)];
+		}
+		// Use the level of indirection only in the Translation Table 
+		else if (tmpInTranslationTable)
+		{
+			tmpAddress = this.hashTranslations.translate(pHash);
+		}
+		// Just treat the hash as an address.
+		// TODO: Discuss this ... it is magic but controversial
 		else
 		{
-			this.logError(`(${this.scope}) Error in getValueByHash; the Hash ${pHash} doesn't exist in the schema.`);
-			return undefined;
+			tmpAddress = pHash;
 		}
+
+		return tmpAddress;
+	}
+
+	// Get the value of an element by its hash
+	getValueByHash (pObject, pHash)
+	{
+		return this.getValueAtAddress(pObject, this.resolveHashAddress(pHash));
 	}
 
 	// Get the value of an element at an address
@@ -236,15 +254,7 @@ class Manyfest
 	// Set the value of an element by its hash
 	setValueByHash(pObject, pHash, pValue)
 	{
-		if (this.elementHashes.hasOwnProperty(pHash))
-		{
-			return this.setValueAtAddress(pObject, this.elementHashes[pHash], pValue);
-		}
-		else
-		{
-			this.logError(`(${this.scope}) Error in setValueByHash; the Hash ${pHash} doesn't exist in the schema.  Value ${pValue} will not be written!`);
-			return undefined;
-		}
+		return this.setValueAtAddress(pObject, this.resolveHashAddress(pHash), pValue);
 	}
 
 

package/test/Manyfest_Object_CheckExistence_tests.js

@@ -1,5 +1,5 @@
 /**
-* Unit tests for Meadow
+* Unit tests for Manyfest
 *
 * @license     MIT
 *

package/test/Manyfest_Object_HashTranslation_tests.js

@@ -0,0 +1,182 @@
+/**
+* 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 Hash Translations',
+	function()
+	{
+		setup (()=> {} );
+
+		suite
+		(
+			'Translation Operations',
+			()=>
+			{
+				test
+				(
+					'A simple hash translation.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({ Scope:'Archive.org', Descriptors: {'metadata.creator': {Name:'Creator', Hash:'Creator'}}});
+						// Property not schema, accessed by hash:
+						let tmpCreator = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Creator');
+						Expect(tmpCreator)
+							.to.equal('General Mills');
+						// Create a translation between "Creator" and "Director"
+						_Manyfest.hashTranslations.addTranslation({"Director":"Creator"});
+						// Creator should still work
+						tmpCreator = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Creator');
+						Expect(tmpCreator)
+							.to.equal('General Mills');
+						// Director should also work
+						tmpCreator = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Director');
+						Expect(tmpCreator)
+							.to.equal('General Mills');
+							
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Multiple translations.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({ Scope:'Archive.org', Descriptors: {'metadata.creator': {Name:'Creator', Hash:'Creator'}}});
+						// Property not schema, accessed by hash:
+						let tmpCreator = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Creator');
+						Expect(tmpCreator).to.equal('General Mills');
+						// Create a translation between "Creator" and "Director" as well as "Author"
+						_Manyfest.hashTranslations.addTranslation({"Director":"Creator", "Author":"Creator"});
+						// Creator should still work
+						tmpCreator = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Creator');
+						Expect(tmpCreator).to.equal('General Mills');
+						// Director should also work
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Director')).to.equal('General Mills');
+						// And Author!
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Author')).to.equal('General Mills');
+							
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Remove a translation.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({ Scope:'Archive.org', Descriptors: {'metadata.creator': {Name:'Creator', Hash:'Creator'}}});
+						// Property not schema, accessed by hash:
+						let tmpCreator = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Creator');
+						Expect(tmpCreator).to.equal('General Mills');
+						// Create a translation between "Creator" and "Director" as well as "Author"
+						_Manyfest.hashTranslations.addTranslation({"Director":"Creator", "Author":"Creator"});
+						Expect(tmpCreator).to.equal('General Mills');
+						// Director should also work
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Director')).to.equal('General Mills');
+						// And Author!
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Author')).to.equal('General Mills');
+						// Now remove Director
+						_Manyfest.hashTranslations.removeTranslation('Director');
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Author')).to.equal('General Mills');
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Director')).to.equal(undefined);
+							
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Remove multiple translations.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({ Scope:'Archive.org', Descriptors: {'metadata.creator': {Name:'Creator', Hash:'Creator'}}});
+						// Property not schema, accessed by hash:
+						let tmpCreator = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Creator');
+						Expect(tmpCreator).to.equal('General Mills');
+						// Create a translation between "Creator" and "Director" as well as "Author"
+						_Manyfest.hashTranslations.addTranslation({"Director":"Creator", "Author":"Creator", "Songwriter":"Creator"});
+						Expect(tmpCreator).to.equal('General Mills');
+						// Director should also work
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Director')).to.equal('General Mills');
+						// And Author!
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Author')).to.equal('General Mills');
+						// Now remove Director
+						_Manyfest.hashTranslations.removeTranslation({'Director':true,'Author':'TheseValuesDontMatter'});
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Author')).to.equal(undefined);
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Director')).to.equal(undefined);
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Songwriter')).to.equal('General Mills');
+							
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Remove all translations.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({ Scope:'Archive.org', Descriptors: {'metadata.creator': {Name:'Creator', Hash:'Creator'}}});
+						// Property not schema, accessed by hash:
+						let tmpCreator = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Creator');
+						Expect(tmpCreator).to.equal('General Mills');
+						// Create a translation between "Creator" and "Director" as well as "Author"
+						_Manyfest.hashTranslations.addTranslation({"Director":"Creator", "Author":"Creator", "Songwriter":"Creator"});
+						Expect(tmpCreator).to.equal('General Mills');
+						// Director should also work
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Director')).to.equal('General Mills');
+						// And Author!
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Author')).to.equal('General Mills');
+						// Now remove Director
+						_Manyfest.hashTranslations.clearTranslations();
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Author')).to.equal(undefined);
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Director')).to.equal(undefined);
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Songwriter')).to.equal(undefined);
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Creator')).to.equal('General Mills');
+							
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Translate to a value not in the hashes, falling back to address.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({ Scope:'Archive.org', Descriptors: {'metadata.creator': {Name:'Creator', Hash:'Creator'}}});
+						// Create a translation between "Creator" and "metadata.identifier", which isn't in the manifest in any way 
+						_Manyfest.hashTranslations.addTranslation({"Creator":"metadata.identifier"});
+						// This address is not in the descriptor address list or the hash list
+						Expect(_Manyfest.getValueAtAddress(_SampleDataArchiveOrgFrankenberry, 'metadata.identifier')).to.equal('FrankenberryCountChoculaTevevisionCommercial1971');
+						// But now we've pointed the Creator hash to it!
+						Expect(_Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Creator')).to.equal('FrankenberryCountChoculaTevevisionCommercial1971');
+							
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Add a bogus translation.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({ Scope:'Archive.org', Descriptors: {'metadata.creator': {Name:'Creator', Hash:'Creator'}}});
+
+						Expect(_Manyfest.hashTranslations.addTranslation('THIS SHOULD BE AN OBJECT')).to.equal(false);
+
+						Expect(_Manyfest.hashTranslations.translationCount()).to.equal(0);
+							
+						fTestComplete();
+					}
+				);
+			}
+		);
+	}
+);

package/test/Manyfest_Object_Populate_tests.js

@@ -1,5 +1,5 @@
 /**
-* Unit tests for Meadow
+* Unit tests for Manyfest
 *
 * @license     MIT
 *

package/test/Manyfest_Object_Read_tests.js

@@ -1,5 +1,5 @@
 /**
-* Unit tests for Meadow
+* Unit tests for Manyfest
 *
 * @license     MIT
 *

package/test/Manyfest_Object_SchemaManipulation_tests.js

@@ -0,0 +1,93 @@
+/**
+* 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 Schema Manipulation',
+	function()
+	{
+		setup (()=> {} );
+
+		suite
+		(
+			'Address Mapping Resolution',
+			()=>
+			{
+				test
+				(
+					'We should be able to remap properties in place.',
+					(fTestComplete)=>
+					{
+						let tmpSchemaDescriptors = (
+							{
+								"a": { "Hash": "a", "Type": "Number" },
+								"b": { "Hash": "b", "Type": "Number" }
+							});
+
+						let tmpTranslationTable = (
+							{
+								"a": "CarrotCost",
+								"b": "AppleCost"
+							});
+						
+						Expect(tmpSchemaDescriptors.a.Hash).to.equal('a');
+
+						let _Manyfest = new libManyfest();
+						// Now remap the schema (in-place)
+						_Manyfest.schemaManipulations.resolveAddressMappings(tmpSchemaDescriptors, tmpTranslationTable);
+
+						// The schema should be fundamentally altered to point these addresses to the old hashes
+						Expect(tmpSchemaDescriptors.CarrotCost.Hash).to.equal('a');
+						Expect(tmpSchemaDescriptors.AppleCost.Hash).to.equal('b');
+
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'We should be able to remap properties safely.',
+					(fTestComplete)=>
+					{
+						let tmpSchemaDescriptors = (
+							{
+								"a": { "Hash": "a", "Type": "Number" },
+								"b": { "Hash": "b", "Type": "Number" }
+							});
+
+						let tmpTranslationTable = (
+							{
+								"a": "CarrotCost",
+								"b": "AppleCost"
+							});
+						
+						Expect(tmpSchemaDescriptors.a.Hash).to.equal('a');
+
+						let _Manyfest = new libManyfest();
+						// Now remap the schema (in-place)
+						let tmpNewSchemaDescriptors = _Manyfest.schemaManipulations.safeResolveAddressMappings(tmpSchemaDescriptors, tmpTranslationTable);
+
+						// The schema should be safe
+						Expect(tmpSchemaDescriptors.a.Hash).to.equal('a');
+						// And a new schema should have been created with the alterations
+						Expect(tmpNewSchemaDescriptors.CarrotCost.Hash).to.equal('a');
+						Expect(tmpNewSchemaDescriptors.AppleCost.Hash).to.equal('b');
+
+						fTestComplete();
+					}
+				);
+			}
+		);
+	}
+);

package/test/Manyfest_Object_Validate_tests.js

@@ -1,5 +1,5 @@
 /**
-* Unit tests for Meadow
+* Unit tests for Manyfest
 *
 * @license     MIT
 *

package/test/Manyfest_Object_Write_tests.js

@@ -1,5 +1,5 @@
 /**
-* Unit tests for Meadow
+* Unit tests for Manyfest
 *
 * @license     MIT
 *

package/test/Manyfest_tests.js

@@ -1,5 +1,5 @@
 /**
-* Unit tests for Meadow
+* Unit tests for Manyfest
 *
 * @license     MIT
 *