fable 3.0.14 → 3.0.17

package/debug/Harness.js

@@ -1,9 +1,31 @@
 const libFable = require('../source/Fable.js');
 
+class SimpleService extends libFable.ServiceProviderBase
+{
+    constructor(pFable, pOptions, pServiceHash)
+    {
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'SimpleService';
+    }
+
+    doSomething()
+    {
+        this.fable.log.info(`SimpleService ${this.UUID}::${this.Hash} is doing something.`);
+    }
+}
+
 let testFable = new libFable({});
 
-testFable.serviceManager.addServiceType('SimpleService');
+testFable.serviceManager.addServiceType('SimpleService', SimpleService);
 
 testFable.serviceManager.instantiateServiceProvider('SimpleService', {SomeOption: true}, 'SimpleService-123');
 
-console.log(`Initialized Service ${testFable.serviceManager.services['SimpleService']['SimpleService-123'].serviceType} as UUID ${testFable.serviceManager.services['SimpleService']['SimpleService-123'].UUID} with hash ${testFable.serviceManager.services['SimpleService']['SimpleService-123'].Hash}`);
+
+testFable.serviceManager.services['SimpleService']['SimpleService-123'].doSomething();
+
+testFable.serviceManager.services['SimpleService']['SimpleService-123'].doSomething();
+
+console.log(`Initialized Service ${testFable.serviceManager.services['SimpleService']['SimpleService-123'].serviceType} as UUID ${testFable.serviceManager.services['SimpleService']['SimpleService-123'].UUID} with hash ${testFable.serviceManager.services['SimpleService']['SimpleService-123'].Hash}`);
+
+testFable.serviceManager.services['SimpleService']['SimpleService-123'].doSomething();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fable",
-  "version": "3.0.14",
+  "version": "3.0.17",
   "description": "An entity behavior management and API bundling library.",
   "main": "source/Fable.js",
   "scripts": {

package/source/Fable-Operation.js

@@ -31,6 +31,8 @@ class FableOperation
 	{
 		this.fable = pFable;
 
+		this.name = pOperationName;
+
 		this.state = JSON.parse(_OperationStatePrototype);
 
 		this.state.Metadata.GUID = this.fable.getUUID();

package/source/Fable-Service-Template.js

@@ -0,0 +1,106 @@
+const libFableServiceBase = require('./Fable-ServiceProviderBase.js');
+
+class FableServiceTemplate extends libFableServiceBase
+{
+	// 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)
+	{
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'Template';
+
+		// These are the exact regex's used in lodash/underscore
+		// TODO: Switch this to precedent
+		this.Matchers = (
+			{
+				Evaluate: /<%([\s\S]+?)%>/g,
+				Interpolate: /<%=([\s\S]+?)%>/g,
+				Escaper: /\\|'|\r|\n|\t|\u2028|\u2029/g,
+				Unescaper: /\\(\\|'|r|n|t|u2028|u2029)/g,
+				// This is how underscore does it, so we are keeping it for now.
+				GuaranteedNonMatch: /.^/
+			});
+
+		// This is a helper for the escaper and unescaper functions.
+		// Right now we are going to keep what underscore is doing, but, not forever.
+		this.templateEscapes = {
+			'\\': '\\',
+			"'": "'",
+			'r': '\r',
+			'\r': 'r',
+			'n': '\n',
+			'\n': 'n',
+			't': '\t',
+			'\t': 't',
+			'u2028': '\u2028',
+			'\u2028': 'u2028',
+			'u2029': '\u2029',
+			'\u2029': 'u2029'
+		};
+
+		// This is defined as such to underscore that it is a dynamic programming
+		// function on this class.
+		this.renderFunction = false;
+        this.templateString = false;
+	}
+
+	renderTemplate(pData)
+	{
+		return this.renderFunction(pData);
+	}
+
+	templateFunction(pData)
+	{
+		let fRenderTemplateBound = this.renderTemplate.bind(this);
+		return fRenderTemplateBound;
+	}
+
+	buildTemplateFunction(pTemplateText, pData)
+	{
+		// For now this is being kept in a weird form ... this is to mimic the old
+		// underscore code until this is rewritten using precedent.
+		this.TemplateSource = "__p+='" + pTemplateText
+			.replace(this.Matchers.Escaper,
+				(pMatch)=>
+				{
+					return `\\${this.templateEscapes[pMatch]}`;
+				})
+			.replace(this.Matchers.Interpolate || this.Matchers.GuaranteedNonMatch,
+				(pMatch, pCode) =>
+				{
+					return `'+\n(${decodeURIComponent(pCode)})+\n'`;
+				})
+			.replace(this.Matchers.Evaluate || this.Matchers.GuaranteedNonMatch,
+				(pMatch, pCode) =>
+				{
+					return `';\n${decodeURIComponent(pCode)}\n;__p+='`;
+				}) + `';\n`;
+
+
+		this.TemplateSource = `with(pTemplateDataObject||{}){\n${this.TemplateSource}}\n`;
+		this.TemplateSource = `var __p='';var print=function(){__p+=Array.prototype.join.call(arguments, '')};\n${this.TemplateSource}return __p;\n`;
+
+		this.renderFunction = new Function('pTemplateDataObject', this.TemplateSource);
+
+		if (typeof(pData) != 'undefined')
+		{
+			return this.renderFunction(pData);
+		}
+
+		// Provide the compiled function source as a convenience for build time
+		// precompilation.
+		this.TemplateSourceCompiled = 'function(obj){\n' + this.TemplateSource + '}';
+
+		return this.templateFunction();
+	}
+}
+
+module.exports = FableServiceTemplate;

package/source/Fable-ServiceManager.js

@@ -32,7 +32,7 @@ class FableService
 		// Add the container for instantiated services to go in
 		this.services[pServiceType] = {};
 
-		if (typeof(pServiceClass) == 'object' && pServiceClass.prototype instanceof libFableServiceBase)
+		if ((typeof(pServiceClass) == 'function') && (pServiceClass.prototype instanceof libFableServiceBase))
 		{
 			// Add the class to the list of classes
 			this.serviceClasses[pServiceType] = pServiceClass;
@@ -47,7 +47,7 @@ class FableService
 	instantiateServiceProvider(pServiceType, pOptions, pCustomServiceHash)
 	{
 		// Instantiate the service
-		let tmpService = new this.serviceClasses[pServiceType](this.fable, pOptions, pCustomServiceHash);
+		let tmpService = this.instantiateServiceProviderWithoutRegistration(pServiceType, pOptions, pCustomServiceHash);
 
 		// Add the service to the service map
 		this.services[pServiceType][tmpService.Hash] = tmpService;
@@ -61,6 +61,14 @@ class FableService
 		return tmpService;
 	}
 
+	// Create a service provider but don't register it to live forever in fable.services
+	instantiateServiceProviderWithoutRegistration(pServiceType, pOptions, pCustomServiceHash)
+	{
+		// Instantiate the service
+		let tmpService = new this.serviceClasses[pServiceType](this.fable, pOptions, pCustomServiceHash);
+		return tmpService;
+	}
+
 	setDefaultServiceInstantiation(pServiceType, pServiceHash)
 	{
 		if (this.services[pServiceType].hasOwnProperty(pServiceHash))
@@ -71,18 +79,8 @@ class FableService
 
 		return false;
 	}
-
-	getServiceByHash(pServiceHash)
-	{
-		if (this.services.hasOwnProperty(pServiceHash))
-		{
-			return this.services[pServiceHash];
-		}
-
-		return false;
-	}
 }
 
 module.exports = FableService;
 
-module.exports.FableServiceBase = libFableServiceBase;
+module.exports.ServiceProviderBase = libFableServiceBase;

package/source/Fable-ServiceProviderBase.js

@@ -10,7 +10,7 @@ class FableServiceProviderBase
 	{
 		this.fable = pFable;
 
-		this.options = pOptions;
+		this.options = (typeof(pOptions) === 'object') ? pOptions : {};
 
         this.serviceType = 'Unknown';
 

package/source/Fable-Utility.js

@@ -1,7 +1,6 @@
-const libFableUtilityTemplate = require('./Fable-Utility-Template.js');
 // TODO: These are still pretty big -- consider the smaller polyfills
 const libAsyncWaterfall = require('async.waterfall');
-const libAsyncEachLimit = require('async.eachLimit');
+const libAsyncEachLimit = require('async.eachlimit');
 
 class FableUtility
 {
@@ -9,6 +8,8 @@ class FableUtility
 	{
 		this.fable = pFable;
 
+		this.templates = {};
+
 		// These two functions are used extensively throughout
 		this.waterfall = libAsyncWaterfall;
 		this.eachLimit = libAsyncEachLimit;
@@ -26,11 +27,21 @@ class FableUtility
 	// with the added twist of returning a precompiled function ready to go.
 	template(pTemplateText, pData)
 	{
-		let tmpTemplate = new libFableUtilityTemplate(this.fable, pTemplateText);
+		let tmpTemplate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Template');
 
 		return tmpTemplate.buildTemplateFunction(pTemplateText, pData);
 	}
 
+	// Build a template function from a template hash, and, register it with the service provider
+	buildHashedTemplate(pTemplateHash, pTemplateText, pData)
+	{
+		let tmpTemplate = this.fable.serviceManager.instantiateServiceProvider('Template', {}, pTemplateHash);
+
+		this.templates[pTemplateHash] = tmpTemplate.buildTemplateFunction(pTemplateText, pData);
+
+		return this.templates[pTemplateHash];
+	}
+
 	// This is a safe, modern version of chunk from underscore
 	// Algorithm pulled from a mix of these two polyfills:
 	// https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore#_chunk

package/source/Fable.js

@@ -10,6 +10,8 @@ const libFableLog = require('fable-log');
 const libFableUtility = require('./Fable-Utility.js');
 const libFableServiceManager = require('./Fable-ServiceManager.js');
 
+const libFableServiceTemplate = require('./Fable-Service-Template.js');
+
 const libFableOperation = require('./Fable-Operation.js');
 
 class Fable
@@ -39,6 +41,11 @@ class Fable
 		this.Operations = {};
 
 		this.serviceManager = new libFableServiceManager(this);
+
+		this.serviceManager.addServiceType('Template', libFableServiceTemplate);
+
+		this.services = this.serviceManager.services;
+		this.defaultServices = this.serviceManager.defaultServices;
 	}
 
 	get settings()
@@ -81,7 +88,7 @@ class Fable
 		}
 		else
 		{
-			return this.pOperations[pOperationHash];
+			return this.Operations[pOperationHash];
 		}
 	}
 }

package/test/FableOperations_tests.js

@@ -30,13 +30,33 @@ suite
 						let testFable = new libFable();
 						let tmpOperation = testFable.createOperation('Big Complex Integration Operation', 'INTEGRATION-123');
 						Expect(tmpOperation).to.be.an('object');
+						Expect(testFable.getOperation('INTEGRATION-123')).to.equal(tmpOperation);
+						Expect(testFable.getOperation('BADHASH')).to.be.false;
 						Expect(testFable.Operations.hasOwnProperty('INTEGRATION-123')).to.equal(true);
-						tmpOperation.log.info('Test 123');
+						tmpOperation.log.info(`Operation GUID ${tmpOperation.GUID} ---- Test 123`);
 						Expect(tmpOperation.state.Log.length).to.equal(1);
 						Expect(tmpOperation.state.Log[0]).to.contain('Test 123');
 					}
 				);
 				test
