manyfest 1.0.0

package/.config/code-server/config.yaml

@@ -0,0 +1,4 @@
+bind-addr: 127.0.0.1:8080
+auth: password
+password: luxury
+cert: false

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

@@ -0,0 +1,4 @@
+{
+	"optOut": false,
+	"lastUpdateCheck": 1648097783781
+}

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

@@ -0,0 +1,4 @@
+{
+	"optOut": false,
+	"lastUpdateCheck": 1664845901965
+}

package/.config/installation/UI-Requirements.md

@@ -0,0 +1,32 @@
+# Questions
+
+. What would you like to call your luxury workspace? my_cool_software
+. What would you like the default password for the code editor to be? 123456789
+. What would you like the repository prefix for your docker images and containers to be? luxury
+. What port would you like to expose the code editor on? 12345
+. Would you like the code editor limited to the local device (explicitly mapping the exposed docker port to 127.0.0.1)? Y
+. Would you like me to generate a Dockerfile? Y
+	a. What would you like the Dockerfile to be called? Dockerfile_LUXURY
+	b. Would you like to run Stricture on a folder/file? N
+	    i.   Which file? ./Model.ddl
+	c. Would you like MySQL in the Docker Environment? N
+		i.   Would you like to expose the MySQL port? Y
+		ii.  What port would you like to expose MySQL on? 3306
+		iii. What would you like the default mysql root password to be? 123456789
+		iv.  What would you like the database name to be? luxury_database
+		v.   Would you like to execute a SQL database population script on container creation (the database is created automatically)? N
+		vi.  Which script would you like to run? ./Database-Initialization.sql
+	d. Would you like add-ons to be installed by default to Visual Studio Code? Y
+		i.   hbenl.vscode-mocha-test-adapter (binding for mocha tests to the test explorer)
+		ii.  hbenl.test-adapter-converter (mocha test suite conversion)
+		iii. hbenl.vscode-test-explorer (tree view for visualizing and executing tests)
+		iv.  ritwickdey.LiveServer (static html web server)
+		v.   daylerees.rainglow (tons of color themes like the freshest theme: freshcut)
+		vi.  oderwat.indent-rainbow (rainbow-colored indent levels)
+. Would you like me to edit the package.json? Y
+	a. Docker build statements
+	b. Mocha tdd test run statements
+	c. Mocha IDE test configurations
+
+
+

package/.config/installation/install_luxury_code.js

@@ -0,0 +1,105 @@
+const libReadline = require('readline');
+
+/********************************************************************
+ * Stolen from Informary for basic management of values in the config
+ */
+const getValueAtAddress = (pObject, pAddress) =>
+{
+    // Make sure pObject is an object
+    if (!typeof(pObject) === 'object') return false;
+    // Make sure pAddress is a string
+    if (!typeof(pAddress) === 'string') return false;
+
+    let tmpSeparatorIndex = pAddress.indexOf('.');
+
+    if (tmpSeparatorIndex === -1)
+    {
+        // Now is the time to return the value in the address
+        return pObject[pAddress];
+    }
+    else
+    {
+        let tmpSubObjectName = pAddress.substring(0, tmpSeparatorIndex);
+        let tmpNewAddress = pAddress.substring(tmpSeparatorIndex+1);
+
+        // 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!
+        if (pObject.hasOwnProperty(tmpSubObjectName) && typeof(pObject[tmpSubObjectName]) !== 'object')
+        {
+            return false;
+        }
+        else if (pObject.hasOwnProperty(tmpSubObjectName))
+        {
+            // If there is already a subobject pass that to the recursive thingy
+            return getValueAtAddress(pObject[tmpSubObjectName], tmpNewAddress);
+        }
+        else
+        {
+            // Create a subobject and then pass that
+            pObject[tmpSubObjectName] = {};
+            return getValueAtAddress(pObject[tmpSubObjectName], tmpNewAddress);
+        }
+    }
+};
+
+const setValueAtAddress = (pObject, pAddress, pValue) =>
+{
+    // Make sure pObject is an object
+    if (!typeof(pObject) === 'object') return false;
+    // Make sure pAddress is a string
+    if (!typeof(pAddress) === 'string') return false;
+
+    let tmpSeparatorIndex = pAddress.indexOf('.');
+
+    if (tmpSeparatorIndex === -1)
+    {
+        // Now is the time to set the value in the object
+        pObject[pAddress] = pValue;
+        return true;
+    }
+    else
+    {
+        let tmpSubObjectName = pAddress.substring(0, tmpSeparatorIndex);
+        let tmpNewAddress = pAddress.substring(tmpSeparatorIndex+1);
+
+        // 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!
+        if (pObject.hasOwnProperty(tmpSubObjectName) && typeof(pObject[tmpSubObjectName]) !== 'object')
+        {
+            if (!pObject.hasOwnProperty('__ERROR'))
+                pObject['__ERROR'] = {};
+            // Put it in an error object so data isn't lost
+            pObject['__ERROR'][pAddress] = pValue;
+            return false;
+        }
+        else if (pObject.hasOwnProperty(tmpSubObjectName))
+        {
+            // If there is already a subobject pass that to the recursive thingy
+            return setValueAtAddress(pObject[tmpSubObjectName], tmpNewAddress, pValue);
+        }
+        else
+        {
+            // Create a subobject and then pass that
+            pObject[tmpSubObjectName] = {};
+            return setValueAtAddress(pObject[tmpSubObjectName], tmpNewAddress, pValue);
+        }
+    }
+};
+/*
+ * End of Informary-stolen code
+ *******************************************************************/
+
+
+const tmpConsoleInteraction = libReadline.createInterface(
+    {
+        input: process.stdin,
+        output: process.stdout
+    });
+
+tmpConsoleInteraction.question(
+    'What do you think of Luxury? ',
+    (pResponse) =>
+    {
+        console.log(`--> You should think about why you think Luxury is [${pResponse}]`);
+        tmpConsoleInteraction.close();
+    });

