manyfest 1.0.30 → 1.0.32

package/source/Manyfest-ObjectAddress-Parser.js

@@ -0,0 +1,298 @@
+// TODO: This is an inelegant solution to delay the rewrite of Manyfest.
+
+// Fable 3.0 has a service for data formatting that deals well with nested enclosures.
+
+// The Manyfest library predates fable 3.0 and the services structure of it, so the functions
+// are more or less pure javascript and as functional as they can be made to be.
+
+// Until we shift Manyfest to be a fable service, these three functions were pulled out of
+// fable to aid in parsing functions with nested enclosures.
+
+module.exports = {
+	/**
+	 * Count the number of segments in a string, respecting enclosures
+	 * 
+	 * @param {string} pString 
+	 * @param {string} pSeparator 
+	 * @param {object} pEnclosureStartSymbolMap 
+	 * @param {object} pEnclosureEndSymbolMap 
+	 * @returns the count of segments in the string as a number
+	 */
+	stringCountSegments: (pString, pSeparator, pEnclosureStartSymbolMap, pEnclosureEndSymbolMap) =>
+	{
+		let tmpString = (typeof(pString) == 'string') ? pString : '';
+
+		let tmpSeparator = (typeof(pSeparator) == 'string') ? pSeparator : '.';
+
+		let tmpEnclosureStartSymbolMap = (typeof(pEnclosureStartSymbolMap) == 'object') ? pEnclosureStart : { '{': 0, '[': 1, '(': 2 };
+		let tmpEnclosureEndSymbolMap = (typeof(pEnclosureEndSymbolMap) == 'object') ? pEnclosureEnd : { '}': 0, ']': 1, ')': 2 };
+
+		if (pString.length < 1)
+		{
+			return 0;
+		}
+
+		let tmpSegmentCount = 1;
+		let tmpEnclosureStack = [];
+
+		for (let i = 0; i < tmpString.length; i++)
+		{
+			// IF This is the start of a segment
+			if ((tmpString[i] == tmpSeparator)
+				// AND we are not in a nested portion of the string
+				&& (tmpEnclosureStack.length == 0))
+			{
+				// Increment the segment count
+				tmpSegmentCount++;
+			}
+			// IF This is the start of an enclosure
+			else if (tmpEnclosureStartSymbolMap.hasOwnProperty(tmpString[i]))
+			{
+				// Add it to the stack!
+				tmpEnclosureStack.push(tmpEnclosureStartSymbolMap[tmpString[i]]);
+			}
+			// IF This is the end of an enclosure
+			else if (tmpEnclosureEndSymbolMap.hasOwnProperty(tmpString[i])
+				// AND it matches the current nest level symbol
+				&& tmpEnclosureEndSymbolMap[tmpString[i]] == tmpEnclosureStack[tmpEnclosureStack.length - 1])
+			{
+				// Pop it off the stack!
+				tmpEnclosureStack.pop();
+			}
+		}
+
+		return tmpSegmentCount;
+	},
+
+	/**
+	 * Get the first segment in a string, respecting enclosures
+	 * 
+	 * @param {string} pString 
+	 * @param {string} pSeparator 
+	 * @param {object} pEnclosureStartSymbolMap 
+	 * @param {object} pEnclosureEndSymbolMap 
+	 * @returns the first segment in the string as a string
+	 */
+	stringGetFirstSegment: (pString, pSeparator, pEnclosureStartSymbolMap, pEnclosureEndSymbolMap) =>
+	{
+		let tmpString = (typeof(pString) == 'string') ? pString : '';
+
+		let tmpSeparator = (typeof(pSeparator) == 'string') ? pSeparator : '.';
+
+		let tmpEnclosureStartSymbolMap = (typeof(pEnclosureStartSymbolMap) == 'object') ? pEnclosureStart : { '{': 0, '[': 1, '(': 2 };
+		let tmpEnclosureEndSymbolMap = (typeof(pEnclosureEndSymbolMap) == 'object') ? pEnclosureEnd : { '}': 0, ']': 1, ')': 2 };
+
+		if (pString.length < 1)
+		{
+			return 0;
+		}
+
+		let tmpEnclosureStack = [];
+
+		for (let i = 0; i < tmpString.length; i++)
+		{
+			// IF This is the start of a segment
+			if ((tmpString[i] == tmpSeparator)
+				// AND we are not in a nested portion of the string
+				&& (tmpEnclosureStack.length == 0))
+			{
+				// Return the segment
+				return tmpString.substring(0, i);
+			}
+			// IF This is the start of an enclosure
+			else if (tmpEnclosureStartSymbolMap.hasOwnProperty(tmpString[i]))
+			{
+				// Add it to the stack!
+				tmpEnclosureStack.push(tmpEnclosureStartSymbolMap[tmpString[i]]);
+			}
+			// IF This is the end of an enclosure
+			else if (tmpEnclosureEndSymbolMap.hasOwnProperty(tmpString[i])
+				// AND it matches the current nest level symbol
+				&& tmpEnclosureEndSymbolMap[tmpString[i]] == tmpEnclosureStack[tmpEnclosureStack.length - 1])
+			{
+				// Pop it off the stack!
+				tmpEnclosureStack.pop();
+			}
+		}
+
+		return tmpString;
+	},
+
+	/**
+	 * Get all segments in a string, respecting enclosures
+	 * 
+	 * @param {string} pString 
+	 * @param {string} pSeparator 
+	 * @param {object} pEnclosureStartSymbolMap 
+	 * @param {object} pEnclosureEndSymbolMap 
+	 * @returns the first segment in the string as a string
+	 */
+	stringGetSegments: (pString, pSeparator, pEnclosureStartSymbolMap, pEnclosureEndSymbolMap)=>
+	{
+		let tmpString = (typeof(pString) == 'string') ? pString : '';
+
+		let tmpSeparator = (typeof(pSeparator) == 'string') ? pSeparator : '.';
+
+		let tmpEnclosureStartSymbolMap = (typeof(pEnclosureStartSymbolMap) == 'object') ? pEnclosureStart : { '{': 0, '[': 1, '(': 2 };
+		let tmpEnclosureEndSymbolMap = (typeof(pEnclosureEndSymbolMap) == 'object') ? pEnclosureEnd : { '}': 0, ']': 1, ')': 2 };
+
+		let tmpCurrentSegmentStart = 0;
+		let tmpSegmentList = [];
+
+		if (pString.length < 1)
+		{
+			return tmpSegmentList;
+		}
+
+		let tmpEnclosureStack = [];
+
+		for (let i = 0; i < tmpString.length; i++)
+		{
+			// IF This is the start of a segment
+			if ((tmpString[i] == tmpSeparator)
+				// AND we are not in a nested portion of the string
+				&& (tmpEnclosureStack.length == 0))
+			{
+				// Return the segment
+				tmpSegmentList.push(tmpString.substring(tmpCurrentSegmentStart, i));
+				tmpCurrentSegmentStart = i+1;
+			}
+			// IF This is the start of an enclosure
+			else if (tmpEnclosureStartSymbolMap.hasOwnProperty(tmpString[i]))
+			{
+				// Add it to the stack!
+				tmpEnclosureStack.push(tmpEnclosureStartSymbolMap[tmpString[i]]);
+			}
+			// IF This is the end of an enclosure
+			else if (tmpEnclosureEndSymbolMap.hasOwnProperty(tmpString[i])
+				// AND it matches the current nest level symbol
+				&& tmpEnclosureEndSymbolMap[tmpString[i]] == tmpEnclosureStack[tmpEnclosureStack.length - 1])
+			{
+				// Pop it off the stack!
+				tmpEnclosureStack.pop();
+			}
+		}
+
+		if (tmpCurrentSegmentStart < tmpString.length)
+		{
+			tmpSegmentList.push(tmpString.substring(tmpCurrentSegmentStart));
+		}
+
+		return tmpSegmentList;
+	},
+
+	/**
+	 * Count the number of enclosures in a string based on the start and end characters.
+	 *
+	 * If no start or end characters are specified, it will default to parentheses.  If the string is not a string, it will return 0.
+	 *
+	 * @param {string} pString
+	 * @param {string} pEnclosureStart
+	 * @param {string} pEnclosureEnd
+	 * @returns the count of full in the string
+	 */
+	stringCountEnclosures: (pString, pEnclosureStart, pEnclosureEnd) =>
+	{
+		let tmpString = (typeof(pString) == 'string') ? pString : '';
+		let tmpEnclosureStart = (typeof(pEnclosureStart) == 'string') ? pEnclosureStart : '(';
+		let tmpEnclosureEnd = (typeof(pEnclosureEnd) == 'string') ? pEnclosureEnd : ')';
+
+		let tmpEnclosureCount = 0;
+		let tmpEnclosureDepth = 0;
+		for (let i = 0; i < tmpString.length; i++)
+		{
+			// This is the start of an enclosure
+			if (tmpString[i] == tmpEnclosureStart)
+			{
+				if (tmpEnclosureDepth == 0)
+				{
+					tmpEnclosureCount++;
+				}
+				tmpEnclosureDepth++;
+			}
+			else if (tmpString[i] == tmpEnclosureEnd)
+			{
+				tmpEnclosureDepth--;
+			}
+		}
+
+		return tmpEnclosureCount;
+	},
+
+
+	/**
+	 * Get the value of the enclosure at the specified index.
+	 *
+	 * If the index is not a number, it will default to 0.  If the string is not a string, it will return an empty string.  If the enclosure is not found, it will return an empty string.  If the enclosure
+	 *
+	 * @param {string} pString
+	 * @param {number} pEnclosureIndexToGet
+	 * @param {string} pEnclosureStart
+	 * @param {string}} pEnclosureEnd
+	 * @returns {string}
+	 */
+	stringGetEnclosureValueByIndex: (pString, pEnclosureIndexToGet, pEnclosureStart, pEnclosureEnd) =>
+	{
+		let tmpString = (typeof(pString) == 'string') ? pString : '';
+		let tmpEnclosureIndexToGet = (typeof(pEnclosureIndexToGet) == 'number') ? pEnclosureIndexToGet : 0;
+		let tmpEnclosureStart = (typeof(pEnclosureStart) == 'string') ? pEnclosureStart : '(';
+		let tmpEnclosureEnd = (typeof(pEnclosureEnd) == 'string') ? pEnclosureEnd : ')';
+
+		let tmpEnclosureCount = 0;
+		let tmpEnclosureDepth = 0;
+
+		let tmpMatchedEnclosureIndex = false;
+		let tmpEnclosedValueStartIndex = 0;
+		let tmpEnclosedValueEndIndex = 0;
+
+		for (let i = 0; i < tmpString.length; i++)
+		{
+			// This is the start of an enclosure
+			if (tmpString[i] == tmpEnclosureStart)
+			{
+				tmpEnclosureDepth++;
+
+				// Only count enclosures at depth 1, but still this parses both pairs of all of them.
+				if (tmpEnclosureDepth == 1)
+				{
+					tmpEnclosureCount++;
+					if (tmpEnclosureIndexToGet == (tmpEnclosureCount - 1))
+					{
+						// This is the start of *the* enclosure
+						tmpMatchedEnclosureIndex = true;
+						tmpEnclosedValueStartIndex = i;
+					}
+				}
+			}
+			// This is the end of an enclosure
+			else if (tmpString[i] == tmpEnclosureEnd)
+			{
+				tmpEnclosureDepth--;
+
+				// Again, only count enclosures at depth 1, but still this parses both pairs of all of them.
+				if ((tmpEnclosureDepth == 0) &&
+					tmpMatchedEnclosureIndex &&
+					(tmpEnclosedValueEndIndex <= tmpEnclosedValueStartIndex))
+				{
+					tmpEnclosedValueEndIndex = i;
+					tmpMatchedEnclosureIndex = false;
+				}
+			}
+		}
+
+		if (tmpEnclosureCount <= tmpEnclosureIndexToGet)
+		{
+			// Return an empty string if the enclosure is not found
+			return '';
+		}
+
+		if ((tmpEnclosedValueEndIndex > 0) && (tmpEnclosedValueEndIndex > tmpEnclosedValueStartIndex))
+		{
+			return tmpString.substring(tmpEnclosedValueStartIndex+1, tmpEnclosedValueEndIndex);
+		}
+		else
+		{
+			return tmpString.substring(tmpEnclosedValueStartIndex+1);
+		}
+	}
+}