+				(
+					'Create an Operation and try to create another with the hash',
+					function()
+					{
+						let testFable = new libFable();
+						let tmpOperation = testFable.createOperation('Big Complex Integration Operation', 'INTEGRATION-123');
+						Expect(tmpOperation).to.be.an('object');
+						Expect(tmpOperation.name).to.equal('Big Complex Integration Operation');
+
+						let tmpCollisionOperation = testFable.createOperation('Another Big Complex Integration Operation with Colliding Name', 'INTEGRATION-123');
+						Expect(tmpCollisionOperation).to.be.an('object');
+						Expect(tmpCollisionOperation.name).to.equal('Another Big Complex Integration Operation with Colliding Name');
+
+						Expect(testFable.getOperation('INTEGRATION-123')).to.equal(tmpOperation);
+
+					}
+				);
+				test
 				(
 					'Create a basic Integration Operation without a Hash',
 					function()
@@ -54,10 +74,11 @@ suite
 						tmpOperation.log.debug('Debug something.', {TestData:'Ignition Complete'});
 						tmpOperation.log.warn('Something was almost bad.');
 						tmpOperation.log.error('This was an error!');
+						tmpOperation.log.error('And this was an error with some sort of data!', {TestData:'Ignition Complete'});
 						tmpOperation.log.fatal('It was fatal.');
-						Expect(tmpOperation.state.Log.length).to.equal(7);
+						Expect(tmpOperation.state.Log.length).to.equal(9);
 						Expect(tmpOperation.state.Log[3]).to.equal('{"TestData":"Ignition Complete"}')
-						Expect(tmpOperation.state.Errors.length).to.equal(2);
+						Expect(tmpOperation.state.Errors.length).to.equal(4);
 					}
 				);
 			}

