fable 3.1.4 → 3.1.7

package/example_applications/mathematical_playground/Math-Solver-Harness.js

@@ -27,27 +27,27 @@ _Fable.log.info(`Beginning Run-through for Set of Test Expressions....`);
 // An array of equations with expected values
 let _Equations = require(`./Equations.json`);
 // The application state is a plain javascript object we pass into the solver to pull variables from
-let _AppData = require(`./AppData.json`);
-// The manifest is a Manyfest which describes hashes for complex addresses in the application state object
-// For example you can't use "Student[0].Age" as a variable in the expression
-// ...but you can use "Student[0].Age" as an address in the manifest with a hash of "StudentAge"
-// ...and then reference "StudentAge" in the expression.
-let tmpManifestConfiguration = { "Scope":"None", "Descriptors":[] };
-let tmpManifest = _Fable.newManyfest(tmpManifestConfiguration);
-// Run each expression in the Equations.json file through the expression parser.
-for (let i = 0; i < _Equations.Expressions.length; i++)
-{
-	let tmpResultObject = {};
-	let tmpResultValue = _ExpressionParser.solve(_Equations.Expressions[i].Equation, _AppData, tmpResultObject, tmpManifest);
-	console.log(`Expression [${i}]: [${_Equations.Expressions[i].Equation}] ==> ${tmpResultValue}`);
-	console.log(`           Expected: ${_Equations.Expressions[i].ExpectedResult}`);
-	//_Fable.ExpressionParser.Messaging.logFunctionOutcome(tmpResultObject);
+// let _AppData = require(`./AppData.json`);
+// // The manifest is a Manyfest which describes hashes for complex addresses in the application state object
+// // For example you can't use "Student[0].Age" as a variable in the expression
+// // ...but you can use "Student[0].Age" as an address in the manifest with a hash of "StudentAge"
+// // ...and then reference "StudentAge" in the expression.
+// let tmpManifestConfiguration = { "Scope":"None", "Descriptors":[] };
+// let tmpManifest = _Fable.newManyfest(tmpManifestConfiguration);
+// // Run each expression in the Equations.json file through the expression parser.
+// for (let i = 0; i < _Equations.Expressions.length; i++)
+// {
+// 	let tmpResultObject = {};
+// 	let tmpResultValue = _ExpressionParser.solve(_Equations.Expressions[i].Equation, _AppData, tmpResultObject, tmpManifest);
+// 	console.log(`Expression [${i}]: [${_Equations.Expressions[i].Equation}] ==> ${tmpResultValue}`);
+// 	console.log(`           Expected: ${_Equations.Expressions[i].ExpectedResult}`);
+// 	//_Fable.ExpressionParser.Messaging.logFunctionOutcome(tmpResultObject);
 
-	if (tmpResultValue !== _Equations.Expressions[i].ExpectedResult)
-	{
-		console.log(`Error: Equation ${_Equations.Expressions[i].Equation} expected [${_Equations.Expressions[i].ExpectedResult}] but got [${tmpResultValue}]`);
-	}
-}
+// 	if (tmpResultValue !== _Equations.Expressions[i].ExpectedResult)
+// 	{
+// 		console.log(`Error: Equation ${_Equations.Expressions[i].Equation} expected [${_Equations.Expressions[i].ExpectedResult}] but got [${tmpResultValue}]`);
+// 	}
+// }
 
 
 /* * * * * * * * * * * * * * * * *
@@ -60,13 +60,16 @@ let _FruitData = require(`../data/Fruit-Data.json`);
 let _FruitManifestDescription = require(`../data/Fruit-Manyfest.json`);
 let _FruitManifest = _Fable.newManyfest(_FruitManifestDescription);
 
+_Fable.AppData = _FruitData;
 _Fable.log.info(`Beginning Manual Solve with Embedded Fruit Data....`);
 
-// The expression we pass into the solver is just a string
+// // The expression we pass into the solver is just a string
 let tmpExpression = 'HyperMax.HealthIndex = (SUM(Calories) / SUM(Sugar)) * MEDIAN(Fat) + (SQRT(AVG(Protein)) - (PI() + 99))';
+//tmpExpression = `aggregationhistogram("AppData.FruityVice", "family", "nutritions.calories")`;
+tmpExpression = 'Out.Match = FindFirstValueByStringIncludes("AppData.FruityVice", "name", "uria", "id")';
 _Fable.log.info(`Solving tmpExpression: [${tmpExpression}]`);
 
-// This is an object where the parser will write out the results of each phase of the compiler/parser/solver
+// // This is an object where the parser will write out the results of each phase of the compiler/parser/solver
 let tmpExpressionParseOutcome = {};
 let tmpSolverResultsObject = {};
 
@@ -82,7 +85,8 @@ _ExpressionParser.substituteValuesInTokenizedObjects(tmpExpressionParseOutcome.P
 let tmpResultValue = _ExpressionParser.solvePostfixedExpression(tmpExpressionParseOutcome.PostfixSolveList, tmpSolverResultsObject, tmpExpressionParseOutcome, _FruitManifest);
 
 // Now that we have a solved expression and the mapped-in values, show the user the solution
-//_Fable.ExpressionParser.Messaging.logFunctionOutcome(tmpExpressionParseOutcome);
+_Fable.ExpressionParser.Messaging.logFunctionOutcome(tmpExpressionParseOutcome);
+
 
 // Step 6: Look at the results.
 console.log(`Outcome object: ${JSON.stringify(tmpSolverResultsObject)}`);

package/package.json

@@ -1,70 +1,70 @@
 {
-    "name": "fable",
-    "version": "3.1.4",
-    "description": "A service dependency injection, configuration and logging library.",
-    "main": "source/Fable.js",
-    "scripts": {
-        "start": "node source/Fable.js",
-        "coverage": "./node_modules/.bin/nyc --reporter=lcov --reporter=text-lcov ./node_modules/mocha/bin/_mocha -- -u tdd -R spec",
-        "test": "./node_modules/.bin/mocha -u tdd -R spec",
-        "build": "npx quack build",
-        "docker-dev-build": "docker build ./ -f Dockerfile_LUXURYCode -t fable-image:local",
-        "docker-dev-run": "docker run -it -d --name fable-dev -p 30001:8080 -p 38086:8086 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/fable\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" fable-image:local",
-        "docker-dev-shell": "docker exec -it fable-dev /bin/bash",
-        "tests": "./node_modules/mocha/bin/_mocha -u tdd --exit -R spec --grep"
-    },
-    "mocha": {
-        "diff": true,
-        "extension": [
-            "js"
-        ],
-        "package": "./package.json",
-        "reporter": "spec",
-        "slow": "75",
-        "timeout": "5000",
-        "ui": "tdd",
-        "watch-files": [
-            "source/**/*.js",
-            "test/**/*.js"
-        ],
-        "watch-ignore": [
-            "lib/vendor"
-        ]
-    },
-    "browser": {
-        "./source/service/Fable-Service-EnvironmentData.js": "./source/service/Fable-Service-EnvironmentData-Web.js",
-        "./source/service/Fable-Service-FilePersistence.js": "./source/service/Fable-Service-FilePersistence-Web.js"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/stevenvelozo/fable.git"
-    },
-    "keywords": [
-        "entity",
-        "behavior"
+  "name": "fable",
+  "version": "3.1.7",
+  "description": "A service dependency injection, configuration and logging library.",
+  "main": "source/Fable.js",
+  "scripts": {
+    "start": "node source/Fable.js",
+    "coverage": "./node_modules/.bin/nyc --reporter=lcov --reporter=text-lcov ./node_modules/mocha/bin/_mocha -- -u tdd -R spec",
+    "test": "./node_modules/.bin/mocha -u tdd -R spec",
+    "build": "npx quack build",
+    "docker-dev-build": "docker build ./ -f Dockerfile_LUXURYCode -t fable-image:local",
+    "docker-dev-run": "docker run -it -d --name fable-dev -p 30001:8080 -p 38086:8086 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/fable\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" fable-image:local",
+    "docker-dev-shell": "docker exec -it fable-dev /bin/bash",
+    "tests": "./node_modules/mocha/bin/_mocha -u tdd --exit -R spec --grep"
+  },
+  "mocha": {
+    "diff": true,
+    "extension": [
+      "js"
     ],
-    "author": "Steven Velozo <steven@velozo.com> (http://velozo.com/)",
-    "license": "MIT",
-    "bugs": {
-        "url": "https://github.com/stevenvelozo/fable/issues"
-    },
-    "homepage": "https://github.com/stevenvelozo/fable",
-    "devDependencies": {
-        "quackage": "^1.0.41"
-    },
-    "dependencies": {
-        "async.eachlimit": "^0.5.2",
-        "async.waterfall": "^0.5.2",
-        "big.js": "^6.2.2",
-        "cachetrax": "^1.0.4",
-        "cookie": "^0.6.0",
-        "data-arithmatic": "^1.0.7",
-        "dayjs": "^1.11.13",
-        "fable-log": "^3.0.16",
-        "fable-serviceproviderbase": "^3.0.15",
-        "fable-settings": "^3.0.12",
-        "fable-uuid": "^3.0.11",
-        "manyfest": "^1.0.38",
-        "simple-get": "^4.0.1"
-    }
+    "package": "./package.json",
+    "reporter": "spec",
+    "slow": "75",
+    "timeout": "5000",
+    "ui": "tdd",
+    "watch-files": [
+      "source/**/*.js",
+      "test/**/*.js"
+    ],
+    "watch-ignore": [
+      "lib/vendor"
+    ]
+  },
+  "browser": {
+    "./source/service/Fable-Service-EnvironmentData.js": "./source/service/Fable-Service-EnvironmentData-Web.js",
+    "./source/service/Fable-Service-FilePersistence.js": "./source/service/Fable-Service-FilePersistence-Web.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stevenvelozo/fable.git"
+  },
+  "keywords": [
+    "entity",
+    "behavior"
+  ],
+  "author": "Steven Velozo <steven@velozo.com> (http://velozo.com/)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/stevenvelozo/fable/issues"
+  },
+  "homepage": "https://github.com/stevenvelozo/fable",
+  "devDependencies": {
+    "quackage": "^1.0.41"
+  },
+  "dependencies": {
+    "async.eachlimit": "^0.5.2",
+    "async.waterfall": "^0.5.2",
+    "big.js": "^6.2.2",
+    "cachetrax": "^1.0.4",
+    "cookie": "^0.6.0",
+    "data-arithmatic": "^1.0.7",
+    "dayjs": "^1.11.13",
+    "fable-log": "^3.0.16",
+    "fable-serviceproviderbase": "^3.0.15",
+    "fable-settings": "^3.0.12",
+    "fable-uuid": "^3.0.11",
+    "manyfest": "^1.0.38",
+    "simple-get": "^4.0.1"
+  }
 }

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