package/source/Manyfest-ParseConditionals.js

@@ -18,7 +18,7 @@ const _ConditionalStanzaEnd = '?~>>';
 const _ConditionalStanzaEndLength = _ConditionalStanzaEnd.length;
 
 // Ugh dependency injection.  Can't wait to make these all fable services.
-let libObjectAddressCheckAddressExists = new (require('./Manyfest-ObjectAddress-CheckAddressExists.js'))();
+//let libObjectAddressCheckAddressExists = new (require('./Manyfest-ObjectAddress-CheckAddressExists.js'))();
 
 // Test the condition of a value in a record
 const testCondition = (pManyfest, pRecord, pSearchAddress, pSearchComparator, pValue) =>
@@ -61,17 +61,15 @@ const testCondition = (pManyfest, pRecord, pSearchAddress, pSearchComparator, pV
 					break;
 			}
 			break;
-		case 'FALSE':
-			return (pManyfest.getValueAtAddress(pRecord, pSearchAddress) === false);
-			break;
-		case 'EX':
-		case 'EXISTS':
-			return libObjectAddressCheckAddressExists.checkAddressExists(pRecord, pSearchAddress);
-			break;
-		case 'DNEX':
-		case 'DOES_NOT_EXIST':
-			return !libObjectAddressCheckAddressExists.checkAddressExists(pRecord, pSearchAddress);
-			break;
+		// TODO: Welcome to dependency hell.  This fixes itself when we move to fable services.
+		// case 'EX':
+		// case 'EXISTS':
+		// 	return libObjectAddressCheckAddressExists.checkAddressExists(pRecord, pSearchAddress);
+		// 	break;
+		// case 'DNEX':
+		// case 'DOES_NOT_EXIST':
+		// 	return !libObjectAddressCheckAddressExists.checkAddressExists(pRecord, pSearchAddress);
+		// 	break;
 		case '!=':
 			return (pManyfest.getValueAtAddress(pRecord, pSearchAddress) != pValue);
 			break;