package/test/FableServiceManager_tests.js

@@ -11,6 +11,41 @@ var libFable = require('../source/Fable.js');
 var Chai = require("chai");
 var Expect = Chai.expect;
 
+class SimpleService extends libFable.ServiceProviderBase
+{
+    constructor(pFable, pOptions, pServiceHash)
+    {
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'SimpleService';
+    }
+
+    doSomething()
+    {
+        this.fable.log.info(`SimpleService ${this.UUID}::${this.Hash} is doing something.`);
+    }
+}
+
+class MockDatabaseService extends libFable.ServiceProviderBase
+{
+    constructor(pFable, pOptions, pServiceHash)
+    {
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'MockDatabaseService';
+    }
+
+    connect()
+    {
+        this.fable.log.info(`MockDatabaseService ${this.UUID}::${this.Hash} is connecting to a database.`);
+    }
+
+    commit(pRecord)
+    {
+        this.fable.log.info(`MockDatabaseService ${this.UUID}::${this.Hash} is committing a record ${pRecord}.`);
+    }
+}
+
 suite
 (
 	'Fable Service Manager',
@@ -48,15 +83,117 @@ suite
 					function()
 					{
 						testFable = new libFable();
-                        testFable.serviceManager.addServiceType('SimpleService');
+                        testFable.serviceManager.addServiceType('SimpleService', SimpleService);
                         testFable.serviceManager.instantiateServiceProvider('SimpleService', {SomeOption: true}, 'SimpleService-123');
 
                         Expect(testFable.serviceManager.services['SimpleService']['SimpleService-123']).to.be.an('object');
 
                         Expect(testFable.serviceManager.defaultServices['SimpleService']).to.be.an('object');
+
+                        testFable.serviceManager.defaultServices.SimpleService.doSomething();
+
                         Expect(testFable.serviceManager.defaultServices['SimpleService'].Hash).to.equal('SimpleService-123');
 					}
 				);
