manyfest 1.0.46 → 1.0.48

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "manyfest",
-    "version": "1.0.46",
+    "version": "1.0.48",
     "description": "JSON Object Manifest for Data Description and Parsing",
     "main": "source/Manyfest.js",
     "scripts": {
@@ -46,7 +46,7 @@
         ]
     },
     "dependencies": {
-        "fable-serviceproviderbase": "^3.0.17"
+        "fable-serviceproviderbase": "^3.0.19"
     },
     "devDependencies": {
         "quackage": "^1.0.51",

package/source/Manyfest.js

@@ -354,6 +354,32 @@ class Manyfest extends libFableServiceProviderBase
 		return this.objectAddressCheckAddressExists.checkAddressExists(pObject, pAddress);
 	}
 
+	/**
+	 * Check what role a string plays in this manifest -- whether it is a Hash, an Address, both or neither.
+	 *
+	 * @param {string} pString - The string to check.
+	 *
+	 * @return {{ IsHash: boolean, IsAddress: boolean, ResolvedAddress: string|undefined }} The role of the string.
+	 */
+	checkStringRole(pString)
+	{
+		if (typeof(pString) !== 'string' || pString.length === 0)
+		{
+			return { IsHash: false, IsAddress: false, ResolvedAddress: undefined };
+		}
+
+		let tmpIsAddress = (pString in this.elementDescriptors);
+		let tmpIsHash = (pString in this.elementHashes);
+		let tmpResolvedAddress = tmpIsHash ? this.elementHashes[pString] : undefined;
+
+		return (
+			{
+				IsHash: tmpIsHash,
+				IsAddress: tmpIsAddress,
+				ResolvedAddress: tmpResolvedAddress
+			});
+	}
+
 	// Turn a hash into an address, factoring in the translation table.
 	resolveHashAddress(pHash)
 	{

package/test/Manyfest_CheckStringRole_tests.js

@@ -0,0 +1,191 @@
+/**
+* Unit tests for Manyfest checkStringRole
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+let libManyfest = require('../source/Manyfest.js');
+
+suite
+(
+	'Manyfest checkStringRole',
+	function()
+	{
+		setup (() => {} );
+
+		suite
+		(
+			'checkStringRole',
+			() =>
+			{
+				test
+				(
+					'Should return IsHash:false, IsAddress:false for an empty string.',
+					(fTestComplete) =>
+					{
+						let _Manyfest = new libManyfest(
+							{
+								Scope: 'Test',
+								Descriptors:
+								{
+									'Name': { Hash: 'PersonName', DataType: 'String' }
+								}
+							});
+						let tmpResult = _Manyfest.checkStringRole('');
+						Expect(tmpResult.IsHash).to.equal(false);
+						Expect(tmpResult.IsAddress).to.equal(false);
+						Expect(tmpResult.ResolvedAddress).to.equal(undefined);
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Should return IsHash:false, IsAddress:false for a non-string.',
+					(fTestComplete) =>
+					{
+						let _Manyfest = new libManyfest(
+							{
+								Scope: 'Test',
+								Descriptors:
+								{
+									'Name': { Hash: 'PersonName', DataType: 'String' }
+								}
+							});
+						let tmpResult = _Manyfest.checkStringRole(42);
+						Expect(tmpResult.IsHash).to.equal(false);
+						Expect(tmpResult.IsAddress).to.equal(false);
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Should return IsHash:false, IsAddress:false for an unknown string.',
+					(fTestComplete) =>
+					{
+						let _Manyfest = new libManyfest(
+							{
+								Scope: 'Test',
+								Descriptors:
+								{
+									'Name': { Hash: 'PersonName', DataType: 'String' }
+								}
+							});
+						let tmpResult = _Manyfest.checkStringRole('SomethingUnknown');
+						Expect(tmpResult.IsHash).to.equal(false);
+						Expect(tmpResult.IsAddress).to.equal(false);
+						Expect(tmpResult.ResolvedAddress).to.equal(undefined);
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Should identify a string that is only a Hash (not an Address).',
+					(fTestComplete) =>
+					{
+						let _Manyfest = new libManyfest(
+							{
+								Scope: 'Test',
+								Descriptors:
+								{
+									'Full.Name.Path': { Hash: 'PersonName', DataType: 'String' }
+								}
+							});
+						let tmpResult = _Manyfest.checkStringRole('PersonName');
+						Expect(tmpResult.IsHash).to.equal(true);
+						Expect(tmpResult.IsAddress).to.equal(false);
+						Expect(tmpResult.ResolvedAddress).to.equal('Full.Name.Path');
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Should identify a string that is only an Address (not a custom Hash).',
+					(fTestComplete) =>
+					{
+						let _Manyfest = new libManyfest(
+							{
+								Scope: 'Test',
+								Descriptors:
+								{
+									'Full.Name.Path': { Hash: 'PersonName', DataType: 'String' }
+								}
+							});
+						// The address is always added as a hash too (mapping to itself), so it's both
+						let tmpResult = _Manyfest.checkStringRole('Full.Name.Path');
+						Expect(tmpResult.IsHash).to.equal(true);
+						Expect(tmpResult.IsAddress).to.equal(true);
+						Expect(tmpResult.ResolvedAddress).to.equal('Full.Name.Path');
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Should identify a string that is both Hash and Address (same string).',
+					(fTestComplete) =>
+					{
+						// When Hash is not specified, it defaults to the address
+						let _Manyfest = new libManyfest(
+							{
+								Scope: 'Test',
+								Descriptors:
+								{
+									'ValueArray': { DataType: 'Array' }
+								}
+							});
+						let tmpResult = _Manyfest.checkStringRole('ValueArray');
+						Expect(tmpResult.IsHash).to.equal(true);
+						Expect(tmpResult.IsAddress).to.equal(true);
+						Expect(tmpResult.ResolvedAddress).to.equal('ValueArray');
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Should handle multiple descriptors with distinct hashes and addresses.',
+					(fTestComplete) =>
+					{
+						let _Manyfest = new libManyfest(
+							{
+								Scope: 'Test',
+								Descriptors:
+								{
+									'DataTableAddress': { Hash: 'DataTable', DataType: 'Array' },
+									'DataTableAddress[].ValueAddress': { Hash: 'ValueArray', DataType: 'Array' },
+									'AggregateValueAddress': { Hash: 'AggregateValue', DataType: 'PreciseNumber' }
+								}
+							});
+						// DataTable is a hash only
+						let tmpDataTable = _Manyfest.checkStringRole('DataTable');
+						Expect(tmpDataTable.IsHash).to.equal(true);
+						Expect(tmpDataTable.IsAddress).to.equal(false);
+						Expect(tmpDataTable.ResolvedAddress).to.equal('DataTableAddress');
+
+						// DataTableAddress is both (always added as hash mapping to itself)
+						let tmpAddr = _Manyfest.checkStringRole('DataTableAddress');
+						Expect(tmpAddr.IsHash).to.equal(true);
+						Expect(tmpAddr.IsAddress).to.equal(true);
+						Expect(tmpAddr.ResolvedAddress).to.equal('DataTableAddress');
+
+						// ValueArray is a hash only
+						let tmpValueArray = _Manyfest.checkStringRole('ValueArray');
+						Expect(tmpValueArray.IsHash).to.equal(true);
+						Expect(tmpValueArray.IsAddress).to.equal(false);
+						Expect(tmpValueArray.ResolvedAddress).to.equal('DataTableAddress[].ValueAddress');
+
+						// Unknown string
+						let tmpUnknown = _Manyfest.checkStringRole('NotInManifest');
+						Expect(tmpUnknown.IsHash).to.equal(false);
+						Expect(tmpUnknown.IsAddress).to.equal(false);
+
+						fTestComplete();
+					}
+				);
+			}
+		);
+	}
+);

package/.babelrc

@@ -1,3 +0,0 @@
-{
-	"presets": ["@babel/preset-env"]
-}

package/.browserslistrc

@@ -1 +0,0 @@
-> 0.01%