From 96df0a271c6d5ec8faf32f4657b49ca16cf05094 Mon Sep 17 00:00:00 2001
From: Peter Pavlovich <pavlovich@gmail.com>
Date: Mon, 12 May 2014 20:34:08 -0400
Subject: [PATCH 1/6] Added support for the Blaze rendering engine. Also added
 a more flexible bootstrapping mechanism. Default behavior is the same as the
 original (bootstrapping 'ngMeteor' on the document element).

---
 README.md                    |  35 ++++++++++--
 modules/ngMeteor-template.js |  62 +++++++++++----------
 ngMeteor.js                  | 104 +++++++++++++++++++++++++++++++----
 package.js                   |  34 +++++++-----
 4 files changed, 176 insertions(+), 59 deletions(-)

diff --git a/README.md b/README.md
index d90ef3c..5fd2070 100644
--- a/README.md
+++ b/README.md
@@ -21,6 +21,7 @@ ngMeteor
 - [Creating and inserting template views](https://github.com/loneleeandroo/ngMeteor#creating-and-inserting-template-views)
 - [Routing](https://github.com/loneleeandroo/ngMeteor#routing)
 - [Module Injection](https://github.com/loneleeandroo/ngMeteor#module-injection)
+- [Flexible module bootstrapping](https://github.com/loneleeandroo/ngMeteor#flexistrap)
 
 ### New Data-Binding to avoid conflict
 To prevent conflicts with Handlebars, ngMeteor has changed the default AngularJS data bindings from <code>{{foo}}</code> to <code>[[foo]]</code>. For example:
@@ -165,14 +166,12 @@ You can render this template using handlebars as you would for any other Meteor
 
     {{> foo}}
 
-Templates will also be added to the $templateCache of the ngMeteor angular module. To invoke the template in AngularJS you could use ng-view and specify the template in the $templateCache when defining your routes using the $routeProvider or your could use the ng-template directive to render your template like this:
+Meteor templates can also be rendered in your Angular views using the ng-template directive like this:
 
     <ANY ng-template="foo"></ANY>
 
     <!--Add the ng-controller attribute if you want to load a controller at the same time.-->    
     <ANY ng-template="foo" ng-controller="fooCtrl"></ANY>
-    
-Templates with names starting with an underscore, for example "_foo", will not be put into the $templateCache, so you will not be able to access those templates using ng-template, ng-include or ng-view.
 
 ### Routing
 The [ngRoute](http://docs.angularjs.org/api/ngRoute) module developed by the AngularJS team is included in ngMeteor, which will satisfy those with simple routing needs. For example, if you want to call a template called 'foo' and a controller called 'TodoCtrl' when someone lands on your home page you would define your route like this:
@@ -212,10 +211,38 @@ Using this method, additional functionality has been provided to ngMeteor in the
 
 Feel free to make ngMeteor module smart packages, and please contact [loneleeandroo](https://github.com/loneleeandroo) if you would like your package to be listed here as well.
 
+### Flexible module bootstrapping (flexistrap)
+
+By default, the ngMeteor angular module is bootstrapped into the top level document on all routes. Since modules cannot be nested in angular, should you want to have parts of your DOM controlled by different modules you can do so using a flexible bootstrapping mechanism called flexistrap which is built in to the ngMeteor package. To use this mechanism you call ngMeteor.addFlexistrap() and provide a jQuery-like selector and an angular module name (or array of module names) as parameters. Fleximodel will then instruct angular to bootstrap the modules with the name (or names, if you provided an array of names) into the DOM elements matching the provided selector.
+
+Optionally, you can provide a path string (or array of path strings) as the 3rd parameter to addFlexistrap. This will apply your modules to the selected DOM elements only when the path(s) identified by the provided strings are being rendered. You can provide a value of '*' to apply your flexistrap configuration to all paths (this is the default behavior if this parameter is not provided).
+
+Optionally, you can provide a boolean as the 4th parameter. If this value is true, the configuration you provide will replace any existing flexistrap configuration for the given path(s) and selector. If False, it will ONLY update EXISTING configurations. If not supplied or null, it will update existing configurations or add new ones if they don't already exist.
+
+Example:
+
+Define two new modules: 'myModule' and 'yourModule':
+
+    myCoolModule = angular.module('myModule',[]);
+    yourCoolModule = angular.module('yourModule',[]);
+
+
+Remove existing (default) bootstrapping of ngMeteor on the toplevel document:
+
+    ngMeteor.removeFlexistrap(); // removes all existing flexistrap configurations for all paths and selectors.
+
+Bootstrap div with id 'xxx' with new module named 'myModule'
+
+    ngMeteor.addFlexistrap('#xxx', 'myModule')
+
+Bootstrap div with id 'yyy' with both the new module 'yourModule' and the original 'ngMeteor' module:
+
+    ngMeteor.addFlexistrap('#yyy', ['yourModule', 'ngMeteor'])
+
 
 <!---
 ### Dynamic routing
-Routes will automaticlly be created based on a template's name, however, you can override the dynamic routes by manually assigning a route using $routeProvider. The route will load that template and conditionally load a controller with the same name if it exists. You can prevent a template from creating a route by adding a "_" infront of the template name. Based on the URL, this is how you should name your templates:
+Routes will automaticlly be created based on a template's name, however, you can override the dynamic routes by manually assigning a route using $routeProvider. The route will load that template and conditionally load a controller with the same name if it exists. You can prevent a template from creating a route by adding a "_" in front of the template name. Based on the URL, this is how you should name your templates:
 
 | URL                               | Template / Controller name     | $routeParams |
 | :-------------------------------- | :----------------------------- | :----------- |
diff --git a/modules/ngMeteor-template.js b/modules/ngMeteor-template.js
index 785b6b5..7eb236a 100644
--- a/modules/ngMeteor-template.js
+++ b/modules/ngMeteor-template.js
@@ -1,26 +1,14 @@
 var ngMeteorTemplate = angular.module('ngMeteor.template', []);
 
-ngMeteorTemplate.run(['$templateCache',
-	function($templateCache) {
-		angular.forEach(Template, function(template, name){
-			if(name.charAt(0) != "_"){
-				var templateString = HTML.toHTML(template.render());
-				$templateCache.put(name, templateString);
-			}
-		});
-	}
-]);
-
-ngMeteorTemplate.directive('ngTemplate', ['$templateCache', '$compile',
-	function($templateCache, $compile) {
+ngMeteorTemplate.directive('ngTemplate', ['$compile',
+	function($compile) {
 		return {
 			restrict: 'AE',
 			scope: true,
 			link: function(scope, element, attributes) {
-				var	name = attributes.ngTemplate || attributes.name,
-					template = $templateCache.get(name);
-				if(angular.isDefined(template)){
-					element.html(template);
+				var	name = attributes.ngTemplate || attributes.name
+				if(name && Template[name]){
+					element.html(ngMeteor.renderTemplateInContext(name, scope));
 					element.replaceWith($compile(element.html())(scope));
 				} else{
 					console.error("ngMeteor: There is no template with the name '" + attributes.ngTemplate + "'");
@@ -30,22 +18,40 @@ ngMeteorTemplate.directive('ngTemplate', ['$templateCache', '$compile',
 	}
 ]);
 
-// Re-compiles template when rendering with Iron-Router
+// Configure Angular to automatically re-compile the template when rendering with Iron-Router
 angular.element(document).ready(function() {
+
+    // Apply the default flexistrap configuration (to match the old behaviour of the module pre-flexistrap
+    ngMeteor.addFlexistrap(document, 'ngMeteor', '*', false);
+
     if(Package['iron-router']){
         var oldRun = Router.run;
         Router.run = function() {
             var runResult = oldRun.apply(this, arguments);
-            key = this._currentController.template
-            var oldRendered = Template[key].rendered;
-            Template[key].rendered = function(){
-                angular.element(document).injector().invoke(['$compile', '$document', '$rootScope', function($compile, $document, $rootScope){
-                    $compile($document)($rootScope);
-                    $rootScope.$digest();
-                    oldRendered.apply(this, arguments);
-                }]);
-                Template[key].rendered = oldRendered;
-            }
+            var templateKey = this._currentController.route.options.template ? this._currentController.route.options.template : this._currentController.route.name;
+            var oldRendered = Template[templateKey].rendered;
+            Template[templateKey].rendered = function(){
+
+                // Apply flexistrap if one has been configured.
+                var map = ngMeteor.getFlexistrap(templateKey);
+                $.each( map, function( key, value ) {
+                    var eleArray = $(key);
+                    _.each(eleArray, function(element){
+                        var moduleList = _.clone(value);
+                        if (!element.bootstrapped && !angular.element(element).injector()){
+                            angular.bootstrap(element, moduleList);
+                            element.bootstrapped = true;
+                        }else {
+                            angular.element(element).injector().invoke(['$compile', '$document', '$rootScope', function ($compile, $document, $rootScope) {
+                                element.replaceWith($compile(element)($rootScope));
+                                $rootScope.$digest();
+                            }]);
+                        }
+                    });
+                });
+                oldRendered.apply(this, arguments);
+                Template[templateKey].rendered = oldRendered;
+            };
             return runResult;
         };
     }
diff --git a/ngMeteor.js b/ngMeteor.js
index 3142480..f208b95 100644
--- a/ngMeteor.js
+++ b/ngMeteor.js
@@ -1,4 +1,6 @@
-// Define ngMeteor and its dependencies
+/**
+ * Define the ngMeteor angular module and its dependencies
+  */
 ngMeteor = angular.module('ngMeteor', [
 	'ngMeteor.collections', 
 	'ngMeteor.template',
@@ -11,17 +13,95 @@ ngMeteor = angular.module('ngMeteor', [
 	'ngSanitize'
 ]);
 
+/**
+ * Define the 'holder' for flexistrap (flexible bootstrap) configurations.
+ * The intent is to have this keyed by the 'path' (in case you have multiple routes) with values being another hash object
+ * with keys being jQuery-like selectors and values being arrays of module names to be bootstrapped into elements matching
+ * those selectors.
+ */
+ngMeteor.flexistrapRegister = {};
+
+/**
+ * Remove a flexistrap configuration.
+ * @param selector: JQuery-style selector to select the DOM element(s) to which the flexistrap operation will apply. If not supplied, it defaults to removing all configurations for the specified path(s).
+ * @param angularModuleNameOrArray: The name (or array of names) of the module(s) to be added to the flexistrop configuration for the selected element(s). If not provided, it will
+ * @param pathOrArray: The path string (or array of path strings) for which, when rendered, we wish to have a flexible bootstrap configuration (flexistrap) applied.
+ *                      If not provided, it applies to all paths specifications including '*'.
+ *                      If you only want it to affect the '*' flexistrap configuration, ensure you provide '*' as the value for this parameter.
+ * @returns: ngMeteor to allow easy method chaining.
+ */
+ngMeteor.removeFlexistrap = function(selector, angularModuleNameOrArray, pathOrArray){
+    return ngMeteor.addFlexistrap(selector, null, pathOrArray, true);
+};
+
+/**
+ * Add or update a flexistrap configuration.
+ * If replaceFlag is true, replace any existing flexistrap configuration for the provided <selector>.
+ * If false, only insert if the configuration doesn't already exist, otherwise ignore.
+ * If null, add to existing or create new.
+ * @param selector: JQuery-style selector to select the DOM element(s) to which the flexistrap operation will apply. If null, it defaults to an empty array.
+ * @param angularModuleNameOrArray: The name (or array of names) of the module(s) to be added to the flexistrop configuration for the selected element(s).
+ *                                      If null, it defaults to an empty array.
+ * @param pathOrArray: (optional) The url (or fragment) which, when rendered, we wish to have this flexible bootstrap configuration applied.
+ *                      Note that a value of '*' will add the provided configuration to all path configurations (as a merge function at run time).
+ *                      If null, it will default to '*'.
+ * @param replaceFlag: (optional) If true, replace existing flexistrap configuration. If false, only add it if one has
+ *                          not yet been registered for this selector and path. If null or not supplied, add the provided module name or names
+ *                          to the existing flexistrap configuration or create a new one to bootstrap with the provided module name(s).
+ * @returns: ngMeteor to allow easy method chaining.
+ */
+ngMeteor.addFlexistrap = function(selector, angularModuleNameOrArray, pathOrArray, replaceFlag){
+    var moduleNames = angularModuleNameOrArray ? (_.isArray(angularModuleNameOrArray) ? angularModuleNameOrArray : [angularModuleNameOrArray]) : [];
+    var paths = pathOrArray ? (_.isArray(pathOrArray) ? pathOrArray : [pathOrArray]) : ['*'];
+
+    _.each(paths, function(ele){
+        var pathEntry = this[ele] ? this[ele] : null;
+        if(typeof replaceFlag === 'undefined' || replaceFlag === null){
+            if(typeof pathEntry === 'undefined' || pathEntry === null){
+                pathEntry = {};
+            }
+        }else{
+            pathEntry = {};
+            if(!replaceFlag){
+                return;
+            }
+        }
+        var moduleArray = selector ? (pathEntry[selector] ? pathEntry[selector] : []) : [];
+        moduleArray = _.union(moduleArray, moduleNames);
+        pathEntry[selector] = moduleArray;
+        this[ele] = pathEntry;
+        return ngMeteor;
+    }, ngMeteor.flexistrapRegister);
+};
+
+/**
+ * Retrieve the flexible bootstrap configuration map for the provided path.
+ * @param path: The routing path being rendered.
+ * @returns A map object with keys being jQuery-like selector strings and values being arrays of module names which
+ *              will be bootstrapped by angular into the elements obtained from the provided selector.
+ */
+ngMeteor.getFlexistrap = function(path){
+    var flexistrap = path ? ngMeteor.flexistrapRegister[path] : null;
+    flexistrap = flexistrap ? flexistrap : {};
+    var all = ngMeteor.flexistrapRegister['*'] ? ngMeteor.flexistrapRegister['*'] : {};
+    return _.extend(flexistrap, all);
+};
+
+/** Utility method for use with the Blaze rendering engine.
+  * Render the named template as HTML using the 'context' param as the source for variable substitution.
+ */
+ngMeteor.renderTemplateInContext = function(templateOrName, context) {
+    var template = (typeof templateOrName === 'string') ? Template[templateOrName] : templateOrName;
+    var div = document.createElement('div');
+    var component = UI.renderWithData(template, context);
+    UI.insert(component, div);
+    return div.innerHTML;
+};
+
 // Change the data-bindings from {{foo}} to [[foo]]
 ngMeteor.config(['$interpolateProvider',
-	function ($interpolateProvider) {
-		$interpolateProvider.startSymbol('[[');
-		$interpolateProvider.endSymbol(']]');
-	}
+    function ($interpolateProvider) {
+        $interpolateProvider.startSymbol('[[');
+        $interpolateProvider.endSymbol(']]');
+    }
 ]);
-
-// Manual initilisation of ngMeteor
-angular.element(document).ready(function() {
-	if (!angular.element(document).injector()){
-		angular.bootstrap(document, ['ngMeteor']);
-	}
-});
diff --git a/package.js b/package.js
index 7835c59..005e9b4 100644
--- a/package.js
+++ b/package.js
@@ -1,29 +1,33 @@
 Package.describe({
-	summary: "The simplest no-conflict way to use AngularJS with Meteor, Meteorite and Atmosphere Smart Packages."
+	summary: "The simplest, no-conflict way to use AngularJS with Meteor, Meteorite and Atmosphere Smart Packages."
 });
 
 Package.on_use(function (api) {
+    api.use('templating', 'client');
+    api.use('underscore', 'client');
+
 	// Exports the ngMeteor package scope
 	api.export('ngMeteor', 'client');
 	
 	// Files to load in Client only.
 	api.add_files([
 		// Lib Files
-		'lib/angular.js',
-		'lib/angular-csp.css',
-		'lib/angular-animate.js',
-		'lib/angular-cookies.js',
-		//'lib/angular-mocks.js',
-		'lib/angular-resource.js',
-		'lib/angular-route.js',
-		//'lib/angular-scenario.js',
-		'lib/angular-sanitize.js',
-		'lib/angular-touch.js',
-		'lib/angular-hash-key-copier.js',
+		    'lib/angular.js',
+		    'lib/angular-csp.css',
+		    'lib/angular-animate.js',
+		    'lib/angular-cookies.js',
+		    'lib/angular-resource.js',
+		    'lib/angular-route.js',
+		    'lib/angular-sanitize.js',
+		    'lib/angular-touch.js',
+		    'lib/angular-hash-key-copier.js',
+
 		// Module Files
-		'modules/ngMeteor-collections.js',
-		'modules/ngMeteor-template.js',
+		    'modules/ngMeteor-collections.js',
+		    'modules/ngMeteor-template.js',
+
 		// Finally load ngMeteor File
-		'ngMeteor.js'
+		    'ngMeteor.js'
+
 	], 'client');
 });

From 2263b2d5d2084e95d133e4786fd41475334a9e3d Mon Sep 17 00:00:00 2001
From: Peter Pavlovich <pavlovich@gmail.com>
Date: Tue, 17 Jun 2014 01:41:54 -0400
Subject: [PATCH 2/6] Reduce the number of 'root' scope elements produced when
 navigating from page to page. Temporary 'partial fix' until memory leak issue
 can be solved.

---
 modules/ngMeteor-template.js | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/modules/ngMeteor-template.js b/modules/ngMeteor-template.js
index 7eb236a..142b601 100644
--- a/modules/ngMeteor-template.js
+++ b/modules/ngMeteor-template.js
@@ -38,14 +38,19 @@ angular.element(document).ready(function() {
                     var eleArray = $(key);
                     _.each(eleArray, function(element){
                         var moduleList = _.clone(value);
-                        if (!element.bootstrapped && !angular.element(element).injector()){
-                            angular.bootstrap(element, moduleList);
+                      //  if (!element.bootstrapped && !angular.element(element).injector()){
+                        if(!ngMeteor.sgiInjector) {
+                            ngMeteor.sgiInjector = angular.bootstrap(element, moduleList);
                             element.bootstrapped = true;
                         }else {
-                            angular.element(element).injector().invoke(['$compile', '$document', '$rootScope', function ($compile, $document, $rootScope) {
-                                element.replaceWith($compile(element)($rootScope));
-                                $rootScope.$digest();
-                            }]);
+
+                                ngMeteor.sgiInjector.invoke(
+                                    ['$compile', '$document', '$rootScope', function ($compile, $document, $rootScope) {
+                                        $compile(element)($rootScope);
+                                        $rootScope.$digest();
+                                    }]
+                                )
+
                         }
                     });
                 });

From 52b8f31868ea33250ae55e6813807a3a588bcb24 Mon Sep 17 00:00:00 2001
From: Peter Pavlovich <pavlovich@gmail.com>
Date: Tue, 17 Jun 2014 20:25:08 -0400
Subject: [PATCH 3/6] Fixes bug in which 'rendered' callbacks registered on
 templates rendered through iron-router were overridden and lost when angular
 compile/digest cycle was incorporated.

This fix caches any registered 'rendered' callback and reapplies it after the angular compile/digest cycle is completed and then re-registers that callback on the template.
---
 modules/ngMeteor-template.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/modules/ngMeteor-template.js b/modules/ngMeteor-template.js
index 142b601..3b71555 100644
--- a/modules/ngMeteor-template.js
+++ b/modules/ngMeteor-template.js
@@ -54,7 +54,9 @@ angular.element(document).ready(function() {
                         }
                     });
                 });
-                oldRendered.apply(this, arguments);
+                if(oldRendered && typeof oldRendered == 'function') {
+                    oldRendered.apply(this, arguments);
+                };
                 Template[templateKey].rendered = oldRendered;
             };
             return runResult;

From c89c656de6c92a2cfd52f0d03a9668cc2e0c156f Mon Sep 17 00:00:00 2001
From: Peter Pavlovich <pavlovich@gmail.com>
Date: Tue, 17 Jun 2014 23:42:21 -0400
Subject: [PATCH 4/6] Clean up

---
 modules/ngMeteor-template.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/modules/ngMeteor-template.js b/modules/ngMeteor-template.js
index 3b71555..81263c0 100644
--- a/modules/ngMeteor-template.js
+++ b/modules/ngMeteor-template.js
@@ -43,9 +43,11 @@ angular.element(document).ready(function() {
                             ngMeteor.sgiInjector = angular.bootstrap(element, moduleList);
                             element.bootstrapped = true;
                         }else {
-
                                 ngMeteor.sgiInjector.invoke(
                                     ['$compile', '$document', '$rootScope', function ($compile, $document, $rootScope) {
+//                                        if($rootScope.$$childHead){
+//                                            $rootScope.$$childHead.$destroy();
+//                                        }
                                         $compile(element)($rootScope);
                                         $rootScope.$digest();
                                     }]

From b73d4f08fb499cecdcb2fadd8aa6fd7c806b3d8a Mon Sep 17 00:00:00 2001
From: Peter Pavlovich <pavlovich@gmail.com>
Date: Tue, 15 Jul 2014 20:43:23 -0400
Subject: [PATCH 5/6] checkpoint

---
 modules/ngMeteor-template.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/modules/ngMeteor-template.js b/modules/ngMeteor-template.js
index 81263c0..f338b69 100644
--- a/modules/ngMeteor-template.js
+++ b/modules/ngMeteor-template.js
@@ -45,9 +45,9 @@ angular.element(document).ready(function() {
                         }else {
                                 ngMeteor.sgiInjector.invoke(
                                     ['$compile', '$document', '$rootScope', function ($compile, $document, $rootScope) {
-//                                        if($rootScope.$$childHead){
-//                                            $rootScope.$$childHead.$destroy();
-//                                        }
+                                        if($rootScope.$$childHead){
+                                            $rootScope.$$childHead.$destroy();
+                                        }
                                         $compile(element)($rootScope);
                                         $rootScope.$digest();
                                     }]

From c656d8f68348de65ae1071d2dd912e1a1333c5b3 Mon Sep 17 00:00:00 2001
From: Peter Pavlovich <pavlovich@gmail.com>
Date: Tue, 15 Jul 2014 20:46:50 -0400
Subject: [PATCH 6/6] Fixed some oversights

---
 lib/bindonce.js              | 321 +++++++++++++++++++++++++++++++++++
 modules/ngMeteor-template.js | 115 ++++++++++---
 ngMeteor.js                  |   6 +-
 package.js                   |   7 +-
 4 files changed, 424 insertions(+), 25 deletions(-)
 create mode 100644 lib/bindonce.js

diff --git a/lib/bindonce.js b/lib/bindonce.js
new file mode 100644
index 0000000..3a6f43d
--- /dev/null
+++ b/lib/bindonce.js
@@ -0,0 +1,321 @@
+(function () {
+	"use strict";
+	/**
+	 * Bindonce - Zero watches binding for AngularJs
+	 * @version v0.3.1
+	 * @link https://github.com/Pasvaz/bindonce
+	 * @author Pasquale Vazzana <pasqualevazzana@gmail.com>
+	 * @license MIT License, http://www.opensource.org/licenses/MIT
+	 */
+
+	var bindonceModule = angular.module('pasvaz.bindonce', []);
+
+	bindonceModule.directive('bindonce', function ()
+	{
+		var toBoolean = function (value)
+		{
+			if (value && value.length !== 0)
+			{
+				var v = angular.lowercase("" + value);
+				value = !(v === 'f' || v === '0' || v === 'false' || v === 'no' || v === 'n' || v === '[]');
+			}
+			else
+			{
+				value = false;
+			}
+			return value;
+		};
+
+		var msie = parseInt((/msie (\d+)/.exec(angular.lowercase(navigator.userAgent)) || [])[1], 10);
+		if (isNaN(msie))
+		{
+			msie = parseInt((/trident\/.*; rv:(\d+)/.exec(angular.lowercase(navigator.userAgent)) || [])[1], 10);
+		}
+
+		var bindonceDirective =
+		{
+			restrict: "AM",
+			controller: ['$scope', '$element', '$attrs', '$interpolate', function ($scope, $element, $attrs, $interpolate)
+			{
+				var showHideBinder = function (elm, attr, value)
+				{
+					var show = (attr === 'show') ? '' : 'none';
+					var hide = (attr === 'hide') ? '' : 'none';
+					elm.css('display', toBoolean(value) ? show : hide);
+				};
+				var classBinder = function (elm, value)
+				{
+					if (angular.isObject(value) && !angular.isArray(value))
+					{
+						var results = [];
+						angular.forEach(value, function (value, index)
+						{
+							if (value) results.push(index);
+						});
+						value = results;
+					}
+					if (value)
+					{
+						elm.addClass(angular.isArray(value) ? value.join(' ') : value);
+					}
+				};
+				var transclude = function (transcluder, scope)
+				{
+					transcluder.transclude(scope, function (clone)
+					{
+						var parent = transcluder.element.parent();
+						var afterNode = transcluder.element && transcluder.element[transcluder.element.length - 1];
+						var parentNode = parent && parent[0] || afterNode && afterNode.parentNode;
+						var afterNextSibling = (afterNode && afterNode.nextSibling) || null;
+						angular.forEach(clone, function (node)
+						{
+							parentNode.insertBefore(node, afterNextSibling);
+						});
+					});
+				};
+
+				var ctrl =
+				{
+					watcherRemover: undefined,
+					binders: [],
+					group: $attrs.boName,
+					element: $element,
+					ran: false,
+
+					addBinder: function (binder)
+					{
+						this.binders.push(binder);
+
+						// In case of late binding (when using the directive bo-name/bo-parent)
+						// it happens only when you use nested bindonce, if the bo-children
+						// are not dom children the linking can follow another order
+						if (this.ran)
+						{
+							this.runBinders();
+						}
+					},
+
+					setupWatcher: function (bindonceValue)
+					{
+						var that = this;
+						this.watcherRemover = $scope.$watch(bindonceValue, function (newValue)
+						{
+							if (newValue === undefined) return;
+							that.removeWatcher();
+							that.checkBindonce(newValue);
+						}, true);
+					},
+
+					checkBindonce: function (value)
+					{
+						var that = this, promise = (value.$promise) ? value.$promise.then : value.then;
+						// since Angular 1.2 promises are no longer 
+						// undefined until they don't get resolved
+						if (typeof promise === 'function')
+						{
+							promise(function ()
+							{
+								that.runBinders();
+							});
+						}
+						else
+						{
+							that.runBinders();
+						}
+					},
+
+					removeWatcher: function ()
+					{
+						if (this.watcherRemover !== undefined)
+						{
+							this.watcherRemover();
+							this.watcherRemover = undefined;
+						}
+					},
+
+					runBinders: function ()
+					{
+						while (this.binders.length > 0)
+						{
+							var binder = this.binders.shift();
+							if (this.group && this.group != binder.group) continue;
+							var value = binder.scope.$eval((binder.interpolate) ? $interpolate(binder.value) : binder.value);
+							switch (binder.attr)
+							{
+								case 'boIf':
+									if (toBoolean(value))
+									{
+										transclude(binder, binder.scope.$new());
+									}
+									break;
+								case 'boSwitch':
+									var selectedTranscludes, switchCtrl = binder.controller[0];
+									if ((selectedTranscludes = switchCtrl.cases['!' + value] || switchCtrl.cases['?']))
+									{
+										binder.scope.$eval(binder.attrs.change);
+										angular.forEach(selectedTranscludes, function (selectedTransclude)
+										{
+											transclude(selectedTransclude, binder.scope.$new());
+										});
+									}
+									break;
+								case 'boSwitchWhen':
+									var ctrl = binder.controller[0];
+									ctrl.cases['!' + binder.attrs.boSwitchWhen] = (ctrl.cases['!' + binder.attrs.boSwitchWhen] || []);
+									ctrl.cases['!' + binder.attrs.boSwitchWhen].push({ transclude: binder.transclude, element: binder.element });
+									break;
+								case 'boSwitchDefault':
+									var ctrl = binder.controller[0];
+									ctrl.cases['?'] = (ctrl.cases['?'] || []);
+									ctrl.cases['?'].push({ transclude: binder.transclude, element: binder.element });
+									break;
+								case 'hide':
+								case 'show':
+									showHideBinder(binder.element, binder.attr, value);
+									break;
+								case 'class':
+									classBinder(binder.element, value);
+									break;
+								case 'text':
+									binder.element.text(value);
+									break;
+								case 'html':
+									binder.element.html(value);
+									break;
+								case 'style':
+									binder.element.css(value);
+									break;
+								case 'src':
+									binder.element.attr(binder.attr, value);
+									if (msie) binder.element.prop('src', value);
+									break;
+								case 'attr':
+									angular.forEach(binder.attrs, function (attrValue, attrKey)
+									{
+										var newAttr, newValue;
+										if (attrKey.match(/^boAttr./) && binder.attrs[attrKey])
+										{
+											newAttr = attrKey.replace(/^boAttr/, '').replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+											newValue = binder.scope.$eval(binder.attrs[attrKey]);
+											binder.element.attr(newAttr, newValue);
+										}
+									});
+									break;
+								case 'href':
+								case 'alt':
+								case 'title':
+								case 'id':
+								case 'value':
+									binder.element.attr(binder.attr, value);
+									break;
+							}
+						}
+						this.ran = true;
+					}
+				};
+
+				return ctrl;
+			}],
+
+			link: function (scope, elm, attrs, bindonceController)
+			{
+				var value = attrs.bindonce && scope.$eval(attrs.bindonce);
+				if (value !== undefined)
+				{
+					bindonceController.checkBindonce(value);
+				}
+				else
+				{
+					bindonceController.setupWatcher(attrs.bindonce);
+					elm.bind("$destroy", bindonceController.removeWatcher);
+				}
+			}
+		};
+
+		return bindonceDirective;
+	});
+
+	angular.forEach(
+	[
+		{ directiveName: 'boShow', attribute: 'show' },
+		{ directiveName: 'boHide', attribute: 'hide' },
+		{ directiveName: 'boClass', attribute: 'class' },
+		{ directiveName: 'boText', attribute: 'text' },
+		{ directiveName: 'boBind', attribute: 'text' },
+		{ directiveName: 'boHtml', attribute: 'html' },
+		{ directiveName: 'boSrcI', attribute: 'src', interpolate: true },
+		{ directiveName: 'boSrc', attribute: 'src' },
+		{ directiveName: 'boHrefI', attribute: 'href', interpolate: true },
+		{ directiveName: 'boHref', attribute: 'href' },
+		{ directiveName: 'boAlt', attribute: 'alt' },
+		{ directiveName: 'boTitle', attribute: 'title' },
+		{ directiveName: 'boId', attribute: 'id' },
+		{ directiveName: 'boStyle', attribute: 'style' },
+		{ directiveName: 'boValue', attribute: 'value' },
+		{ directiveName: 'boAttr', attribute: 'attr' },
+
+		{ directiveName: 'boIf', transclude: 'element', terminal: true, priority: 1000 },
+		{ directiveName: 'boSwitch', require: 'boSwitch', controller: function () { this.cases = {}; } },
+		{ directiveName: 'boSwitchWhen', transclude: 'element', priority: 800, require: '^boSwitch' },
+		{ directiveName: 'boSwitchDefault', transclude: 'element', priority: 800, require: '^boSwitch' }
+	],
+	function (boDirective)
+	{
+		var childPriority = 200;
+		return bindonceModule.directive(boDirective.directiveName, function ()
+		{
+			var bindonceDirective =
+			{
+				priority: boDirective.priority || childPriority,
+				transclude: boDirective.transclude || false,
+				terminal: boDirective.terminal || false,
+				require: ['^bindonce'].concat(boDirective.require || []),
+				controller: boDirective.controller,
+				compile: function (tElement, tAttrs, transclude)
+				{
+					return function (scope, elm, attrs, controllers)
+					{
+						var bindonceController = controllers[0];
+						var name = attrs.boParent;
+						if (name && bindonceController.group !== name)
+						{
+							var element = bindonceController.element.parent();
+							bindonceController = undefined;
+							var parentValue;
+
+							while (element[0].nodeType !== 9 && element.length)
+							{
+								if ((parentValue = element.data('$bindonceController'))
+									&& parentValue.group === name)
+								{
+									bindonceController = parentValue;
+									break;
+								}
+								element = element.parent();
+							}
+							if (!bindonceController)
+							{
+								throw new Error("No bindonce controller: " + name);
+							}
+						}
+
+						bindonceController.addBinder(
+						{
+							element: elm,
+							attr: boDirective.attribute || boDirective.directiveName,
+							attrs: attrs,
+							value: attrs[boDirective.directiveName],
+							interpolate: boDirective.interpolate,
+							group: name,
+							transclude: transclude,
+							controller: controllers.slice(1),
+							scope: scope
+						});
+					};
+				}
+			};
+
+			return bindonceDirective;
+		});
+	})
+})();
diff --git a/modules/ngMeteor-template.js b/modules/ngMeteor-template.js
index f338b69..beed613 100644
--- a/modules/ngMeteor-template.js
+++ b/modules/ngMeteor-template.js
@@ -22,29 +22,105 @@ ngMeteorTemplate.directive('ngTemplate', ['$compile',
 angular.element(document).ready(function() {
 
     // Apply the default flexistrap configuration (to match the old behaviour of the module pre-flexistrap
-    ngMeteor.addFlexistrap(document, 'ngMeteor', '*', false);
+    ngMeteor.addFlexistrap('body', 'ngMeteor', '*', false);
 
     if(Package['iron-router']){
+        Router.scopes = {};
         var oldRun = Router.run;
         Router.run = function() {
+            var routePath = arguments[0].path;
             var runResult = oldRun.apply(this, arguments);
             var templateKey = this._currentController.route.options.template ? this._currentController.route.options.template : this._currentController.route.name;
             var oldRendered = Template[templateKey].rendered;
             Template[templateKey].rendered = function(){
+                Deps.nonreactive(function(){
+                    // Apply flexistrap if one has been configured.
+                    var map = ngMeteor.getFlexistrap(templateKey);
+                    if(!Router.scopes[routePath]){
+                        Router.scopes[routePath] = [];
+                    };
+                    //                console.log("Router scopes");
+                    //                console.log(Router.scopes);
+                    //                console.log("--------------");
+                    if(routePath != '/signup'){
+                        var myScopes = Router.scopes['/signup'];
+                        Router.scopes['/signup'] = [];
+                        _.each(myScopes, function(theScope){
+                            var killScope = function(aScope){
+                                var currentChild = aScope.$$childHead;
+                                if(currentChild){
+                                    while(currentChild) {
+                                        var nextChild = currentChild.$$nextSibling;
+                                        killScope(currentChild);
+                                        currentChild = nextChild;
+                                      //  nextChild = null;
+                                    }
+                                    currentChild = null;
+                                }
 
-                // Apply flexistrap if one has been configured.
-                var map = ngMeteor.getFlexistrap(templateKey);
-                $.each( map, function( key, value ) {
-                    var eleArray = $(key);
-                    _.each(eleArray, function(element){
-                        var moduleList = _.clone(value);
-                      //  if (!element.bootstrapped && !angular.element(element).injector()){
-                        if(!ngMeteor.sgiInjector) {
-                            ngMeteor.sgiInjector = angular.bootstrap(element, moduleList);
-                            element.bootstrapped = true;
-                        }else {
-                                ngMeteor.sgiInjector.invoke(
-                                    ['$compile', '$document', '$rootScope', function ($compile, $document, $rootScope) {
+                                if(aScope.$$watchers) {
+                                    aScope.$$watchers.length = 0;
+                                }
+
+
+
+//                                aScope.$$watchers = null;
+                                aScope.model = null;
+                                aScope.field = null;
+                                aScope.modelId = null;
+                                aScope.xid = null;
+                                aScope.flexiModelname = null;
+                                delete aScope.properties;
+                                delete aScope.fieldPersonEmailsForm;
+                                delete aScope.unwrapped;
+                                delete aScope.model;
+                                delete aScope.field;
+                                delete aScope.modelId;
+                                delete aScope.xid;
+                                delete aScope.flexiModelname;
+                                if(aScope.options){
+                                    aScope.options.length = 0;
+                                    delete aScope.options;
+                                }
+                                if(aScope.collection){
+                                    aScope.collection.length = 0;
+                                    delete aScope.collection;
+                                }
+
+                                delete aScope.personForm;
+                                delete aScope.fieldPersonHomeAddressesForm;
+                                aScope.$destroy();
+                                aScope.$$listeners = {};
+                                aScope.$$listenerCount = {};
+
+                                aScope.__proto__ = {};
+
+                                console.log('destroying: ' + aScope.$id)
+                            };
+                            killScope(theScope);
+                        });
+                        if(myScopes){
+                            // Router.scopes['/signup'].length = 0;
+                            myScopes.length = 0;
+                            myScopes = null;
+                        }
+
+                    }
+                    $.each( map, function( key, value ) {
+                        var eleArray = $(key);
+                        _.each(eleArray, function(element){
+                            var moduleList = _.clone(value);
+                            if (!element.bootstrapped && !angular.element(element).injector()){
+                                console.log('bootstrapping')
+                                var inj = angular.bootstrap(element, moduleList);
+                                inj.invoke(['$rootScope', function($rootScope){Router.scopes[routePath].push($rootScope)}]);
+                                element.bootstrapped = true;
+                            }else {
+                                console.log("did not bootstrap");
+                                //   console.log(element);
+                                //   console.log("-----------");
+                                angular.element(element).injector().invoke(
+                                    ['$compile', '$rootScope', function ($compile, $rootScope) {
                                         if($rootScope.$$childHead){
                                             $rootScope.$$childHead.$destroy();
                                         }
@@ -53,13 +129,14 @@ angular.element(document).ready(function() {
                                     }]
                                 )
 
-                        }
+                            }
+                        });
                     });
+                    if(oldRendered && typeof oldRendered == 'function') {
+                        oldRendered.apply(this, arguments);
+                    };
+                    Template[templateKey].rendered = oldRendered;
                 });
-                if(oldRendered && typeof oldRendered == 'function') {
-                    oldRendered.apply(this, arguments);
-                };
-                Template[templateKey].rendered = oldRendered;
             };
             return runResult;
         };
diff --git a/ngMeteor.js b/ngMeteor.js
index f208b95..41441ba 100644
--- a/ngMeteor.js
+++ b/ngMeteor.js
@@ -56,13 +56,13 @@ ngMeteor.addFlexistrap = function(selector, angularModuleNameOrArray, pathOrArra
 
     _.each(paths, function(ele){
         var pathEntry = this[ele] ? this[ele] : null;
-        if(typeof replaceFlag === 'undefined' || replaceFlag === null){
-            if(typeof pathEntry === 'undefined' || pathEntry === null){
+        if(_.isUndefined(replaceFlag) || _.isNull(replaceFlag)){
+            if(_.isUndefined(pathEntry) || _.isNull(pathEntry)){
                 pathEntry = {};
             }
         }else{
             pathEntry = {};
-            if(!replaceFlag){
+            if(replaceFlag == false){
                 return;
             }
         }
diff --git a/package.js b/package.js
index 005e9b4..fee6523 100644
--- a/package.js
+++ b/package.js
@@ -6,13 +6,11 @@ Package.on_use(function (api) {
     api.use('templating', 'client');
     api.use('underscore', 'client');
 
-	// Exports the ngMeteor package scope
-	api.export('ngMeteor', 'client');
-	
 	// Files to load in Client only.
 	api.add_files([
 		// Lib Files
 		    'lib/angular.js',
+            'lib/bindonce.js',
 		    'lib/angular-csp.css',
 		    'lib/angular-animate.js',
 		    'lib/angular-cookies.js',
@@ -30,4 +28,7 @@ Package.on_use(function (api) {
 		    'ngMeteor.js'
 
 	], 'client');
+
+    // Exports the ngMeteor package scope
+    api.export('ngMeteor', 'client');
 });