+                test
+                (
+                    'Use the Default Service with a different hash',
+                    function()
+                    {
+                        let testFable = new libFable({});
+
+                        testFable.serviceManager.addServiceType('SimpleService', SimpleService);
+
+                        testFable.serviceManager.instantiateServiceProvider('SimpleService', {SomeOption: true}, 'SimpleService-13');
+
+                        testFable.serviceManager.services['SimpleService']['SimpleService-13'].doSomething();
+
+                        Expect(testFable.serviceManager.services['SimpleService']['SimpleService-13']).to.be.an('object');
+                    }
+                );
+
+                test
+                (
+                    'Instantiate a service without registering it to Fable',
+                    function()
+                    {
+                        let testFable = new libFable({});
+
+                        testFable.serviceManager.addServiceType('SimpleService', SimpleService);
+
+                        let tmpService = testFable.serviceManager.instantiateServiceProviderWithoutRegistration('SimpleService', {SomeOption: true}, 'SimpleService-99');
+
+                        Expect(testFable.services.SimpleService['SimpleService-99']).to.be.an('undefined');
+
+                        Expect(tmpService).to.be.an('object');
+                    }
+                );
+
+                test
+                (
+                    'Change the default service provider',
+                    function()
+                    {
+                        let testFable = new libFable({});
+
+                        testFable.serviceManager.addServiceType('SimpleService', SimpleService);
+                        testFable.serviceManager.addServiceType('DatabaseService', MockDatabaseService);
+
+                        testFable.serviceManager.instantiateServiceProvider('SimpleService', {SomeOption: true});
+                        testFable.serviceManager.defaultServices.SimpleService.doSomething();
+
+                        testFable.serviceManager.instantiateServiceProvider('DatabaseService', {ConnectionString: 'mongodb://localhost:27017/test'}, 'PrimaryConnection');
+
+                        Expect(testFable.serviceManager.defaultServices.DatabaseService.Hash).to.equal('PrimaryConnection');
+
+                        testFable.serviceManager.instantiateServiceProvider('DatabaseService', {ConnectionString: 'mongodb://localhost:27017/test'}, 'SecondaryConnection');
+
+                        Expect(testFable.serviceManager.defaultServices.DatabaseService.Hash).to.equal('PrimaryConnection');
+
+                        testFable.serviceManager.defaultServices.DatabaseService.connect();
+                        testFable.serviceManager.defaultServices.DatabaseService.commit('Test Record');
+
+                        testFable.serviceManager.setDefaultServiceInstantiation('DatabaseService', 'SecondaryConnection');
+
+                        testFable.serviceManager.defaultServices.DatabaseService.connect();
+                        testFable.serviceManager.defaultServices.DatabaseService.commit('Another Test Record');
+
+                        Expect(testFable.serviceManager.defaultServices.DatabaseService.Hash).to.equal('SecondaryConnection');
+                    }
+                );
+
+                test
+                (
+                    'Attempt to change the default service provider to a nonexistant provider',
+                    function()
+                    {
+                        let testFable = new libFable({});
+
+                        testFable.serviceManager.addServiceType('SimpleService', SimpleService);
+                        testFable.serviceManager.addServiceType('DatabaseService', MockDatabaseService);
+
+                        testFable.serviceManager.instantiateServiceProvider('SimpleService', {SomeOption: true});
+                        testFable.serviceManager.defaultServices.SimpleService.doSomething();
+
+                        testFable.serviceManager.instantiateServiceProvider('DatabaseService', {ConnectionString: 'mongodb://localhost:27017/test'}, 'PrimaryConnection');
+
+                        Expect(testFable.serviceManager.defaultServices.DatabaseService.Hash).to.equal('PrimaryConnection');
+
+                        testFable.serviceManager.instantiateServiceProvider('DatabaseService', {ConnectionString: 'mongodb://localhost:27017/test'}, 'SecondaryConnection');
+
+                        Expect(testFable.serviceManager.defaultServices.DatabaseService.Hash).to.equal('PrimaryConnection');
+
+                        testFable.serviceManager.defaultServices.DatabaseService.connect();
+                        testFable.serviceManager.defaultServices.DatabaseService.commit('Test Record');
+
+                        Expect(testFable.serviceManager.setDefaultServiceInstantiation('DatabaseService', 'TertiaryConnection')).to.be.false;
+
+                        testFable.serviceManager.defaultServices.DatabaseService.connect();
+                        testFable.serviceManager.defaultServices.DatabaseService.commit('Another Test Record');
+
+                        Expect(testFable.serviceManager.defaultServices.DatabaseService.Hash).to.equal('PrimaryConnection');
+                    }
+                );
 			}
 		);
 	}

