fable 3.0.45 → 3.0.47

package/retold-harness/model/sql_create/MySQL-Security.sql

@@ -0,0 +1,5 @@
+FLUSH PRIVILEGES;
+
+ALTER USER 'root'@'localhost' IDENTIFIED BY '123456789';
+
+GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '123456789' WITH GRANT OPTION;

package/source/services/Fable-Service-MetaTemplate/MetaTemplate-StringParser.js

@@ -0,0 +1,281 @@
+/**
+* MetaTemplate String Parser
+* @author      Steven Velozo <steven@velozo.com>
+* @description Parse a string, properly processing each matched token in the word tree.
+*/
+
+class StringParser
+{
+	/**
+	 * StringParser Constructor
+	 */
+	constructor(fEachLimit)
+	{
+		this.eachLimit = fEachLimit;
+	}
+
+	/**
+	 * Create a fresh parsing state object to work with.
+	 * @method newParserState
+	 * @param {Object} pParseTree - A node on the parse tree to begin parsing from (usually root)
+	 * @return {Object} A new parser state object for running a character parser on
+	 * @private
+	 */
+	newParserState (pParseTree)
+	{
+		return (
+		{
+			ParseTree: pParseTree,
+
+			Asynchronous: false,
+
+			Output: '',
+			OutputBuffer: '',
+
+			Pattern: false,
+
+			PatternMatch: false,
+			PatternMatchOutputBuffer: ''
+		});
+	}
+
+	/**
+	 * Assign a node of the parser tree to be the next potential match.
+	 * If the node has a PatternEnd property, it is a valid match and supercedes the last valid match (or becomes the initial match).
+	 * @method assignNode
+	 * @param {Object} pNode - A node on the parse tree to assign
+	 * @param {Object} pParserState - The state object for the current parsing task
+	 * @private
+	 */
+	assignNode (pNode, pParserState)
+	{
+		pParserState.PatternMatch = pNode;
+
+		// If the pattern has a END we can assume it has a parse function...
+		if (pParserState.PatternMatch.hasOwnProperty('PatternEnd'))
+		{
+			// ... this is the legitimate start of a pattern.
+			pParserState.Pattern = pParserState.PatternMatch;
+		}
+	}
+
+	/**
+	 * Append a character to the output buffer in the parser state.
+	 * This output buffer is used when a potential match is being explored, or a match is being explored.
+	 * @method appendOutputBuffer
+	 * @param {string} pCharacter - The character to append
+	 * @param {Object} pParserState - The state object for the current parsing task
+	 * @private
+	 */
+	appendOutputBuffer (pCharacter, pParserState)
+	{
+		pParserState.OutputBuffer += pCharacter;
+	}
+
+	/**
+	 * Flush the output buffer to the output and clear it.
+	 * @method flushOutputBuffer
+	 * @param {Object} pParserState - The state object for the current parsing task
+	 * @private
+	 */
+	flushOutputBuffer (pParserState)
+	{
+		pParserState.Output += pParserState.OutputBuffer;
+		pParserState.OutputBuffer = '';
+	}
+
+	/**
+	 * Check if the pattern has ended.  If it has, properly flush the buffer and start looking for new patterns.
+	 * @method checkPatternEnd
+	 * @param {Object} pParserState - The state object for the current parsing task
+	 * @private
+	 */
+	checkPatternEnd (pParserState, pData)
+	{
+		if ((pParserState.OutputBuffer.length >= pParserState.Pattern.PatternEnd.length+pParserState.Pattern.PatternStart.length) &&
+			(pParserState.OutputBuffer.substr(-pParserState.Pattern.PatternEnd.length) === pParserState.Pattern.PatternEnd))
+		{
+			// ... this is the end of a pattern, cut off the end tag and parse it.
+			// Trim the start and end tags off the output buffer now
+			if (pParserState.Pattern.isAsync)
+			{
+				console.log(`Precedent ERROR: Async template detected for pattern ${pParserState.Pattern.PatternStart} ... ${pParserState.Pattern.PatternEnd} but the template engine is being run in non-async mode.`);
+				this.OutputBuffer = '';
+				// Flush the output buffer.
+				this.flushOutputBuffer(pParserState);
+				// End pattern mode
+				pParserState.Pattern = false;
+				pParserState.PatternMatch = false;
+			}
+			else
+			{
+				pParserState.OutputBuffer = pParserState.Pattern.Parse(pParserState.OutputBuffer.substr(pParserState.Pattern.PatternStart.length, pParserState.OutputBuffer.length - (pParserState.Pattern.PatternStart.length+pParserState.Pattern.PatternEnd.length)), pData);
+				// Flush the output buffer.
+				this.flushOutputBuffer(pParserState);
+				// End pattern mode
+				pParserState.Pattern = false;
+				pParserState.PatternMatch = false;
+			}
+		}
+	}
+
+	checkPatternEndAsync (pParserState, pData, fCallback)
+	{
+		if ((pParserState.OutputBuffer.length >= pParserState.Pattern.PatternEnd.length+pParserState.Pattern.PatternStart.length) &&
+			(pParserState.OutputBuffer.substr(-pParserState.Pattern.PatternEnd.length) === pParserState.Pattern.PatternEnd))
+		{
+			// ... this is the end of a pattern, cut off the end tag and parse it.
+			// Trim the start and end tags off the output buffer now
+			if (pParserState.Pattern.isAsync)
+			{
+				return pParserState.Pattern.Parse(pParserState.OutputBuffer.substr(pParserState.Pattern.PatternStart.length, pParserState.OutputBuffer.length - (pParserState.Pattern.PatternStart.length+pParserState.Pattern.PatternEnd.length)), pData,
+					(pError, pAsyncOutput) =>
+					{
+						if (pError)
+						{
+							console.log(`Precedent ERROR: Async template error happened parsing ${pParserState.Pattern.PatternStart} ... ${pParserState.Pattern.PatternEnd}: ${pError}`);
+						}
+
+						pParserState.OutputBuffer = pAsyncOutput;
+						// Flush the output buffer.
+						this.flushOutputBuffer(pParserState);
+						// End pattern mode
+						pParserState.Pattern = false;
+						pParserState.PatternMatch = false;
+
+						return fCallback();
+					});
+			}
+			else
+			{
+				pParserState.OutputBuffer = pParserState.Pattern.Parse(pParserState.OutputBuffer.substr(pParserState.Pattern.PatternStart.length, pParserState.OutputBuffer.length - (pParserState.Pattern.PatternStart.length+pParserState.Pattern.PatternEnd.length)), pData);
+				// Flush the output buffer.
+				this.flushOutputBuffer(pParserState);
+				// End pattern mode
+				pParserState.Pattern = false;
+				pParserState.PatternMatch = false;
+			}
+		}
+
+		return fCallback();
+	}
+
+	/**
+	 * Parse a character in the buffer.
+	 * @method parseCharacter
+	 * @param {string} pCharacter - The character to append
+	 * @param {Object} pParserState - The state object for the current parsing task
+	 * @private
+	 */
+	parseCharacter (pCharacter, pParserState, pData)
+	{
+		// (1) If we aren't in a pattern match, and we aren't potentially matching, and this may be the start of a new pattern....
+		if (!pParserState.PatternMatch && pParserState.ParseTree.hasOwnProperty(pCharacter))
+		{
+			// ... assign the node as the matched node.
+			this.assignNode(pParserState.ParseTree[pCharacter], pParserState);
+			this.appendOutputBuffer(pCharacter, pParserState);
+		}
+		// (2) If we are in a pattern match (actively seeing if this is part of a new pattern token)
+		else if (pParserState.PatternMatch)
+		{
+			// If the pattern has a subpattern with this key
+			if (pParserState.PatternMatch.hasOwnProperty(pCharacter))
+			{
+				// Continue matching patterns.
+				this.assignNode(pParserState.PatternMatch[pCharacter], pParserState);
+			}
+			this.appendOutputBuffer(pCharacter, pParserState);
+			if (pParserState.Pattern)
+			{
+				// ... Check if this is the end of the pattern (if we are matching a valid pattern)...
+				this.checkPatternEnd(pParserState, pData);
+			}
+		}
+		// (3) If we aren't in a pattern match or pattern, and this isn't the start of a new pattern (RAW mode)....
+		else
+		{
+			pParserState.Output += pCharacter;
+		}
+	}
+
+	parseCharacterAsync (pCharacter, pParserState, pData, fCallback)
+	{
+		// (1) If we aren't in a pattern match, and we aren't potentially matching, and this may be the start of a new pattern....
+		if (!pParserState.PatternMatch && pParserState.ParseTree.hasOwnProperty(pCharacter))
+		{
+			// ... assign the node as the matched node.
+			this.assignNode(pParserState.ParseTree[pCharacter], pParserState);
+			this.appendOutputBuffer(pCharacter, pParserState);
+		}
+		// (2) If we are in a pattern match (actively seeing if this is part of a new pattern token)
+		else if (pParserState.PatternMatch)
+		{
+			// If the pattern has a subpattern with this key
+			if (pParserState.PatternMatch.hasOwnProperty(pCharacter))
+			{
+				// Continue matching patterns.
+				this.assignNode(pParserState.PatternMatch[pCharacter], pParserState);
+			}
+			this.appendOutputBuffer(pCharacter, pParserState);
+			if (pParserState.Pattern)
+			{
+				// ... Check if this is the end of the pattern (if we are matching a valid pattern)...
+				return this.checkPatternEndAsync(pParserState, pData, fCallback);
+			}
+		}
+		// (3) If we aren't in a pattern match or pattern, and this isn't the start of a new pattern (RAW mode)....
+		else
+		{
+			pParserState.Output += pCharacter;
+		}
+
+		return fCallback(null);
+	}
+
+	/**
+	 * Parse a string for matches, and process any template segments that occur.
+	 * @method parseString
+	 * @param {string} pString - The string to parse.
+	 * @param {Object} pParseTree - The parse tree to begin parsing from (usually root)
+	 * @param {Object} pData - The data to pass to the function as a second parameter
+	 * @param {function} fCallback - The callback function to call when the parse is complete
+	 */
+	parseString (pString, pParseTree, pData, fCallback)
+	{
+		if (typeof(fCallback) !== 'function')
+		{
+			let tmpParserState = this.newParserState(pParseTree);
+
+			for (var i = 0; i < pString.length; i++)
+			{
+				// TODO: This is not fast.
+				this.parseCharacter(pString[i], tmpParserState, pData, fCallback);
+			}
+
+			this.flushOutputBuffer(tmpParserState);
+
+			return tmpParserState.Output;
+		}
+		else
+		{
+			// This is the async mode
+			let tmpParserState = this.newParserState(pParseTree);
+
+			this.eachLimit(pString, 1,
+				(pCharacter, fCharacterCallback) =>
+				{
+					this.parseCharacterAsync(pCharacter, tmpParserState, pData, fCharacterCallback);
+				},
+				(pError) =>
+				{
+					// Flush the remaining data
+					this.flushOutputBuffer(tmpParserState);
+					fCallback(pError, tmpParserState.Output);
+				});
+
+		}
+	}
+}
+
+module.exports = StringParser;

