feat(shutdown): Add the ability for an app to shutdown

Adds a new `$shutdown` service that can be used to shutdown an app
and the `$shutdownProvider` that can be used to register tasks that
need to be executed when shutting down an app

Author: lgalfaso

src/.jshintrc

@@ -86,6 +86,7 @@
     "angularInit": false,
     "bootstrap": false,
     "getTestability": false,
+    "shutdown": false,
     "snake_case": false,
     "bindJQuery": false,
     "assertArg": false,

src/Angular.js

@@ -1692,7 +1692,7 @@ function bootstrap(element, modules, config) {
 
     modules = modules || [];
     modules.unshift(['$provide', function($provide) {
-      $provide.value('$rootElement', element);
+      $provide.provider('$rootElement', rootElementProviderFactory(element));
     }]);
 
     if (config.debugInfoEnabled) {
@@ -1772,6 +1772,48 @@ function getTestability(rootElement) {
   return injector.get('$$testability');
 }
 
+function rootElementProviderFactory(rootElement) {
+  return ['$shutdownProvider', function($shutdownProvider) {
+    $shutdownProvider.register(function() {
+      if (rootElement.dealoc) {
+        rootElement.dealoc();
+      } else {
+        rootElement.find('*').removeData();
+        rootElement.removeData();
+      }
+    });
+    this.$get = function() {
+      return rootElement;
+    };
+  }];
+}
+
+function $ShutDownProvider() {
+  var fns = [];
+  this.$get = function() {
+    return function() {
+      while (fns.length) {
+        var fn = fns.shift();
+        fn();
+      }
+    };
+  };
+
+  this.register = function(fn) {
+    fns.push(fn);
+  };
+}
+
+function shutdown(element) {
+  var injector;
+
+  injector = angular.element(element).injector();
+  if (!injector) {
+    throw ngMinErr('shtdwn', 'Element not part of an app');
+  }
+  injector.get('$shutdown')();
+}
+
 var SNAKE_CASE_REGEXP = /[A-Z]/g;
 function snake_case(name, separator) {
   separator = separator || '_';

src/AngularPublic.js

@@ -86,6 +86,7 @@
   $$SanitizeUriProvider,
   $SceProvider,
   $SceDelegateProvider,
+  $ShutDownProvider,
   $SnifferProvider,
   $TemplateCacheProvider,
   $TemplateRequestProvider,
@@ -125,6 +126,7 @@ var version = {
 function publishExternalAPI(angular) {
   extend(angular, {
     'bootstrap': bootstrap,
+    'shutdown': shutdown,
     'copy': copy,
     'extend': extend,
     'merge': merge,
@@ -160,6 +162,8 @@ function publishExternalAPI(angular) {
 
   angularModule('ng', ['ngLocale'], ['$provide',
     function ngModule($provide) {
+      // $shutdown provider needs to be first as other providers might use it.
+      $provide.provider('$shutdown', $ShutDownProvider);
       // $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
       $provide.provider({
         $$sanitizeUri: $$SanitizeUriProvider

src/ng/browser.js

@@ -28,7 +28,11 @@ function Browser(window, document, $log, $sniffer) {
       history = window.history,
       setTimeout = window.setTimeout,
       clearTimeout = window.clearTimeout,
-      pendingDeferIds = {};
+      setInterval = window.setInterval,
+      clearInterval = window.clearInterval,
+      pendingDeferIds = {},
+      currentIntervalIds = {},
+      active = true;
 
   self.isMock = false;
 
@@ -79,6 +83,15 @@ function Browser(window, document, $log, $sniffer) {
     }
   };
 
+  self.shutdown = function() {
+    active = false;
+    forEach(currentIntervalIds, function(ignore, intervalId) {
+      delete currentIntervalIds[intervalId];
+      clearInterval(+intervalId);
+    });
+    jqLite(window).off('hashchange popstate', cacheStateAndFireUrlChange);
+  };
+
   //////////////////////////////////////////////////////////////
   // URL API
   //////////////////////////////////////////////////////////////
@@ -270,16 +283,6 @@ function Browser(window, document, $log, $sniffer) {
     return callback;
   };
 
-  /**
-   * @private
-   * Remove popstate and hashchange handler from window.
-   *
-   * NOTE: this api is intended for use only by $rootScope.
-   */
-  self.$$applicationDestroyed = function() {
-    jqLite(window).off('hashchange popstate', cacheStateAndFireUrlChange);
-  };
-
   /**
    * Checks whether the url has changed outside of Angular.
    * Needs to be exported to be able to check for changes that have been done in sync,
@@ -321,12 +324,16 @@ function Browser(window, document, $log, $sniffer) {
    */
   self.defer = function(fn, delay) {
     var timeoutId;
-    outstandingRequestCount++;
-    timeoutId = setTimeout(function() {
-      delete pendingDeferIds[timeoutId];
-      completeOutstandingRequest(fn);
-    }, delay || 0);
-    pendingDeferIds[timeoutId] = true;
+    if (active) {
+      outstandingRequestCount++;
+      timeoutId = setTimeout(function() {
+        delete pendingDeferIds[timeoutId];
+        completeOutstandingRequest(fn);
+      }, delay || 0);
+      pendingDeferIds[timeoutId] = true;
+    } else {
+      timeoutId = 0;
+    }
     return timeoutId;
   };
 
@@ -351,11 +358,57 @@ function Browser(window, document, $log, $sniffer) {
     return false;
   };
 
+
+  /**
+   * @name $browser#interval
+   * @param {function()} fn A function, who's execution should be executed.
+   * @param {number=} interval in milliseconds on how often to execute the function.
+   * @returns {*} IntervalId that can be used to cancel the task via `$browser.interval.cancel()`.
+   *
+   * @description
+   * Executes a fn asynchronously via `setInterval(fn, interval)`.
+   *
+   */
+  self.interval = function(fn, interval) {
+    var intervalId;
+    if (active) {
+      intervalId = setInterval(fn, interval);
+      currentIntervalIds[intervalId] = true;
+    } else {
+      intervalId = 0;
+    }
+    return intervalId;
+  };
+
+
+  /**
+   * @name $browser#interval.cancel
+   *
+   * @description
+   * Cancels a interval task identified with `intervalId`.
+   *
+   * @param {*} intervalId Token returned by the `$browser.interval` function.
+   * @returns {boolean} Returns `true` if the task was successfully canceled, and
+   *          `false` if the task was already canceled.
+   */
+  self.interval.cancel = function(intervalId) {
+    if (currentIntervalIds[intervalId]) {
+      delete currentIntervalIds[intervalId];
+      clearInterval(intervalId);
+      return true;
+    }
+    return false;
+  };
 }
 
-function $BrowserProvider() {
+function $BrowserProvider($shutdownProvider) {
+  var browser;
+
+  $shutdownProvider.register(function() { if (browser) { browser.shutdown(); } });
   this.$get = ['$window', '$log', '$sniffer', '$document',
       function($window, $log, $sniffer, $document) {
-        return new Browser($window, $document, $log, $sniffer);
+        return browser = new Browser($window, $document, $log, $sniffer);
       }];
 }
+
+$BrowserProvider.$inject = ['$shutdownProvider'];

src/ng/interval.js

@@ -135,16 +135,14 @@ function $IntervalProvider() {
     function interval(fn, delay, count, invokeApply) {
       var hasParams = arguments.length > 4,
           args = hasParams ? sliceArgs(arguments, 4) : [],
-          setInterval = $window.setInterval,
-          clearInterval = $window.clearInterval,
           iteration = 0,
           skipApply = (isDefined(invokeApply) && !invokeApply),
           deferred = (skipApply ? $$q : $q).defer(),
           promise = deferred.promise;
 
       count = isDefined(count) ? count : 0;
 
-      promise.$$intervalId = setInterval(function tick() {
+      promise.$$intervalId = $browser.interval(function tick() {
         if (skipApply) {
           $browser.defer(callback);
         } else {
@@ -154,7 +152,7 @@ function $IntervalProvider() {
 
         if (count > 0 && iteration >= count) {
           deferred.resolve(iteration);
-          clearInterval(promise.$$intervalId);
+          $browser.interval.cancel(promise.$$intervalId);
           delete intervals[promise.$$intervalId];
         }
 
@@ -191,7 +189,7 @@ function $IntervalProvider() {
         // Interval cancels should not report as unhandled promise.
         intervals[promise.$$intervalId].promise.catch(noop);
         intervals[promise.$$intervalId].reject('canceled');
-        $window.clearInterval(promise.$$intervalId);
+        $browser.interval.cancel(promise.$$intervalId);
         delete intervals[promise.$$intervalId];
         return true;
       }

src/ng/rootScope.js

@@ -67,11 +67,12 @@
  * They also provide event emission/broadcast and subscription facility. See the
  * {@link guide/scope developer guide on scopes}.
  */
-function $RootScopeProvider() {
+function $RootScopeProvider($shutdownProvider) {
   var TTL = 10;
   var $rootScopeMinErr = minErr('$rootScope');
   var lastDirtyWatch = null;
   var applyAsyncId = null;
+  var $rootScope;
 
   this.digestTtl = function(value) {
     if (arguments.length) {
@@ -94,8 +95,10 @@ function $RootScopeProvider() {
     return ChildScope;
   }
 
-  this.$get = ['$exceptionHandler', '$parse', '$browser',
-      function($exceptionHandler, $parse, $browser) {
+  $shutdownProvider.register(function() { if ($rootScope) { $rootScope.$destroy(); } });
+
+  this.$get = ['$exceptionHandler', '$parse', '$browser', '$shutdown',
+      function($exceptionHandler, $parse, $browser, $shutdown) {
 
     function destroyChildScope($event) {
         $event.currentScope.$$destroyed = true;
@@ -907,8 +910,7 @@ function $RootScopeProvider() {
         this.$$destroyed = true;
 
         if (this === $rootScope) {
-          //Remove handlers attached to window when $rootScope is removed
-          $browser.$$applicationDestroyed();
+          $shutdown();
         }
 
         incrementWatchersCount(this, -this.$$watchersCount);
@@ -1308,7 +1310,7 @@ function $RootScopeProvider() {
       }
     };
 
-    var $rootScope = new Scope();
+    $rootScope = new Scope();
 
     //The internal queues. Expose them on the $rootScope for debugging/testing purposes.
     var asyncQueue = $rootScope.$$asyncQueue = [];
@@ -1374,3 +1376,6 @@ function $RootScopeProvider() {
     }
   }];
 }
+
+$RootScopeProvider.$inject = ['$shutdownProvider'];
+

src/ngMock/angular-mocks.js

@@ -23,12 +23,17 @@ angular.mock = {};
  * The api of this service is the same as that of the real {@link ng.$browser $browser}, except
  * that there are several helper methods available which can be used in tests.
  */
-angular.mock.$BrowserProvider = function() {
+angular.mock.$BrowserProvider = function($shutdownProvider) {
+  var browser;
+
+  $shutdownProvider.register(function() { if (browser) { browser.shutdown(); } });
   this.$get = function() {
-    return new angular.mock.$Browser();
+    return browser = new angular.mock.$Browser();
   };
 };
 
+angular.mock.$BrowserProvider.$inject = ['$shutdownProvider'];
+
 angular.mock.$Browser = function() {
   var self = this;
 
@@ -135,6 +140,52 @@ angular.mock.$Browser = function() {
   self.baseHref = function() {
     return this.$$baseHref;
   };
+
+  self.interval = function(fn, interval) {
+    self.interval.repeatFns.push({
+      nextTime:(self.interval.now + interval),
+      delay: interval,
+      fn: fn,
+      id: self.interval.nextRepeatId
+    });
+    self.interval.repeatFns.sort(function(a,b) { return a.nextTime - b.nextTime;});
+
+    return self.interval.nextRepeatId++;
+  };
+
+  self.interval.cancel = function(id) {
+    var fnIndex;
+
+    angular.forEach(self.interval.repeatFns, function(fn, index) {
+      if (fn.id === id) fnIndex = index;
+    });
+
+    if (fnIndex !== undefined) {
+      self.interval.repeatFns.splice(fnIndex, 1);
+      return true;
+    }
+
+    return false;
+  };
+
+  self.interval.flush = function(millis) {
+    self.interval.now += millis;
+    while (self.interval.repeatFns.length &&
+        self.interval.repeatFns[0].nextTime <= self.interval.now) {
+      var task = self.interval.repeatFns[0];
+      task.fn();
+      task.nextTime += task.delay;
+      self.interval.repeatFns.sort(function(a,b) { return a.nextTime - b.nextTime;});
+    }
+    return millis;
+  };
+
+  self.interval.repeatFns = [];
+  self.interval.nextRepeatId = 0;
+  self.interval.now = 0;
+
+  self.shutdown = angular.noop;
+
 };
 angular.mock.$Browser.prototype = {
 
@@ -2911,10 +2962,8 @@ angular.mock.$RootScopeDecorator = ['$delegate', function($delegate) {
       }
       angular.element.cleanData(cleanUpNodes);
 
-      // Ensure `$destroy()` is available, before calling it
-      // (a mocked `$rootScope` might not implement it (or not even be an object at all))
-      var $rootScope = injector.get('$rootScope');
-      if ($rootScope && $rootScope.$destroy) $rootScope.$destroy();
+      var $shutdown = injector.get('$shutdown');
+      if ($shutdown) $shutdown();
     }
 
     // clean up jquery's fragment cache