package/.config/installation/install_luxury_default_configuration.json

@@ -0,0 +1,45 @@
+{
+    "WorkspaceName": "my_cool_software",
+    "Docker":
+    {
+        "ContainerPrefix": "luxury",
+        "ImagePrefix": "luxury",
+
+        "DockerfileName": "Dockerfile_LUXURY",
+
+        "AutoGenerateLuxuryDockerfile": true,
+
+        "WebEditor":
+        {
+            "Password": "123456789",
+            "ExternalPort": 12345,
+            
+            "AutoInstallAddOns": true,
+            "AddonList":
+            {
+                "hbenl.vscode-mocha-test-adapter": true,
+                "hbenl.test-adapter-converter": true,
+		        "hbenl.vscode-test-explorer": true,
+		        "ritwickdey.LiveServer": true,
+		        "daylerees.rainglow": true,
+                "oderwat.indent-rainbow": true
+            }
+        },
+
+        "MySQL":
+        {
+            "Installation": true,
+            "Password": "123456789",
+            "ExternalPort": 13306,
+            "DatabaseName": "luxury_database",
+            "RunPopulateScript": false,
+            "PopulateScriptFile": "Database-Initialization.sql"
+        }
+    },
+    "Package-json":
+    {
+        "AutoUpdate": true,
+        "MochaTestRunCommands": false,
+        "MochaIDEConfigurations": true
+    }
+}

package/.config/installation/install_luxury_interaction.json

@@ -0,0 +1,3 @@
+{
+    ""
+}

package/.config/installation/precedent.1.0.5.js