@@ -157,6 +157,139 @@ class DataFormat extends libFableServiceProviderBase
 			});
 	}
 
+	/**
+	 * Concatenate a list of strings together. Non-strings are excluded.
+	 *
+	 * @param {...string} pStrings - The strings to concatenate
+	 * @return {string}
+	 */
+	concatenateStrings (...pStrings)
+	{
+		return this.joinStrings('', ...pStrings);
+	}
+
+	/**
+	 * Concatenate a list of strings together. Non-strings are excluded.
+	 *
+	 * @param {string} pValueObjectSetAddress - The address of the array of strings to concatenate
+	 * @return {string}
+	 */
+	concatenateStringsInternal (pValueObjectSetAddress)
+	{
+		if (!pValueObjectSetAddress)
+		{
+			return {};
+		}
+
+		let tmpValueObjectSet = this.fable.Utility.getInternalValueByHash(pValueObjectSetAddress);
+		if (!Array.isArray(tmpValueObjectSet))
+		{
+			return tmpValueObjectSet || null;
+		}
+		return this.concatenateStrings(...tmpValueObjectSet);
+	}
+
+	/**
+	 * Join a list of strings together. Non-strings are excluded.
+	 *
+	 * @param {string} pJoin - The string to join with
+	 * @param {...string} pStrings - The strings to join
+	 * @return {string}
+	 */
+	joinStrings (pJoin, ...pStrings)
+	{
+		return pStrings.filter((v) => typeof v === 'string' || typeof v === 'number').join(pJoin);
+	}
+
+	/**
+	 * Joins a list of strings together. Non-strings are excluded.
+	 *
+	 * @param {string} pJoin - The string to join with
+	 * @param {string} pValueObjectSetAddress - The address of the array of values to join
+	 * @return {string}
+	 */
+	joinStringsInternal (pJoin, pValueObjectSetAddress)
+	{
+		if (!pValueObjectSetAddress)
+		{
+			return {};
+		}
+
+		let tmpValueObjectSet = this.fable.Utility.getInternalValueByHash(pValueObjectSetAddress);
+		if (!Array.isArray(tmpValueObjectSet))
+		{
+			return tmpValueObjectSet || null;
+		}
+		return this.joinStrings(pJoin, ...tmpValueObjectSet);
+	}
+
+
+	/**
+	 * Concatenate a list of values together into a string.
+	 *
+	 * @param {...any} pValues - The strings to concatenate
+	 * @return {string}
+	 */
+	concatenateStringsRaw (...pValues)
+	{
+		return this.joinStringsRaw('', ...pValues);
+	}
+
+	/**
+	 * Concatenate a list of values together into a string.
+	 *
+	 * @param {string} pValueObjectSetAddress - The address of the array of values to concatenate
+	 * @return {string}
+	 */
+	concatenateStringsRawInternal (pValueObjectSetAddress)
+	{
+		if (!pValueObjectSetAddress)
+		{
+			return {};
+		}
+
+		let tmpValueObjectSet = this.fable.Utility.getInternalValueByHash(pValueObjectSetAddress);
+		if (!Array.isArray(tmpValueObjectSet))
+		{
+			return tmpValueObjectSet || null;
+		}
+		return this.concatenateStringsRaw(...tmpValueObjectSet);
+	}
+
+	/**
+	 * Join a list of values together into a string.
+	 *
+	 * @param {string} pJoin - The string to join with
+	 * @param {...any} pValues - The strings to join
+	 * @return {string}
+	 */
+	joinStringsRaw (pJoin, ...pValues)
+	{
+		return pValues.map(String).join(pJoin);
+	}
+
+	/**
+	 * Joins a list of values together into a string.
+	 *
+	 * @param {string} pJoin - The string to join with
+	 * @param {string} pValueObjectSetAddress - The address of the array of values to join
+	 * @return {string}
+	 */
+	joinStringsRawInternal (pJoin, pValueObjectSetAddress)
+	{
+		if (!pValueObjectSetAddress)
+		{
+			return {};
+		}
+
+		let tmpValueObjectSet = this.fable.Utility.getInternalValueByHash(pValueObjectSetAddress);
+		if (!Array.isArray(tmpValueObjectSet))
+		{
+			return tmpValueObjectSet || null;
+		}
+		return this.joinStringsRaw(pJoin, ...tmpValueObjectSet);
+	}
+
 	/**
 	 * Clean wrapping characters if they exist consistently around the string.  If they do not, the string is returned unchanged.
 	 *
@@ -844,4 +977,4 @@ class DataFormat extends libFableServiceProviderBase
 	}
 }
 
-module.exports = DataFormat;
+module.exports = DataFormat;

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-ExpressionTokenizer.js

@@ -35,6 +35,8 @@ class ExpressionTokenizer extends libExpressionParserOperationBase
 		 *  - Token
 		 *    : could be an operator e.g. "+", "-", "*", "/"
 		 *    : could be a parenthesis e.g. "(", ")"
+		 *  - String
+		 *    : Wrapped in double quotes e.g. "Hello World", "This is a test", etc.
 		 */
 		let tmpCurrentTokenType = false;
 		let tmpCurrentToken = '';