package/test/FableUtility_tests.js

@@ -58,9 +58,52 @@ suite
 					function()
 					{
 						testFable = new libFable();
-						let tmpTemplate = testFable.Utility.template('There are <%= Count %> things....');
+						let tmpTemplate = testFable.Utility.template('There // %> are \\ */ /* <%= Count %> things....');
 						Expect(tmpTemplate).to.be.a('function');
-						Expect(tmpTemplate({Count:1000})).to.equal('There are 1000 things....');
+						Expect(tmpTemplate({Count:1000})).to.equal('There // %> are \\ */ /* 1000 things....');
+					}
+				);
+				test
+				(
+					'Processed Template like Underscore Work With Variables and no scope leakage',
+					function()
+					{
+						testFable = new libFable();
+						let tmpTemplate = testFable.Utility.template('There are so many of these things (<%= Count %> to be exact)....');
+						Expect(tmpTemplate).to.be.a('function');
+						Expect(tmpTemplate({Count:1000})).to.equal('There are so many of these things (1000 to be exact)....');
+						let tmpOtherTemplate = testFable.Utility.template('Things count: <%= Count %>');
+						Expect(tmpOtherTemplate).to.be.a('function');
+						Expect(tmpOtherTemplate({Count:600})).to.equal('Things count: 600');
+						Expect(tmpTemplate({Count:256})).to.equal('There are so many of these things (256 to be exact)....');
+					}
+				);
+				test
+				(
+					'Processed Template like Underscore Work With Variables and no scope leakage',
+					function()
+					{
+						testFable = new libFable();
+						testFable.Utility.buildHashedTemplate('HeadLine', '<h1><%= TitleText %> Page</h1>');
+						testFable.Utility.buildHashedTemplate('Slogan', '<p>Some people, like <%= Name %>, have all the fun.</p>');
+						
+						// Access the low level service render function
+						Expect(testFable.services.Template.HeadLine.renderFunction({TitleText:'Test'})).to.equal('<h1>Test Page</h1>');
+						Expect(testFable.services.Template.Slogan.renderFunction({Name:'Jim'})).to.equal('<p>Some people, like Jim, have all the fun.</p>');
+
+						// Use the high level simpler one
+						Expect(testFable.Utility.templates.HeadLine({TitleText:'A New'})).to.equal('<h1>A New Page</h1>');
+						Expect(testFable.Utility.templates.Slogan({Name:'Bob'})).to.equal('<p>Some people, like Bob, have all the fun.</p>');
+					}
+				);
+				test
+				(
+					'Processed Template with default scope',
+					function()
+					{
+						testFable = new libFable();
+						let tmpTemplate = testFable.Utility.template('There are <%= Count %> things....', {Count:1000});
+						Expect(tmpTemplate).to.equal('There are 1000 things....');
 					}
 				);
 				test