package/source/services/Fable-Service-MetaTemplate/MetaTemplate-WordTree.js

@@ -0,0 +1,97 @@
+/**
+* MetaTemplate Word Tree
+* @author      Steven Velozo <steven@velozo.com>
+* @description Create a tree (directed graph) of Javascript objects, one character per object.
+*/
+
+class WordTree
+{
+	/**
+	 * WordTree Constructor
+	 */
+	constructor()
+	{
+		this.ParseTree = {};
+	}
+
+	/**
+	 * Add a child character to a Parse Tree node
+	 * @method addChild
+	 * @param {Object} pTree - A parse tree to push the characters into
+	 * @param {string} pPattern - The string to add to the tree
+	 * @param {number} pIndex - The index of the character in the pattern
+	 * @returns {Object} The resulting leaf node that was added (or found)
+	 * @private
+	 */
+	addChild (pTree, pPattern, pIndex)
+	{
+		if (!pTree.hasOwnProperty(pPattern[pIndex]))
+			pTree[pPattern[pIndex]] = {};
+
+		return pTree[pPattern[pIndex]];
+	}
+
+	/** Add a Pattern to the Parse Tree
+	 * @method addPattern
+	 * @param {Object} pPatternStart - The starting string for the pattern (e.g. "${")
+	 * @param {string} pPatternEnd - The ending string for the pattern (e.g. "}")
+	 * @param {number} pParser - The function to parse if this is the matched pattern, once the Pattern End is met.  If this is a string, a simple replacement occurs.
+	 * @return {bool} True if adding the pattern was successful
+	 */
+	addPattern (pPatternStart, pPatternEnd, pParser)
+	{
+		if (pPatternStart.length < 1)
+			return false;
+
+		if ((typeof(pPatternEnd) === 'string') && (pPatternEnd.length < 1))
+			return false;
+
+		let tmpLeaf = this.ParseTree;
+
+		// Add the tree of leaves iteratively
+		for (var i = 0; i < pPatternStart.length; i++)
+			tmpLeaf = this.addChild(tmpLeaf, pPatternStart, i);
+
+		tmpLeaf.PatternStart = pPatternStart;
+		tmpLeaf.PatternEnd = ((typeof(pPatternEnd) === 'string') && (pPatternEnd.length > 0)) ? pPatternEnd : pPatternStart;
+		tmpLeaf.Parse = (typeof(pParser) === 'function') ? pParser :
+						(typeof(pParser) === 'string') ? () => { return pParser; } :
+						(pData) => { return pData; };
+		tmpLeaf.isPromise = false;
+
+		return true;
+	}
+
+	/** Add a Pattern to the Parse Tree (asynchronous)
+	 * @method addPattern
+	 * @param {Object} pPatternStart - The starting string for the pattern (e.g. "${")
+	 * @param {string} pPatternEnd - The ending string for the pattern (e.g. "}")
+	 * @param {number} pParserAsync - The function (with an asynchronous callback) to parse if this is the matched pattern, once the Pattern End is met.  If this is a string, a simple replacement occurs.
+	 * @return {bool} True if adding the pattern was successful
+	 */
+	addPatternAsync (pPatternStart, pPatternEnd, pParserAsync)
+	{
+		if (pPatternStart.length < 1)
+			return false;
+
+		if ((typeof(pPatternEnd) === 'string') && (pPatternEnd.length < 1))
+			return false;
+
+		let tmpLeaf = this.ParseTree;
+
+		// Add the tree of leaves iteratively
+		for (var i = 0; i < pPatternStart.length; i++)
+			tmpLeaf = this.addChild(tmpLeaf, pPatternStart, i);
+
+		tmpLeaf.PatternStart = pPatternStart;
+		tmpLeaf.PatternEnd = ((typeof(pPatternEnd) === 'string') && (pPatternEnd.length > 0)) ? pPatternEnd : pPatternStart;
+		tmpLeaf.Parse = (typeof(pParserAsync) === 'function') ? pParserAsync :
+						(typeof(pParserAsync) === 'string') ? (pHash, pData, fCallback) => { fCallback(pParserPromise); } :
+						(pHash, pData, fCallback) => { return fCallback(pHash); };
+		tmpLeaf.isAsync = true;
+
+		return true;
+	}
+}
+
+module.exports = WordTree;

