refactor(Transition): Remove TransitionRunner class.

feat(Transition): Run onBefore hooks for *all* transitions created, even invalid ones.

Author: christopherthielen

src/resolve/resolvable.ts

@@ -89,7 +89,7 @@ export default class Resolvable {
   }
 
   toString() {
-    return `Resolvable(name: ${this.name}, state: ${this.state.name}, requires: [${this.deps}])`;
+    return `Resolvable(name: ${this.name}, requires: [${this.deps}])`;
   }
 
   /**
@@ -100,6 +100,6 @@ export default class Resolvable {
     let invalid = filter(resolves, not(isFunction)), keys = Object.keys(invalid);
     if (keys.length)
       throw new Error(`Invalid resolve key/value: ${keys[0]}/${invalid[keys[0]]}`);
-    return map(resolves, (fn, name) => new Resolvable(name, fn));
+    return map(resolves, (fn, name: string) => new Resolvable(name, fn));
   }
 }

src/state/hooks/transitionManager.ts

@@ -51,11 +51,8 @@ export default class TransitionManager {
     this.resolveHooks = new ResolveHooks(transition);
 
     this.treeChanges = transition.treeChanges();
-  }
 
-  registerHooks() {
     this.registerUpdateGlobalState();
-
     this.viewHooks.registerHooks();
     this.enterExitHooks.registerHooks();
     this.resolveHooks.registerHooks();
@@ -98,9 +95,7 @@ export default class TransitionManager {
 
       if (error.type === RejectType.SUPERSEDED) {
         if (error.redirected && error.detail instanceof Transition) {
-          let tMgr = this._redirectMgr(error.detail);
-          tMgr.registerHooks();
-          return tMgr.runTransition();
+          return this._redirectMgr(error.detail).runTransition();
         }
       }
     }

src/state/state.ts

@@ -725,13 +725,10 @@ function $StateProvider(   $urlRouterProvider,   $urlMatcherFactoryProvider) {
         return $q.reject(ref.error());
 
       let transition = $transitions.create(currentPath, ref);
-      if (!transition.valid())
-        return $q.reject(transition.error());
-
       let tMgr = new TransitionManager(transition, $transitions, $urlRouter, $view, $state, $stateParams, $q, transQueue, treeChangesQueue);
-      tMgr.registerHooks();
+      let transitionPromise = tMgr.runTransition();
       // Return a promise for the transition, which also has the transition object on it.
-      return extend(tMgr.runTransition(), { transition });
+      return extend(transitionPromise, { transition });
     };
 
     /**

src/state/stateEvents.ts

@@ -13,7 +13,7 @@ import {RejectType} from "../transition/rejectFactory";
 
 stateChangeStartHandler.$inject = ['$transition$', '$stateEvents', '$rootScope', '$urlRouter'];
 function stateChangeStartHandler($transition$: Transition, $stateEvents, $rootScope, $urlRouter) {
-  if (!$transition$.options().notify)
+  if (!$transition$.options().notify || !$transition$.valid() || $transition$.ignored())
     return;
 
   let enabledEvents = $stateEvents.provider.enabled();
@@ -46,15 +46,17 @@ function stateChangeStartHandler($transition$: Transition, $stateEvents, $rootSc
   let toParams = $transition$.params("to");
   let fromParams = $transition$.params("from");
 
-  if (enabledEvents.$stateChangeStart && $rootScope.$broadcast('$stateChangeStart', $transition$.to(), toParams, $transition$.from(), fromParams, $transition$).defaultPrevented) {
-    if (enabledEvents.$stateChangeCancel) {
-      $rootScope.$broadcast('$stateChangeCancel', $transition$.to(), toParams, $transition$.from(), fromParams, $transition$);
+  if (enabledEvents.$stateChangeSuccess) {
+    var startEvent = $rootScope.$broadcast('$stateChangeStart', $transition$.to(), toParams, $transition$.from(), fromParams, $transition$);
+
+    if (startEvent.defaultPrevented) {
+      if (enabledEvents.$stateChangeCancel) {
+        $rootScope.$broadcast('$stateChangeCancel', $transition$.to(), toParams, $transition$.from(), fromParams, $transition$);
+      }
+      $urlRouter.update();
+      return false;
     }
-    $urlRouter.update();
-    return false;
-  }
 
-  if (enabledEvents.$stateChangeSuccess) {
     $transition$.promise.then(function () {
       /**
        * @ngdoc event

src/transition/hookBuilder.ts

@@ -55,7 +55,7 @@ export default class HookBuilder {
   // onBefore/onStart/onFinish/onSuccess/onError returns an array of hooks
   // onExit/onRetain/onEnter returns an array of arrays of hooks
 
-  getOnBeforeHooks  = () => this._buildTransitionHooks("onBefore");
+  getOnBeforeHooks  = () => this._buildTransitionHooks("onBefore", {}, { async: false });
   getOnStartHooks   = () => this._buildTransitionHooks("onStart");
   getOnExitHooks    = () => this._buildNodeHooks("onExit",          this.treeChanges.exiting.reverse(), (node) => this._toFrom({ from: node.state }));
   getOnRetainHooks  = () => this._buildNodeHooks("onRetain",        this.treeChanges.retained,          (node) => this._toFrom());

src/transition/transition.ts

@@ -5,10 +5,10 @@ import trace from "../common/trace";
 
 import {ITransitionOptions, ITransitionHookOptions, ITreeChanges, IHookRegistry, IHookRegistration, IHookGetter} from "./interface";
 import $transitions from "./transitionService";
+import TransitionHook from "./transitionHook";
 import {HookRegistry, matchState} from "./hookRegistry";
 import HookBuilder from "./hookBuilder";
-import TransitionRunner from "./transitionRunner";
-import {RejectFactory} from "./rejectFactory";
+import {RejectFactory, TransitionRejection} from "./rejectFactory";
 
 import Node from "../path/node";
 import PathFactory from "../path/pathFactory";
@@ -27,7 +27,8 @@ import {ViewConfig} from "../view/view";
 
 import {
   map, find, extend, filter, mergeR, flatten, unnest, tail, forEach, identity,
-  omit, isObject, not, prop, propEq, toJson, val, abstractKey, arrayTuples, allTrueR
+  omit, isObject, isPromise, not, prop, propEq, toJson, val, abstractKey,
+  arrayTuples, allTrueR, Predicate
 } from "../common/common";
 
 let transitionCount = 0, REJECT = new RejectFactory();
@@ -164,7 +165,7 @@ export class Transition implements IHookRegistry {
    * @param state (optional) the state in the topath which should receive the new resolves (otherwise, the root state)
    */
   addResolves(resolves: IResolveDeclarations, state: IStateOrName = "") {
-    let stateName = state.name ? state.name : state;
+    let stateName = <string> (<any> state).name ? (<any> state).name : state;
     let topath = this._treeChanges.to;
     let targetNode = find(topath, node => node.state.name === stateName);
     tail(topath).resolveContext.addResolvables(Resolvable.makeResolvables(resolves), targetNode.state);
@@ -309,14 +310,26 @@ export class Transition implements IHookRegistry {
   }
 
   run () {
+    let hookBuilder = this.hookBuilder();
+    let runSynchronousHooks = TransitionHook.runSynchronousHooks;
+    const runSuccessHooks = () => runSynchronousHooks(hookBuilder.getOnSuccessHooks(), {}, true);
+    const runErrorHooks = ($error$) => runSynchronousHooks(hookBuilder.getOnErrorHooks(), { $error$ }, true);
+    // Run the success/error hooks *after* the Transition promise is settled.
+    this.promise.then(runSuccessHooks, runErrorHooks);
+
+    let promiseChain = runSynchronousHooks(hookBuilder.getOnBeforeHooks());
+
+    if (TransitionHook.isRejection(promiseChain)) {
+      this._deferred.reject(promiseChain);
+      return this.promise;
+    }
+
     if (!this.valid()) {
       let error = new Error(this.error());
       this._deferred.reject(error);
-      throw error;
+      return this.promise;
     }
 
-    trace.traceTransitionStart(this);
-
     if (this.ignored()) {
       trace.traceTransitionIgnored(this);
       let ignored = REJECT.ignored();
@@ -336,7 +349,10 @@ export class Transition implements IHookRegistry {
       return runtime.$q.reject(error);
     };
 
-    new TransitionRunner(this, resolve, reject).run();
+    trace.traceTransitionStart(this);
+
+    promiseChain = hookBuilder.asyncHooks().reduce((_chain, step) => _chain.then(step.invokeStep), promiseChain);
+    promiseChain.then(resolve, reject);
 
     return this.promise;
   }

src/transition/transitionHook.ts

@@ -1,7 +1,9 @@
+import {IPromise} from "angular";
 import {IInjectable, defaults, extend, noop, filter, not, isFunction, isDefined, map, pattern, val,
-    eq, is, isPromise, isObject, parse, fnToString, maxLength} from "../common/common";
+    eq, is, isPromise, isObject, parse, fnToString, maxLength, Predicate} from "../common/common";
+import {runtime} from "../common/angular1";
 import trace from "../common/trace";
-import {RejectFactory} from "./rejectFactory";
+import {RejectFactory, TransitionRejection} from "./rejectFactory";
 import {Transition} from "./transition";
 import {State} from "../state/state";
 import {IResolveDeclarations} from "../state/interface";
@@ -78,4 +80,32 @@ export default class TransitionHook {
         name = fnToString(fn);
     return `${event} context: ${context}, ${maxLength(200, name)}`;
   }
+
+
+  /**
+   * Given an array of TransitionHooks, runs each one synchronously and sequentially.
+   *
+   * Returns a promise chain composed of any promises returned from each hook.invokeStep() call
+   */
+  static runSynchronousHooks(hooks: TransitionHook[], locals = {}, swallowExceptions: boolean = false): IPromise<any> {
+    let results = [];
+    for (let i = 0; i < hooks.length; i++) {
+      try {
+        let hookResult = hooks[i].invokeStep(locals);
+        let rejection = TransitionHook.isRejection(hookResult);
+        if (rejection) return rejection;
+        results.push(hookResult);
+      } catch (exception) {
+        if (!swallowExceptions) throw exception;
+        console.log("Swallowed exception during synchronous hook handler: " + exception); // TODO: What to do here?
+      }
+    }
+
+    return results.filter(<Predicate<any>> isPromise).reduce((chain, promise) => chain.then(val(promise)), runtime.$q.when());
+  }
+
+
+  static isRejection(hookResult) {
+    return hookResult && hookResult.reason instanceof TransitionRejection && hookResult;
+  }
 }