@@ -0,0 +1,339 @@
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+"use strict";
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+/**
+* Precedent Meta-Templating
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*
+* @description Process text streams, parsing out meta-template expressions.
+*/
+var libWordTree = require("./WordTree.js");
+var libStringParser = require("./StringParser.js");
+
+var Precedent = function () {
+	/**
+  * Precedent Constructor
+  */
+	function Precedent() {
+		_classCallCheck(this, Precedent);
+
+		this.WordTree = new libWordTree();
+
+		this.StringParser = new libStringParser();
+
+		this.ParseTree = this.WordTree.ParseTree;
+	}
+
+	/**
+  * Add a Pattern to the Parse Tree
+  * @method addPattern
+  * @param {Object} pTree - A node on the parse tree to push the characters into
+  * @param {string} pPattern - The string to add to the tree
+  * @param {number} pIndex - callback function
+  * @return {bool} True if adding the pattern was successful
+  */
+
+
+	_createClass(Precedent, [{
+		key: "addPattern",
+		value: function addPattern(pPatternStart, pPatternEnd, pParser) {
+			return this.WordTree.addPattern(pPatternStart, pPatternEnd, pParser);
+		}
+
+		/**
+   * Parse a string with the existing parse tree
+   * @method parseString
+   * @param {string} pString - The string to parse
+   * @return {string} The result from the parser
+   */
+
+	}, {
+		key: "parseString",
+		value: function parseString(pString) {
+			return this.StringParser.parseString(pString, this.ParseTree);
+		}
+	}]);
+
+	return Precedent;
+}();
+
+module.exports = Precedent;
+
+},{"./StringParser.js":2,"./WordTree.js":3}],2:[function(require,module,exports){
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+/**
+* String Parser
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*
+* @description Parse a string, properly processing each matched token in the word tree.
+*/
+
+var StringParser = function () {
+	/**
+  * StringParser Constructor
+  */
+	function StringParser() {
+		_classCallCheck(this, StringParser);
+	}
+
+	/**
+  * 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
+  */
+
+
+	_createClass(StringParser, [{
+		key: 'newParserState',
+		value: function newParserState(pParseTree) {
+			return {
+				ParseTree: pParseTree,
+
+				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
+   */
+
+	}, {
+		key: 'assignNode',
+		value: function 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
+   */
+
+	}, {
+		key: 'appendOutputBuffer',
+		value: function 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
+   */
+
+	}, {
+		key: 'flushOutputBuffer',
+		value: function 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
+   */
+
+	}, {
+		key: 'checkPatternEnd',
+		value: function checkPatternEnd(pParserState) {
+			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
+				pParserState.OutputBuffer = pParserState.Pattern.Parse(pParserState.OutputBuffer.substr(pParserState.Pattern.PatternStart.length, pParserState.OutputBuffer.length - (pParserState.Pattern.PatternStart.length + pParserState.Pattern.PatternEnd.length)));
+				// Flush the output buffer.
+				this.flushOutputBuffer(pParserState);
+				// End pattern mode
+				pParserState.Pattern = false;
+				pParserState.PatternMatch = false;
+			}
+		}
+
+		/**
+   * 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
+   */
+
+	}, {
+		key: 'parseCharacter',
+		value: function parseCharacter(pCharacter, pParserState) {
+			// (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);
+					}
+				}
+				// (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;
+					}
+		}
+
+		/**
+   * 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)
+   */
+
+	}, {
+		key: 'parseString',
+		value: function parseString(pString, pParseTree) {
+			var tmpParserState = this.newParserState(pParseTree);
+
+			for (var i = 0; i < pString.length; i++) {
+				// TODO: This is not fast.
+				this.parseCharacter(pString[i], tmpParserState);
+			}
+
+			this.flushOutputBuffer(tmpParserState);
+
+			return tmpParserState.Output;
+		}
+	}]);
+
+	return StringParser;
+}();
+
+module.exports = StringParser;
+
+},{}],3:[function(require,module,exports){
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+/**
+* Word Tree
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*
+* @description Create a tree (directed graph) of Javascript objects, one character per object.
+*/
+
+var WordTree = function () {
+	/**
+  * WordTree Constructor
+  */
+	function WordTree() {
+		_classCallCheck(this, WordTree);
+
+		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 - callback function
+  * @returns {Object} The resulting leaf node that was added (or found)
+  * @private
+  */
+
+
+	_createClass(WordTree, [{
+		key: 'addChild',
+		value: function addChild(pTree, pPattern, pIndex) {
+			if (pIndex > pPattern.length) return pTree;
+
+			if (!pTree.hasOwnProperty(pPattern[pIndex])) pTree[pPattern[pIndex]] = {};
+
+			return pTree[pPattern[pIndex]];
+		}
+
+		/** Add a Pattern to the Parse Tree
+   * @method addPattern
+   * @param {Object} pTree - A node on the parse tree to push the characters into
+   * @param {string} pPattern - The string to add to the tree
+   * @param {number} pIndex - callback function
+   * @return {bool} True if adding the pattern was successful
+   */
+
+	}, {
+		key: 'addPattern',
+		value: function addPattern(pPatternStart, pPatternEnd, pParser) {
+			if (pPatternStart.length < 1) return false;
+
+			var 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' ? function () {
+				return pParser;
+			} : function (pData) {
+				return pData;
+			};
+
+			return true;
+		}
+	}]);
+
+	return WordTree;
+}();
+
+module.exports = WordTree;
+
+},{}]},{},[1])
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","source/Precedent.js","source/StringParser.js","source/WordTree.js"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/**\n* Precedent Meta-Templating\n*\n* @license     MIT\n*\n* @author      Steven Velozo <steven@velozo.com>\n*\n* @description Process text streams, parsing out meta-template expressions.\n*/\nvar libWordTree = require(`./WordTree.js`);\nvar libStringParser = require(`./StringParser.js`);\n\nclass Precedent\n{\n\t/**\n\t * Precedent Constructor\n\t */\n\tconstructor()\n\t{\n\t\tthis.WordTree = new libWordTree();\n\t\t\n\t\tthis.StringParser = new libStringParser();\n\n\t\tthis.ParseTree = this.WordTree.ParseTree;\n\t}\n\t\n\t/**\n\t * Add a Pattern to the Parse Tree\n\t * @method addPattern\n\t * @param {Object} pTree - A node on the parse tree to push the characters into\n\t * @param {string} pPattern - The string to add to the tree\n\t * @param {number} pIndex - callback function\n\t * @return {bool} True if adding the pattern was successful\n\t */\n\taddPattern(pPatternStart, pPatternEnd, pParser)\n\t{\n\t\treturn this.WordTree.addPattern(pPatternStart, pPatternEnd, pParser);\n\t}\n\t\n\t/**\n\t * Parse a string with the existing parse tree\n\t * @method parseString\n\t * @param {string} pString - The string to parse\n\t * @return {string} The result from the parser\n\t */\n\tparseString(pString)\n\t{\n\t\treturn this.StringParser.parseString(pString, this.ParseTree);\n\t}\n}\n\nmodule.exports = Precedent;\n","/**\n* String Parser\n*\n* @license     MIT\n*\n* @author      Steven Velozo <steven@velozo.com>\n*\n* @description Parse a string, properly processing each matched token in the word tree.\n*/\n\nclass StringParser\n{\n\t/**\n\t * StringParser Constructor\n\t */\n\tconstructor()\n\t{\n\t}\n\t\n\t/**\n\t * Create a fresh parsing state object to work with.\n\t * @method newParserState\n\t * @param {Object} pParseTree - A node on the parse tree to begin parsing from (usually root)\n\t * @return {Object} A new parser state object for running a character parser on\n\t * @private\n\t */\n\tnewParserState (pParseTree)\n\t{\n\t\treturn (\n\t\t{\n\t\t    ParseTree: pParseTree,\n\n\t\t\tOutput: '',\n\t\t\tOutputBuffer: '',\n\n\t\t\tPattern: false,\n\n\t\t\tPatternMatch: false,\n\t\t\tPatternMatchOutputBuffer: ''\n\t\t});\n\t}\n\t\t\n\t/**\n\t * Assign a node of the parser tree to be the next potential match.\n\t * If the node has a PatternEnd property, it is a valid match and supercedes the last valid match (or becomes the initial match).\n\t * @method assignNode\n\t * @param {Object} pNode - A node on the parse tree to assign\n\t * @param {Object} pParserState - The state object for the current parsing task\n\t * @private\n\t */\n\tassignNode (pNode, pParserState)\n\t{\n\t\tpParserState.PatternMatch = pNode;\n\n\t\t// If the pattern has a END we can assume it has a parse function...\n\t\tif (pParserState.PatternMatch.hasOwnProperty('PatternEnd'))\n\t\t{\n\t\t\t// ... this is the legitimate start of a pattern.\n\t\t\tpParserState.Pattern = pParserState.PatternMatch;\n\t\t}\n\t}\n\t\n\t/**\n\t * Append a character to the output buffer in the parser state.\n\t * This output buffer is used when a potential match is being explored, or a match is being explored.\n\t * @method appendOutputBuffer\n\t * @param {string} pCharacter - The character to append\n\t * @param {Object} pParserState - The state object for the current parsing task\n\t * @private\n\t */\n\tappendOutputBuffer (pCharacter, pParserState)\n\t{\n\t\tpParserState.OutputBuffer += pCharacter;\n\t}\n\t\n\t/**\n\t * Flush the output buffer to the output and clear it.\n\t * @method flushOutputBuffer\n\t * @param {Object} pParserState - The state object for the current parsing task\n\t * @private\n\t */\n\tflushOutputBuffer (pParserState)\n\t{\n\t\tpParserState.Output += pParserState.OutputBuffer;\n\t\tpParserState.OutputBuffer = '';\n\t}\n\n\t\n\t/**\n\t * Check if the pattern has ended.  If it has, properly flush the buffer and start looking for new patterns.\n\t * @method checkPatternEnd\n\t * @param {Object} pParserState - The state object for the current parsing task\n\t * @private\n\t */\n\tcheckPatternEnd (pParserState)\n\t{\n\t\tif ((pParserState.OutputBuffer.length >= pParserState.Pattern.PatternEnd.length+pParserState.Pattern.PatternStart.length) && \n\t\t\t(pParserState.OutputBuffer.substr(-pParserState.Pattern.PatternEnd.length) === pParserState.Pattern.PatternEnd))\n\t\t{\n\t\t\t// ... this is the end of a pattern, cut off the end tag and parse it.\n\t\t\t// Trim the start and end tags off the output buffer now\n\t\t\tpParserState.OutputBuffer = pParserState.Pattern.Parse(pParserState.OutputBuffer.substr(pParserState.Pattern.PatternStart.length, pParserState.OutputBuffer.length - (pParserState.Pattern.PatternStart.length+pParserState.Pattern.PatternEnd.length)));\n\t\t\t// Flush the output buffer.\n\t\t\tthis.flushOutputBuffer(pParserState);\n\t\t\t// End pattern mode\n\t\t\tpParserState.Pattern = false;\n\t\t\tpParserState.PatternMatch = false;\n\t\t}\n\t}\n\t\n\t/**\n\t * Parse a character in the buffer.\n\t * @method parseCharacter\n\t * @param {string} pCharacter - The character to append\n\t * @param {Object} pParserState - The state object for the current parsing task\n\t * @private\n\t */\n\tparseCharacter (pCharacter, pParserState)\n\t{\n\t\t// (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....\n\t\tif (!pParserState.PatternMatch && pParserState.ParseTree.hasOwnProperty(pCharacter))\n\t\t{\n\t\t\t// ... assign the node as the matched node.\n\t\t\tthis.assignNode(pParserState.ParseTree[pCharacter], pParserState);\n\t\t\tthis.appendOutputBuffer(pCharacter, pParserState);\n\t\t}\n\t\t// (2) If we are in a pattern match (actively seeing if this is part of a new pattern token)\n\t\telse if (pParserState.PatternMatch)\n\t\t{\n\t\t\t// If the pattern has a subpattern with this key\n\t\t\tif (pParserState.PatternMatch.hasOwnProperty(pCharacter))\n\t\t\t{\n\t\t\t\t// Continue matching patterns.\n\t\t\t\tthis.assignNode(pParserState.PatternMatch[pCharacter], pParserState);\n\t\t\t}\n\t\t\tthis.appendOutputBuffer(pCharacter, pParserState);\n\t\t\tif (pParserState.Pattern)\n\t\t\t{\n\t\t\t\t// ... Check if this is the end of the pattern (if we are matching a valid pattern)...\n\t\t\t\tthis.checkPatternEnd(pParserState);\n\t\t\t}\n\t\t}\n\t\t// (3) If we aren't in a pattern match or pattern, and this isn't the start of a new pattern (RAW mode)....\n\t\telse\n\t\t{\n\t\t\tpParserState.Output += pCharacter;\n\t\t}\n\t}\n\t\n\t/**\n\t * Parse a string for matches, and process any template segments that occur.\n\t * @method parseString\n\t * @param {string} pString - The string to parse.\n\t * @param {Object} pParseTree - The parse tree to begin parsing from (usually root)\n\t */\n\tparseString (pString, pParseTree)\n\t{\n\t\tlet tmpParserState = this.newParserState(pParseTree);\n\n\t\tfor (var i = 0; i < pString.length; i++)\n\t\t{\n\t\t\t// TODO: This is not fast.\n\t\t\tthis.parseCharacter(pString[i], tmpParserState);\n\t\t}\n\t\t\n\t\tthis.flushOutputBuffer(tmpParserState);\n\t\t\n\t\treturn tmpParserState.Output;\n\t}\n}\n\nmodule.exports = StringParser;\n","/**\n* Word Tree\n*\n* @license     MIT\n*\n* @author      Steven Velozo <steven@velozo.com>\n*\n* @description Create a tree (directed graph) of Javascript objects, one character per object.\n*/\n\nclass WordTree\n{\n\t/**\n\t * WordTree Constructor\n\t */\n\tconstructor()\n\t{\n\t\tthis.ParseTree = {};\n\t}\n\t\n\t/** \n\t * Add a child character to a Parse Tree node\n\t * @method addChild\n\t * @param {Object} pTree - A parse tree to push the characters into\n\t * @param {string} pPattern - The string to add to the tree\n\t * @param {number} pIndex - callback function\n\t * @returns {Object} The resulting leaf node that was added (or found)\n\t * @private\n\t */\n\taddChild (pTree, pPattern, pIndex)\n\t{\n\t\tif (pIndex > pPattern.length)\n\t\t\treturn pTree;\n\t\t\n\t\tif (!pTree.hasOwnProperty(pPattern[pIndex]))\n\t\t\tpTree[pPattern[pIndex]] = {};\n\t\t\n\t\treturn pTree[pPattern[pIndex]];\n\t}\n\t\n\t/** Add a Pattern to the Parse Tree\n\t * @method addPattern\n\t * @param {Object} pTree - A node on the parse tree to push the characters into\n\t * @param {string} pPattern - The string to add to the tree\n\t * @param {number} pIndex - callback function\n\t * @return {bool} True if adding the pattern was successful\n\t */\n\taddPattern (pPatternStart, pPatternEnd, pParser)\n\t{\n\t\tif (pPatternStart.length < 1)\n\t\t\treturn false;\n\n\t\tlet tmpLeaf = this.ParseTree;\n\n\t\t// Add the tree of leaves iteratively\n\t\tfor (var i = 0; i < pPatternStart.length; i++)\n\t\t\ttmpLeaf = this.addChild(tmpLeaf, pPatternStart, i);\n\n\t\ttmpLeaf.PatternStart = pPatternStart;\n\t\ttmpLeaf.PatternEnd = ((typeof(pPatternEnd) === 'string') && (pPatternEnd.length > 0)) ? pPatternEnd : pPatternStart;\n\t\ttmpLeaf.Parse = (typeof(pParser) === 'function') ? pParser : \n\t\t\t\t\t\t(typeof(pParser) === 'string') ? () => { return pParser; } :\n\t\t\t\t\t\t(pData) => { return pData; };\n\n\t\treturn true;\n\t}\n}\n\nmodule.exports = WordTree;\n"]}