package/source/services/Fable-Service-MetaTemplate.js

@@ -1,6 +1,13 @@
 const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
 
-const libPrecedent = require('precedent');
+/**
+* Precedent Meta-Templating
+* @author      Steven Velozo <steven@velozo.com>
+* @description Process text stream trie and postfix tree, parsing out meta-template expression functions.
+*/
+const libWordTree = require(`./Fable-Service-MetaTemplate/MetaTemplate-WordTree.js`);
+const libStringParser = require(`./Fable-Service-MetaTemplate/MetaTemplate-StringParser.js`);
+
 
 class FableServiceMetaTemplate extends libFableServiceBase
 {
@@ -10,9 +17,15 @@ class FableServiceMetaTemplate extends libFableServiceBase
 
         this.serviceType = 'MetaTemplate';
 
-        this._MetaTemplateLibrary = new libPrecedent(this.options);
+		this.WordTree = new libWordTree();
+
+		// In order to allow asynchronous template processing we need to use the async.eachLimit function
+		this.StringParser = new libStringParser(this.fable.defaultServices.Utility.eachLimit);
+
+		this.ParseTree = this.WordTree.ParseTree;
 	}
 
+
 	/**
 	 * Add a Pattern to the Parse Tree
 	 * @method addPattern
@@ -23,23 +36,24 @@ class FableServiceMetaTemplate extends libFableServiceBase
 	 */
 	addPattern(pPatternStart, pPatternEnd, pParser)
 	{
-		return this._MetaTemplateLibrary.addPattern(pPatternStart, pPatternEnd, pParser);
+		return this.WordTree.addPattern(pPatternStart, pPatternEnd, pParser);
 	}
 