@@ -44,7 +46,7 @@ class ExpressionTokenizer extends libExpressionParserOperationBase
 
 			// [ WHITESPACE ]
 			// 1. Space breaks tokens except when we're in an address that's been scoped by a {}
-			if ((tmpCharacter === ' ') && (tmpCurrentTokenType !== 'StateAddress'))
+			if ((tmpCharacter === ' ') && ((tmpCurrentTokenType !== 'StateAddress') && (tmpCurrentTokenType !== 'String')))
 			{
 				if (tmpCurrentToken.length > 0)
 				{
@@ -55,13 +57,18 @@ class ExpressionTokenizer extends libExpressionParserOperationBase
 				continue;
 			}
 
-			// [ STATE ADDRESS BLOCKS ]
+			// [ STATE ADDRESS AND STRING BLOCKS ]
 			// 2. If we're in an address, we keep going until we hit the closing brace
 			if ((tmpCurrentTokenType === 'StateAddress') && (tmpCharacter !== '}'))
 			{
 				tmpCurrentToken += tmpCharacter;
 				continue;
 			}
+			if ((tmpCurrentTokenType === 'String') && (tmpCharacter !== '"'))
+			{
+				tmpCurrentToken += tmpCharacter;
+				continue;
+			}
 			// 3. If we're in an address and we hit the closing brace, we close the token, push it and reset
 			if ((tmpCurrentTokenType === 'StateAddress') && (tmpCharacter === '}'))
 			{
@@ -71,6 +78,14 @@ class ExpressionTokenizer extends libExpressionParserOperationBase
 				tmpCurrentTokenType = false;
 				continue;
 			}
+			if ((tmpCurrentTokenType === 'String') && (tmpCharacter === '"'))
+			{
+				tmpCurrentToken += tmpCharacter;
+				tmpResults.RawTokens.push(tmpCurrentToken);
+				tmpCurrentToken = '';
+				tmpCurrentTokenType = false;
+				continue;
+			}
 			// 4. If we're not in an address and we hit a closing brace it's a problem
 			//    TODO: Should we just ignore it?  We do at the moment.
 			if (tmpCharacter == '}')
@@ -97,6 +112,17 @@ class ExpressionTokenizer extends libExpressionParserOperationBase
 				tmpCurrentToken = tmpCharacter;
 				continue;
 			}
