fable 3.0.20 → 3.0.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fable",
-  "version": "3.0.20",
+  "version": "3.0.22",
   "description": "An entity behavior management and API bundling library.",
   "main": "source/Fable.js",
   "scripts": {
@@ -63,8 +63,10 @@
   "dependencies": {
     "async.eachlimit": "^0.5.2",
     "async.waterfall": "^0.5.2",
+    "data-arithmatic": "^1.0.3",
     "fable-log": "^3.0.6",
     "fable-settings": "^3.0.3",
-    "fable-uuid": "^3.0.2"
+    "fable-uuid": "^3.0.2",
+    "precedent": "^1.0.9"
   }
 }

package/source/Fable-Service-DataArithmatic.js

@@ -0,0 +1,16 @@
+const libFableServiceBase = require('./Fable-ServiceProviderBase.js');
+const libDataArithmatic = require('data-arithmatic');
+
+class FableServiceDataArithmatic extends libFableServiceBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'DataArithmatic';
+
+        this._DataArithmaticLibrary = new libDataArithmatic();
+	}
+}
+
+module.exports = FableServiceDataArithmatic;

package/source/Fable-Service-MetaTemplate.js

@@ -0,0 +1,41 @@
+const libFableServiceBase = require('./Fable-ServiceProviderBase.js');
+
+const libPrecedent = require('precedent');
+
+class FableServiceMetaTemplate extends libFableServiceBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'MetaTemplate';
+
+        this._MetaTemplateLibrary = new libPrecedent(this.options);
+	}
+
+	/**
+	 * 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
+	 */
+	addPattern(pPatternStart, pPatternEnd, pParser)
+	{
+		return this._MetaTemplateLibrary.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
+	 */
+	parseString(pString)
+	{
+		return this._MetaTemplateLibrary.parseString(pString, this.ParseTree);
+	}
+}
+
+module.exports = FableServiceMetaTemplate;

package/source/{Fable-Utility.js → Fable-Service-Utility.js}

@@ -1,12 +1,24 @@
+const libFableServiceBase = require('./Fable-ServiceProviderBase.js');
+
+
 // TODO: These are still pretty big -- consider the smaller polyfills
 const libAsyncWaterfall = require('async.waterfall');
 const libAsyncEachLimit = require('async.eachlimit');
 
-class FableUtility
+class FableServiceUtility extends libFableServiceBase
 {
-	constructor(pFable)
+	// Underscore and lodash have a behavior, _.template, which compiles a
+	// string-based template with code snippets into simple executable pieces,
+	// with the added twist of returning a precompiled function ready to go.
+	//
+	// NOTE: This does not implement underscore escape expressions
+	// NOTE: This does not implement underscore magic browser variable assignment
+	//
+	// This is an implementation of that.
+	// TODO: Make this use precedent, add configuration, add debugging.
+	constructor(pFable, pOptions, pServiceHash)
 	{
-		this.fable = pFable;
+        super(pFable, pOptions, pServiceHash);
 
 		this.templates = {};
 
@@ -68,4 +80,4 @@ class FableUtility
 	}
 }
 
-module.exports = FableUtility;
+module.exports = FableServiceUtility;

package/source/Fable.js

@@ -7,10 +7,12 @@ const libFableSettings = require('fable-settings');
 const libFableUUID = require('fable-uuid');
 const libFableLog = require('fable-log');
 
-const libFableUtility = require('./Fable-Utility.js');
 const libFableServiceManager = require('./Fable-ServiceManager.js');
 
+const libFableServiceDataArithmatic = require('./Fable-Service-DataArithmatic.js');
 const libFableServiceTemplate = require('./Fable-Service-Template.js');
+const libFableServiceMetaTemplate = require('./Fable-Service-MetaTemplate.js');
+const libFableServiceUtility = require('./Fable-Service-Utility.js');
 
 const libFableOperation = require('./Fable-Operation.js');
 
@@ -28,9 +30,6 @@ class Fable
 		this.log = new libFableLog(this.settingsManager.settings);
 		this.log.initialize();
 