-	addPatternAsync(pPatternStart, pPatternEnd, pParser)
+	addPatternAsync(pPatternStart, pPatternEnd, pParserPromise)
 	{
-		return this._MetaTemplateLibrary.addPatternAsync(pPatternStart, pPatternEnd, pParser);
+		return this.WordTree.addPatternAsync(pPatternStart, pPatternEnd, pParserPromise);
 	}
 
 	/**
 	 * Parse a string with the existing parse tree
 	 * @method parseString
 	 * @param {string} pString - The string to parse
+	 * @param {object} pData - Data to pass in as the second argument
 	 * @return {string} The result from the parser
 	 */
 	parseString(pString, pData, fCallback)
 	{
-		return this._MetaTemplateLibrary.parseString(pString, pData, fCallback);
+		return this.StringParser.parseString(pString, this.ParseTree, pData, fCallback);
 	}
 }
 

package/source/services/Fable-Service-Operation-DefaultSettings.js

@@ -1,7 +1,7 @@
 module.exports = (
     {
         "Metadata": {
-            "GUID": false,
+            "UUID": false,
             "Hash": false,
 
             "Title": "",

package/source/services/Fable-Service-Operation.js

@@ -13,20 +13,13 @@ class FableOperation extends libFableServiceBase
 
 		this.state = JSON.parse(_OperationStatePrototypeString);
 
-		this.state.Metadata.GUID = this.fable.getUUID();
+		// Match the service instantiation to the operation.
 		this.state.Metadata.Hash = this.Hash;
+		this.state.Metadata.UUID = this.UUID;
 
-		this.name = (typeof(this.options.Name) == 'string') ? this.options.Name : `Unnamed Operation ${this.state.Metadata.GUID}`;
-	}
+		this.name = (typeof(this.options.Name) == 'string') ? this.options.Name : `Unnamed Operation ${this.state.Metadata.UUID}`;
 
-	get GUID()
-	{
-		return this.state.Metadata.GUID;
-	}
-
-	get log()
-	{
-		return this;
+		this.log = this;
 	}
 
 	writeOperationLog(pLogLevel, pLogText, pLogObject)