+			if ((tmpCurrentTokenType !== 'String') && (tmpCharacter == '"'))
+			{
+				if (tmpCurrentToken.length > 0)
+				{
+					tmpResults.RawTokens.push(tmpCurrentToken);
+				}
+				tmpCurrentToken = '';
+				tmpCurrentTokenType = 'String';
+				tmpCurrentToken = tmpCharacter;
+				continue;
+			}
 
 			// [ TOKENS ]
 			if (tmpCharacter in this.ExpressionParser.tokenRadix)

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-FunctionMap.json

@@ -129,6 +129,36 @@
 		"Address": "fable.Utility.getInternalValueByHash"
 	},
 
+	"findfirstvaluebyexactmatch": {
+		"Name": "find + map on array of objects?",
+		"Address": "fable.Utility.findFirstValueByExactMatchInternal"
+	},
+
+	"findfirstvaluebystringincludes": {
+		"Name": "find + map on array of objects?",
+		"Address": "fable.Utility.findFirstValueByStringIncludesInternal"
+	},
+
+	"concat": {
+		"Name": "concatenate an array of values and output a string",
+		"Address": "fable.DataFormat.concatenateStringsInternal"
+	},
+
+	"concatraw": {
+		"Name": "concatenate an array of values and output a string",
+		"Address": "fable.DataFormat.concatenateStringsRawInternal"
+	},
+
+	"join": {
+		"Name": "join an array of values and output a string",
+		"Address": "fable.DataFormat.joinStringsInternal"
+	},
+
+	"joinraw": {
+		"Name": "join an array of values and output a string",
+		"Address": "fable.DataFormat.joinStringsRawInternal"
+	},
+
 	"entryinset": {
 		"Name": "Entry in Set",
 		"Address": "fable.Math.entryInSet"
@@ -220,4 +250,4 @@
 		"Name": "Create Value Object by Hashes",
 		"Address": "fable.Utility.createValueObjectByHashes"
 	}