-		// Built-in utility belt functions
-		this.Utility = new libFableUtility(this);
-
 		// Built-in dependencies
 		this.Dependencies = (
 			{
@@ -42,8 +41,23 @@ class Fable
 
 		this.serviceManager = new libFableServiceManager(this);
 
+		// Initialize and instantiate the default baked-in Data Arithmatic service
+		this.serviceManager.addServiceType('DataArithmatic', libFableServiceDataArithmatic);
+		this.fable.serviceManager.instantiateServiceProvider('DataArithmatic', {}, 'Default-Service-DataArithmatic');
+		// This service is passing through the data arithmatic library
+		this.DataArithmatic = this.serviceManager.defaultServices.DataArithmatic._DataArithmaticLibrary;
+
+		// Initialize the template service
 		this.serviceManager.addServiceType('Template', libFableServiceTemplate);
 
+		// Initialize the metatemplate service
+		this.serviceManager.addServiceType('MetaTemplate', libFableServiceMetaTemplate);
+
+		// Initialize and instantiate the default baked-in Utility service
+		this.serviceManager.addServiceType('Utility', libFableServiceUtility)
+		this.fable.serviceManager.instantiateServiceProvider('Utility', {}, 'Default-Service-Utility');
+		this.Utility = this.serviceManager.defaultServices.Utility;
+
 		this.services = this.serviceManager.services;
 		this.defaultServices = this.serviceManager.defaultServices;
 	}

package/test/FableDataArithmatic_tests.js

@@ -0,0 +1,223 @@
+/**
+* Unit tests for Fable's DataArithmatic service
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var libFable = require('../source/Fable.js');
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+suite
+(
+	'DataArithmatic String',
+	function()
+	{
+		setup (()=> {} );
+
+		suite
+		(
+			'Manipulate Strings',
+			()=>
+			{
+				test
+				(
+					'Reverse a String',
+					(fTestComplete)=>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataArithmatic = testFable.DataArithmatic;
+						Expect(_DataArithmatic
+							.stringReverse('Dogs'))
+							.to.equal('sgoD');
+						Expect(_DataArithmatic
+							.stringReverse('Florence and the Machine'))
+							.to.equal('enihcaM eht dna ecnerolF');
+						return fTestComplete();
+					}
+				)
+				test
+				(
+					'Insecure String Hash',
+					(fTestComplete)=>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataArithmatic = testFable.DataArithmatic;
+						Expect(_DataArithmatic
+							.insecureStringHash('Dogs'))
+							.to.equal('HSH2135767');
+						Expect(_DataArithmatic
+							.insecureStringHash('Dogs1'))
+							.to.equal('HSH66208826');
+						Expect(_DataArithmatic
+							.insecureStringHash('This string is longer'))
+							.to.equal('HSH53260210');
+						// This repeat is intentional, to ensure stable hash generation after multiple runs.
+						Expect(_DataArithmatic
+							.insecureStringHash('Dogs'))
+							.to.equal('HSH2135767');
+						return fTestComplete();
+					}
+				)
+				test
+				(
+					'Clean wrapping characters from a valid enclosure.',
+					(fTestComplete)=>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataArithmatic = testFable.DataArithmatic;
+						// Test the enclosure cleaning function
+						Expect(_DataArithmatic
+							.cleanEnclosureWrapCharacters('`', '`Dogs`'))
+							.to.equal('Dogs');
+						// Tests a cleaning where the enclosure is not wrapped with the expected character
+						Expect(_DataArithmatic
+							.cleanEnclosureWrapCharacters('"', '`Cats`'))
+							.to.equal('`Cats`');
+						// Tests a cleaning where the enclosure is not wrapped with the expected character
+						Expect(_DataArithmatic
+							.cleanEnclosureWrapCharacters('"', '"Dogs"'))
+							.to.equal('Dogs');
+						// Test cleaning an enclosure with multiple enclosures of the same type which are expected to stay intact
+						Expect(_DataArithmatic
+							.cleanEnclosureWrapCharacters('[', '[Array[with]weird other] Dogs in it['))
+							.to.equal('Array[with]weird other] Dogs in it');
+						// Test cleaning a string where the enclosure character is on one side but not the other
+						Expect(_DataArithmatic
+							.cleanEnclosureWrapCharacters('"', '"Dogs'))
+							.to.equal('"Dogs');
+						// Test cleaning a string where the enclosure character is on one side but not the other
+						Expect(_DataArithmatic
+							.cleanEnclosureWrapCharacters('"', 'Dogs"'))
+							.to.equal('Dogs"');
+						return fTestComplete();
+					}
+				);
+				test
+				(
+					'Test if a string starts with a given substring - Javascript Engine startsWith',
+					(fTestComplete)=>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataArithmatic = testFable.DataArithmatic;
+						Expect(_DataArithmatic
+							.stringStartsWith('Dogs', 'Do'))
+							.to.equal(true);
+						Expect(_DataArithmatic
+							.stringStartsWith('Bats', 'Bats'))
+							.to.equal(true);
+						Expect(_DataArithmatic
+							.stringStartsWith('Dogs', 'Dogs are cool'))
+							.to.equal(false);
+						Expect(_DataArithmatic
+							.stringStartsWith('Dogs', 'Cats'))
+							.to.equal(false);
+						return fTestComplete();
+					}
+				);
+				test
+				(
+					'Test if a string starts with a given substring - Internal startsWith',
+					(fTestComplete)=>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataArithmatic = testFable.DataArithmatic;
+						_DataArithmatic._UseEngineStringStartsWith = false;
+						Expect(_DataArithmatic
+							.stringStartsWith('Dogs', 'Do'))
+							.to.equal(true);
+						Expect(_DataArithmatic
+							.stringStartsWith('Bats', 'Bats'))
+							.to.equal(true);
+						Expect(_DataArithmatic
+							.stringStartsWith('Dogs', 'Dogs are cool'))
+							.to.equal(false);
+						Expect(_DataArithmatic
+							.stringStartsWith('Dogs', 'Cats'))
+							.to.equal(false);
+						return fTestComplete();
+					}
+				);
+				test
+				(
+					'Test if a string ends with a given substring - Javascript Engine endsWith',
+					(fTestComplete)=>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataArithmatic = testFable.DataArithmatic;
+						Expect(_DataArithmatic
+							.stringEndsWith('Dogs', 'gs'))
+							.to.equal(true);
+						Expect(_DataArithmatic
+							.stringEndsWith('Bats', 'Bats'))
+							.to.equal(true);
+						Expect(_DataArithmatic
+							.stringEndsWith('Dogs', 'Dogs are cool'))
+							.to.equal(false);
+						Expect(_DataArithmatic
+							.stringEndsWith('Dogs', 'Cats'))
+							.to.equal(false);
+						return fTestComplete();
+					}
+				);
+				test
+				(
+					'Test if a string ends with a given substring - Internal endsWith',
+					(fTestComplete)=>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataArithmatic = testFable.DataArithmatic;
+						_DataArithmatic._UseEngineStringEndsWith = false;
+						Expect(_DataArithmatic
+							.stringEndsWith('Dogs', 'gs'))
+							.to.equal(true);
+						Expect(_DataArithmatic
+							.stringEndsWith('Bats', 'Bats'))
+							.to.equal(true);
+						Expect(_DataArithmatic
+							.stringEndsWith('Dogs', 'Dogs are cool'))
+							.to.equal(false);
+						// We should be able to tell it a midpoint to "end" the string at
+						Expect(_DataArithmatic
+							.stringEndsWith('Start from a median point', 'median', 19))
+							.to.equal(true);
+						Expect(_DataArithmatic
+							.stringEndsWith('Start from a median point', 'median', 20))
+							.to.equal(false);
+						Expect(_DataArithmatic
+							.stringEndsWith('Dogs', 'Cats'))
+							.to.equal(false);
+						return fTestComplete();
+					}
+				);
+				test
+				(
+					'Test cleaning nonalpha characters from a string',
+					(fTestComplete)=>
+					{
+						let testFable = new libFable({LogStreams: false});
+						let _DataArithmatic = testFable.DataArithmatic;
+						Expect(_DataArithmatic
+							.cleanNonAlphaCharacters('Dogs'))
+							.to.equal('Dogs');
+						Expect(_DataArithmatic
+							.cleanNonAlphaCharacters('Dogs are cool'))
+							.to.equal('Dogs_are_cool');
+						Expect(_DataArithmatic
+							.cleanNonAlphaCharacters('Dogs are cool!'))
+							.to.equal('Dogs_are_cool_');
+						// Test cleaning with no character
+						_DataArithmatic._Value_Clean_formatterCleanNonAlpha = '';
+						Expect(_DataArithmatic
+							.cleanNonAlphaCharacters('Dogs are cool!'))
+							.to.equal('Dogsarecool');
+						return fTestComplete();
+					}
+				);
+			}
+		);
+	}
+);

package/test/FableMetaTemplating_tests.js

@@ -0,0 +1,96 @@
+/**
+* Unit tests for Fable
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var libFable = require('../source/Fable.js');
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+
+var loadPrecedentModule = () =>
+{
+	let tmpFable = new libFable();
+	return tmpFable.serviceManager.instantiateServiceProviderWithoutRegistration('MetaTemplate', {});
+};
+
+var configPrecedent = (pModule) =>
+{
+	pModule.addPattern('<%', '%>', 'JUNKED_THIS_DATA');
+	// This one gets the count of the inner string...
+	pModule.addPattern('<%#', '%>', (pData)=>{return pData.length});
+	// Replaces the string with the settings object...
+	pModule.addPattern('<%=', '%>', (pData)=>{return JSON.stringify(pModule.settings);});
+	// This just escapes out pairs of $
+	pModule.addPattern('$');
+};
+
+suite
+(
+	'Fable MetaTemplating',
+	function()
+	{
+		var testFable = false;
+
+		setup
+		(
+			function()
+			{
+			}
+		);
+
+		suite
+		(
+			'MetaTemplating',
+			function()
+			{
+				test
+				(
+					'No Matches...',
+					(fDone) =>
+					{
+						var tmpTestString = 'ABC123';
+						var tmpExpectedResult = tmpTestString;
+						var testPrecedent = loadPrecedentModule();
+						configPrecedent(testPrecedent);
+						var	tmpResult = testPrecedent.parseString(tmpTestString);
+						Expect(tmpResult).to.equal(tmpExpectedResult);
+						fDone();
+					}
+				);
+				test
+				(
+					'Count function...',
+					(fDone) =>
+					{
+						var tmpTestString = 'There are <%#0123456789%> characters in here';
+						var tmpExpectedResult = 'There are 10 characters in here';
+						var testPrecedent = loadPrecedentModule();
+						configPrecedent(testPrecedent);
+						var	tmpResult = testPrecedent.parseString(tmpTestString);
+						Expect(tmpResult).to.equal(tmpExpectedResult);
+						fDone();
+					}
+				);
+				test
+				(
+					'Multiple terms...',
+					(fDone) =>
+					{
+						var tmpTestString = 'There are <%#12345%> characters in here and a $comment$ as well.  And we <% Some data in here %> right up.';
+						var tmpExpectedResult = 'There are 5 characters in here and a comment as well.  And we JUNKED_THIS_DATA right up.';
+						var testPrecedent = loadPrecedentModule();
+						configPrecedent(testPrecedent);
+						var	tmpResult = testPrecedent.parseString(tmpTestString);
+						Expect(tmpResult).to.equal(tmpExpectedResult);
+						fDone();
+					}
+				);
+			}
+		);
+	}
+);

package/test/FableOperations_tests.js

@@ -10,7 +10,6 @@ var libFable = require('../source/Fable.js');
 
 var Chai = require("chai");
 var Expect = Chai.expect;
-var Assert = Chai.assert;
 
 suite
 (

package/test/FableUtility_tests.js

@@ -10,7 +10,6 @@ var libFable = require('../source/Fable.js');
 
 var Chai = require("chai");
 var Expect = Chai.expect;
-var Assert = Chai.assert;
 
 suite
 (

package/test/Fable_tests.js

@@ -10,7 +10,6 @@ var libFable = require('../source/Fable.js');
 
 var Chai = require("chai");
 var Expect = Chai.expect;
-var Assert = Chai.assert;
 
 suite
 (