package/test/Manyfest_Embedded_Solvers_tests.js

@@ -59,10 +59,11 @@ suite
 								Scope:'Archive.org',
 								Descriptors:
 									{
-                                        'files[]<<~?length,EXISTS?~>>': {Name:'Files With a length Property', Hash:'FilesWithLength'},
-                                        'files[]<<~?length,DNEX?~>>': {Name:'Files Without a length Property', Hash:'FilesWithoutLength'},
-                                        'files[]<<~?length,DNEX?~>><<~?source,==,original?~>>': {Name:'Original Files With a length Property', Hash:'OriginalFilesWithLength'},
-										'files[]<<~?thumbnail,EXISTS?~>>': {Name:'Thumbnail Bit is Explicitly Set', Hash:'ThumbnailExplicitlySet'},
+										// TODO: STRICKEN OUT BY DEPENDENCY HELL
+                                        //'files[]<<~?length,EXISTS?~>>': {Name:'Files With a length Property', Hash:'FilesWithLength'},
+                                        // 'files[]<<~?length,DNEX?~>>': {Name:'Files Without a length Property', Hash:'FilesWithoutLength'},
+                                        // 'files[]<<~?length,DNEX?~>><<~?source,==,original?~>>': {Name:'Original Files With a length Property', Hash:'OriginalFilesWithLength'},
+										// 'files[]<<~?thumbnail,EXISTS?~>>': {Name:'Thumbnail Bit is Explicitly Set', Hash:'ThumbnailExplicitlySet'},
 										'files[]<<~?thumbnail,TRUE?~>>': {Name:'Thumbnail Files', Hash:'ThumbnailFiles'},
 										'files[]<<~?thumbnail,FALSE?~>>': {Name:'Not Thumbnail Files', Hash:'NotThumbnailFiles'},
 										'files[]<<~?format,LENGTH_LESS_THAN,8?~>>': {Name:'Short Format Files', Hash:'ShortFormatFiles'}
@@ -79,21 +80,22 @@ suite
 						Expect(tmpNotThumbnailFiles).to.be.an('array');
 						Expect(tmpNotThumbnailFiles.length).to.equal(1);
 
-						let tmpFilesWithLength = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'FilesWithLength');
-						Expect(tmpFilesWithLength).to.be.an('array');
-						Expect(tmpFilesWithLength.length).to.equal(3);
+						// TODO: Dependencies are the wurst
+						// let tmpFilesWithLength = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'FilesWithLength');
+						// Expect(tmpFilesWithLength).to.be.an('array');
+						// Expect(tmpFilesWithLength.length).to.equal(3);
 