-}
+}

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

@@ -371,6 +371,31 @@ class FableServiceUtility extends libFableServiceBase
 		return undefined;
 	}
 
+	/**
+	 * Find the first value in an object that contains a specific value
+	 * @param {string} pFableAddress - The address in the fable object to pull the value from
+	 * @param {string} pValueToMatchAddress - The manyfest hash/address of the value to match
+	 * @param {string} pValueToMatch - The value to match
+	 * @param {string} pValueAddress - The manyfest hash/address of the value to return
+	 * @returns {any} - The value from the object
+	 */
+	findFirstValueByStringIncludesInternal(pFableAddress, pValueToMatchAddress, pValueToMatch, pValueAddress)
+	{
+		// Lazily create a manifest if it doesn't exist
+		if (!this.manifest)
+		{
+			this.manifest = this.fable.newManyfest();
+		}
+
+		if (typeof(pFableAddress) != 'string')
+		{
+			return undefined;
+		}
+		let tmpObjectArray = this.manifest.getValueByHash(this.fable, pFableAddress);
+
+		return this.findFirstValueByStringIncludes(tmpObjectArray, pValueToMatchAddress, pValueToMatch, pValueAddress);
+	}
+
 	/**
 	 * Find the first value in an object that contains a specific value
 	 * @param {array} pObjectArray - The array of objects to search
@@ -402,6 +427,31 @@ class FableServiceUtility extends libFableServiceBase
 
 		return undefined;
 	}
+
+	/**
+	 * Find the first value in an object that contains a specific value
+	 * @param {string} pFableAddress - The address in the fable object to pull the value from
+	 * @param {string} pValueToMatchAddress - The manyfest hash/address of the value to match
+	 * @param {string} pValueToMatch - The value to match
+	 * @param {string} pValueAddress - The manyfest hash/address of the value to return
+	 * @returns {any} - The value from the object
+	 */
+	findFirstValueByExactMatchInternal(pFableAddress, pValueToMatchAddress, pValueToMatch, pValueAddress)
+	{
+		// Lazily create a manifest if it doesn't exist
+		if (!this.manifest)
+		{
+			this.manifest = this.fable.newManyfest();
+		}
+
+		if (typeof(pFableAddress) != 'string')
+		{
+			return undefined;
+		}
+		let tmpObjectArray = this.manifest.getValueByHash(this.fable, pFableAddress);
+
+		return this.findFirstValueByExactMatch(tmpObjectArray, pValueToMatchAddress, pValueToMatch, pValueAddress);
+	}
 }
 
 module.exports = FableServiceUtility;