package/source/Fable-Utility-Template.js

@@ -1,108 +0,0 @@
-class FableUtility
-{
-	// 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, pTemplateText)
-	{
-		this.fable = pFable;
-
-		// These are the exact regex's used in lodash/underscore
-		// TODO: Switch this to precedent
-		this.Matchers = (
-			{
-		        Evaluate: /<%([\s\S]+?)%>/g,
-		        Interpolate: /<%=([\s\S]+?)%>/g,
-	    		Escaper: /\\|'|\r|\n|\t|\u2028|\u2029/g,
-	    		Unescaper: /\\(\\|'|r|n|t|u2028|u2029)/g,
-				// This is how underscore does it, so we are keeping it for now.
-	    		GuaranteedNonMatch: /.^/
-		    });
-
-	    // This is a helper for the escaper and unescaper functions.
-	    // Right now we are going to keep what underscore is doing, but, not forever.
-	    this.templateEscapes = {
-	        '\\': '\\',
-	        "'": "'",
-	        'r': '\r',
-	        '\r': 'r',
-	        'n': '\n',
-	        '\n': 'n',
-	        't': '\t',
-	        '\t': 't',
-	        'u2028': '\u2028',
-	        '\u2028': 'u2028',
-	        'u2029': '\u2029',
-	        '\u2029': 'u2029'
-	    };
-
-	    // This is defined as such to underscore that it is a dynamic programming
-	    // function on this class.
-	    this.renderFunction = ()=>{return ``};
-	}
-
-	// Underscore and lodash have a behavior, _.extend, which merges objects.
-	// Now that es6 gives us this, use the native thingy.
-	extend(pDestinationObject, ...pSourceObjects)
-	{
-		return Object.assign(pDestinationObject, ...pSourceObjects);
-	}
-
-	renderTemplate(pData)
-	{
-		return this.renderFunction(pData);
-	}
-
-	templateFunction(pData)
-	{
-		let fRenderTemplateBound = this.renderTemplate.bind(this);
-		return fRenderTemplateBound;
-	}
-
-	buildTemplateFunction(pTemplateText, pData)
-    {
-    	// For now this is being kept in a weird form ... this is to mimic the old
-    	// underscore code until this is rewritten using precedent.
-        this.TemplateSource = "__p+='" + pTemplateText
-            .replace(this.Matchers.Escaper,
-            	(pMatch)=>
-	            {
-	                return `\\${this.templateEscapes[pMatch]}`;
-	            })
-            .replace(this.Matchers.Interpolate || this.Matchers.GuaranteedNonMatch,
-            	(pMatch, pCode) =>
-            	{
-	                return `'+\n(${decodeURIComponent(pCode)})+\n'`;
-	            })
-	        .replace(this.Matchers.Evaluate || this.Matchers.GuaranteedNonMatch,
-				(pMatch, pCode) =>
-            	{
-	                return `';\n${decodeURIComponent(pCode)}\n;__p+='`;
-	            }) + `';\n`;
-
-
-        this.TemplateSource = `with(pTemplateDataObject||{}){\n${this.TemplateSource}}\n`;
-        this.TemplateSource = `var __p='';var print=function(){__p+=Array.prototype.join.call(arguments, '')};\n${this.TemplateSource}return __p;\n`;
-
-        this.renderFunction = new Function('pTemplateDataObject', this.TemplateSource);
-
-        if (typeof(pData) != 'undefined')
-        {
-            return this.renderFunction(pData);
-        }
-
-        // Provide the compiled function source as a convenience for build time
-        // precompilation.
-        this.TemplateSourceCompiled = 'function(obj){\n' + this.TemplateSource + '}';
-
-        return this.templateFunction();
-	}
-}
-
-module.exports = FableUtility;