-						let tmpOGFilesWithLength = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'OriginalFilesWithLength');
-						Expect(tmpOGFilesWithLength).to.be.an('array');
-						Expect(tmpOGFilesWithLength.length).to.equal(2);
+						// let tmpOGFilesWithLength = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'OriginalFilesWithLength');
+						// Expect(tmpOGFilesWithLength).to.be.an('array');
+						// Expect(tmpOGFilesWithLength.length).to.equal(2);
 
-						let tmpFilesWithoutLength = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'FilesWithoutLength');
-						Expect(tmpFilesWithoutLength).to.be.an('array');
-						Expect(tmpFilesWithoutLength.length).to.equal(14);
+						// let tmpFilesWithoutLength = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'FilesWithoutLength');
+						// Expect(tmpFilesWithoutLength).to.be.an('array');
+						// Expect(tmpFilesWithoutLength.length).to.equal(14);
 
-						let tmpExplicitlyExists = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'ThumbnailExplicitlySet');
-						Expect(tmpExplicitlyExists).to.be.an('array');
-						Expect(tmpExplicitlyExists.length).to.equal(2);
+						// let tmpExplicitlyExists = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'ThumbnailExplicitlySet');
+						// Expect(tmpExplicitlyExists).to.be.an('array');
+						// Expect(tmpExplicitlyExists.length).to.equal(2);
 
 						let tmpShortFormatFiles = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'ShortFormatFiles');
 						Expect(tmpShortFormatFiles).to.be.an('array');