package/test/DataFormat-StringNumberFormatting_tests.js

@@ -136,5 +136,72 @@ suite
 				);
 			}
 		);
+		suite
+		(
+			'String Manipulation',
+			()=>
+			{
+				test
+				(
+					'concatenateStrings concatenates an array of string-like objects',
+					() =>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataFormat = testFable.services.DataFormat;
+						Expect(_DataFormat
+							.concatenateStrings(undefined, 'test', 123))
+							.to.equal('test123');
+						Expect(_DataFormat
+							.concatenateStrings('waffle', { }, null))
+							.to.equal('waffle');
+					}
+				);
+				test
+				(
+					'concatenateStringsRaw stringifies then concatenates an array of anything',
+					() =>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataFormat = testFable.services.DataFormat;
+						Expect(_DataFormat
+							.concatenateStringsRaw(undefined, 'test', 123))
+							.to.equal('undefinedtest123');
+						Expect(_DataFormat
+							.concatenateStringsRaw('waffle', { }, null))
+							.to.equal('waffle[object Object]null');
+					}
+				);
+				test
+				(
+					'joinStrings joins an array of string-like objects',
+					() =>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataFormat = testFable.services.DataFormat;
+						Expect(_DataFormat
+							.joinStrings('/', undefined, 'test', 123))
+							.to.equal('test/123');
+						Expect(_DataFormat
+							.joinStrings('/', 'waffle', { }, null))
+							.to.equal('waffle');
+					}
+				);
+				test
+				(
+					'joinStringsRaw stringifies then joins an array of anything',
+					() =>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataFormat = testFable.services.DataFormat;
+						Expect(_DataFormat
+							.joinStringsRaw('/', undefined, 'test', 123))
+							.to.equal('undefined/test/123');
+						Expect(_DataFormat
+							.joinStringsRaw('/', 'waffle', { }, null))
+							.to.equal('waffle/[object Object]/null');
+					}
+				);
+			}
+		);
 	}
 );