package/.config/luxury-extras/.vscode/launch.json

@@ -0,0 +1,46 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch Debug Harness",
+            "type": "pwa-node",
+            "request": "launch",
+            "outputCapture": "std",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/debug/Harness.js",
+            "presentation": {
+                "hidden": false,
+                "group": "",
+                "order": 1
+            }
+        },
+        {
+            "name": "Mocha Tests",
+            "args": [
+                "-u",
+                "tdd",
+                "--timeout",
+                "999999",
+                "--colors",
+                "${workspaceFolder}/test"
+            ],
+            "internalConsoleOptions": "openOnSessionStart",
+            "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
+            "request": "launch",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "type": "pwa-node",
+            "presentation": {
+                "hidden": false,
+                "group": "",
+                "order": 2
+            }
+        }
+    ]
+}

package/.config/luxury-extras/Dockerfile_LUXURYCode

@@ -0,0 +1,39 @@
+# Use the codercom/code-server image
+FROM codercom/code-server:latest
+MAINTAINER steven velozo
+
+VOLUME /home/coder/.config
+VOLUME /home/coder/.vscode
+
+RUN echo "...installing debian dependencies..."
+RUN sudo apt update
+RUN sudo apt install vim curl tmux -y
+
+RUN echo "Building development image..."
+
+RUN echo "...installing vscode extensions..."
+RUN code-server --install-extension ritwickdey.LiveServer \
+    code-server --install-extension hbenl.vscode-mocha-test-adapter \
+    code-server --install-extension hbenl.vscode-test-explorer \
+    code-server --install-extension hbenl.test-adapter-converter \
+    code-server --install-extension daylerees.rainglow \
+    code-server --install-extension oderwat.indent-rainbow
+
+RUN echo "...mapping library specific volumes..."
+# Volume mappings for code
+VOLUME /home/coder/YOURLIBRARYNAMEHERE
+# VOLUME /home/coder/YOURLIBRARYNAMEHERE/node_modules
+
+SHELL ["/bin/bash", "-c"]
+USER coder
+
+RUN echo "...installing node version manager..."
+# Because there is a .bashrc chicken/egg problem, we will create one here to simulate logging in.  This is not great.
+RUN touch ~/.bashrc && chmod +x ~/.bashrc
+RUN curl https://raw.githubusercontent.com/creationix/nvm/master/install.sh | bash
+
+RUN echo "...installing node version 14 as the default..."
+RUN . ~/.nvm/nvm.sh && source ~/.bashrc && nvm install 14
+RUN . ~/.nvm/nvm.sh && source ~/.bashrc && nvm alias default 14
+
+WORKDIR /home/coder/YOURLIBRARYNAMEHERE