package/test/Manyfest_ObjectAddress_Parser_tests.js

@@ -0,0 +1,160 @@
+/**
+* Unit tests for Mock Fable behaviors
+*
+* Shamelessly ripped from fable until we can get the fable service structure in place.
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var libFableDataFormatInjector = require('../source/Manyfest-ObjectAddress-Parser.js');
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+suite
+(
+	'DataArithmatic String Tokenization',
+	function()
+	{
+		setup (()=> {} );
+
+		suite
+		(
+			'Manipulate Strings',
+			()=>
+			{
+
+				test
+				(
+					'Test counting enclosures',
+					(fTestComplete)=>
+					{
+						//let testFable = new libFable({LogStreams: false});
+						let _DataFormat = libFableDataFormatInjector;
+						Expect(_DataFormat
+							.stringCountEnclosures('Dogs (are) cool'))
+							.to.equal(1);
+						Expect(_DataFormat
+							.stringCountEnclosures('Dogs are cool'))
+							.to.equal(0);
+						// It should not count nested enclosures.
+						// Although with getEnclosureValueByIndex and recalling this, you can recursively get them.
+						Expect(_DataFormat
+							.stringCountEnclosures('There (are (many)) of these (things)'))
+							.to.equal(2);
+						Expect(_DataFormat
+							.stringCountEnclosures('There [are (many)] of these (things)'))
+							.to.equal(2);
+						// You can also specify the enclosure characters
+						Expect(_DataFormat
+							.stringCountEnclosures('There [are (many)] of these (things)', '[', ']'))
+							.to.equal(1);
+						// It does not *require* a closing character and still counts the enclosure.
+						// Hotly debated topic.  A setting could be added to change this behavior.
+						Expect(_DataFormat
+							.stringCountEnclosures('There [are (many) of these (things)', '[', ']'))
+							.to.equal(1);
+						return fTestComplete();
+					}
+				);
+				test
+				(
+					'Test getting an enclosure value by index',
+					(fTestComplete)=>
+					{
+						//let testFable = new libFable({LogStreams: false});
+						let _DataFormat = libFableDataFormatInjector;
+						Expect(_DataFormat
+							.stringGetEnclosureValueByIndex('Dogs (are) cool', 0))
+							.to.equal('are');
+						Expect(_DataFormat
+							.stringGetEnclosureValueByIndex('Dogs are cool', 0))
+							.to.equal('');
+						Expect(_DataFormat
+							.stringGetEnclosureValueByIndex('There (are (many)) of these (things)', 0))
+							.to.equal('are (many)');
+						Expect(_DataFormat
+							.stringGetEnclosureValueByIndex('There [are (many)] of these (things)', 1))
+							.to.equal('things');
+						Expect(_DataFormat
+							.stringGetEnclosureValueByIndex('There [are (many)] of these (things)', 2))
+							.to.equal('');
+						Expect(_DataFormat
+							.stringGetEnclosureValueByIndex('(This enclosure is the whole string)', 0))
+							.to.equal('This enclosure is the whole string');
+						// You can also specify the enclosure characters
+						Expect(_DataFormat
+							.stringGetEnclosureValueByIndex('There [are (many)] of these (things)', 0, '[', ']'))
+							.to.equal('are (many)');
+						Expect(_DataFormat
+							.stringGetEnclosureValueByIndex('There [are (many) of these (things)', 0, '[', ']'))
+							.to.equal('are (many) of these (things)');
+						Expect(_DataFormat
+							.stringGetEnclosureValueByIndex('There (are (many) of these (things))', 0))
+							.to.equal('are (many) of these (things)');
+						return fTestComplete();
+					}
+				);
+
+				test
+				(
+					'Test counting segments and respecting enclosures',
+					(fTestComplete)=>
+					{
+						//let testFable = new libFable({LogStreams: false});
+						let _DataFormat = libFableDataFormatInjector;
+						Expect(_DataFormat
+							.stringCountSegments('Dogs.are.cool'))
+							.to.equal(3);
+						Expect(_DataFormat
+							.stringCountSegments('Dogs.are.cool'))
+							.to.equal(3);
+						Expect(_DataFormat
+							.stringCountSegments('Dogs.are(.)cool'))
+							.to.equal(2);
+						Expect(_DataFormat
+							.stringCountSegments('Dogs.are(.[....])co.(.)ol'))
+							.to.equal(3);
+						Expect(_DataFormat
+							.stringCountSegments('Dogs.are(.[....]),co.(.)ol', ','))
+							.to.equal(2);
+						return fTestComplete();
+					}
+				);
+				test
+				(
+					'Get the first segment of a string',
+					(fTestComplete)=>
+					{
+						//let testFable = new libFable({LogStreams: false});
+						let _DataFormat = libFableDataFormatInjector;
+						Expect(_DataFormat
+							.stringGetFirstSegment('Dogs.are.cool'))
+							.to.equal('Dogs');
+						Expect(_DataFormat
+							.stringGetFirstSegment('Dogs().are.cool'))
+							.to.equal('Dogs()');
+						Expect(_DataFormat
+							.stringGetFirstSegment('Dogs[This.That(),Equals(THEM)].are(.)cool'))
+							.to.equal('Dogs[This.That(),Equals(THEM)]');
+						Expect(_DataFormat
+							.stringGetFirstSegment('Dogs(.are(.[....])co.(.)ol'))
+							.to.equal('Dogs(.are(.[....])co.(.)ol');
+						Expect(_DataFormat
+							.stringGetFirstSegment('Dogs(.are(,[....])co.(.)ol', ','))
+							.to.equal('Dogs(.are(,[....])co.(.)ol');
+						Expect(_DataFormat
+							.stringGetFirstSegment('Dogs.are(,[....]),co.(.)ol', ','))
+							.to.equal('Dogs.are(,[....])');
+						Expect(_DataFormat
+							.stringGetFirstSegment('..Dogs.are(,[....]),co.(.)ol', '.'))
+							.to.equal('');
+						return fTestComplete();
+					}
+				);
+			}
+		);
+	}
+);

package/test/Manyfest_Object_CheckExistence_tests.js

@@ -64,6 +64,60 @@ suite
 						fTestComplete();
 					}
 				);
+				test
+				(
+					'Elements exist in function return values ... yiiiiikes.',
+					(fTestComplete)=>
+					{
+						// Create a compmlex mock object to check metadata on.
+						let _MockObject = (
+							{
+								"Name": "Yadda",
+								"TheFunction": (pValue) => { return `Value is: ${pValue}`; },
+								"ComplexFunction": (pValue, pOutput) => { return `Value is: ${pValue} and would output as ${pOutput}`; },
+								"Behaviors": 
+									{
+										"Value": 0,
+										"Increment": function () 
+											{
+												this.Value++; return this.Value;
+											},
+										"SillyObject": function()
+										{
+											return { Cost: 1.00, Name: 'Beanie Baby', Stores: ['Aberdeen', 'Seattle', 'Tacoma'] }
+										},
+										"FormatOutput": function () { return `My magic value is: ${this.Value}`; }
+									},
+								"Manyfest":
+									{
+										Scope:'Function.Mock',
+										Descriptors:
+											{
+												"metadata.creator":
+													{
+														Name:'Creator',
+														Hash:'Creator'
+													}
+											}
+									},
+								"Data": _SampleDataArchiveOrgFrankenberry
+							});
+						let _Manyfest = new libManyfest(_MockObject.Manyfest);
+
+						// Function existence should just work
+						Expect(_Manyfest.checkAddressExists(_MockObject, 'Behaviors.SillyObject')).to.equal(true);
+						// If it is a function we can ask manyfest if it's a function and it will be true
+						Expect(_Manyfest.checkAddressExists(_MockObject, 'Behaviors.SillyObject()')).to.equal(true);
+						// Non functions will return false even if they exist.
+						Expect(_Manyfest.checkAddressExists(_MockObject, 'Behaviors.Value')).to.equal(true);
+						Expect(_Manyfest.checkAddressExists(_MockObject, 'Behaviors.Value()')).to.equal(false);
+
+						Expect(_Manyfest.checkAddressExists(_MockObject, 'Behaviors.SillyObject().Stores')).to.equal(true);
+						Expect(_Manyfest.checkAddressExists(_MockObject, 'Behaviors.SillyObject().Stores[0]')).to.equal(true);
+
+						fTestComplete();
+					}
+				);
 			}
 		);
 	}