package/test/ExpressionParser_tests.js

@@ -45,6 +45,12 @@ suite
 						let complexTokenizedResultsDoubleWidthOperators = _Parser.tokenize('SpecialValue ?= 5+3 - sqrt(75 / (3 + {Depth}) * Width)^ 3');
 						Expect(complexTokenizedResultsDoubleWidthOperators.length).to.equal(20);
 						Expect(complexTokenizedResultsDoubleWidthOperators).to.deep.equal(['SpecialValue', '?=', '5', '+', '3', '-', 'sqrt', '(', '75', '/', '(', '3', '+', '{Depth}', ')', '*', 'Width', ')', '^', '3']);
+
+						let tokenizedWithSymbologyInQuotes = _Parser.tokenize('5 + 2 * "Hello World"');
+						Expect(tokenizedWithSymbologyInQuotes.length).to.equal(5);
+						Expect(tokenizedWithSymbologyInQuotes).to.deep.equal(['5', '+', '2', '*', '"Hello World"']);
+						// TODO: refresh on the tokenization process and see if this is a valid test
+						//Expect(tmpResultObject.RawExpression).to.equal('5 + 2');
 						return fDone();
 					}
 				);
@@ -375,5 +381,43 @@ suite
 				);
 			}
 		);
+		suite
+		(
+			'Data Expressions',
+			function()
+			{
+				test
+				(
+					'Concatenates Strings',
+					() =>
+					{
+						let testFable = new libFable();
+
+						//FIXME: would be nicer to have a way of transorming the city object via the solver
+						let testCityData = require('./data/cities.json');
+						testFable.AppData = { CityNames: testCityData.slice(0, 4).map((c) => c.city) };
+						testFable.AppData.CityNames[2] = { };
+
+						// Now through the solver
+
+						let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+						let tmpResultsObject = {};
+						let tmpDestinationObject = {};
+						
+						_Parser.solve('Names = concat("AppData.CityNames")', this.fable, tmpResultsObject, false, tmpDestinationObject);
+						Expect(tmpDestinationObject.Names).to.equal('New YorkLos AngelesHouston');
+
+						_Parser.solve('RawNames = concatRaw("AppData.CityNames")', this.fable, tmpResultsObject, false, tmpDestinationObject);
+						Expect(tmpDestinationObject.RawNames).to.equal('New YorkLos Angeles[object Object]Houston');
+
+						_Parser.solve('JoinedNames = join(", ", "AppData.CityNames")', this.fable, tmpResultsObject, false, tmpDestinationObject);
+						Expect(tmpDestinationObject.JoinedNames).to.equal('New York, Los Angeles, Houston');
+
+						_Parser.solve('RawJoinedNames = joinRaw(" ", "AppData.CityNames")', this.fable, tmpResultsObject, false, tmpDestinationObject);
+						Expect(tmpDestinationObject.RawJoinedNames).to.equal('New York Los Angeles [object Object] Houston');
+					}
+				);
+			}
+		);
 	}
-);
+);