refactor(ResolveContext): nuke 'state' param from invokeNow/invokeLater

Author: christopherthielen

src/common/trace.ts

@@ -144,11 +144,11 @@ class Trace {
     console.log(`Transition #${tid} Digest #${digest}:               <- Resolved  ${resolvableStr} to: ${maxLength(200, result)}`);
   }
 
-  tracePathElementInvoke(state, fn, deps, options) {
+  tracePathElementInvoke(node, fn, deps, options) {
     if (!this.enabled(Category.INVOKE)) return;
     let tid = parse("transition.$id")(options),
         digest = this.approximateDigests,
-        stateName = state && state.toString(),
+        stateName = node && node.state && node.state.toString(),
         fnName = functionToString(fn);
     console.log(`Transition #${tid} Digest #${digest}:         Invoke ${options.when}: context: ${stateName} ${maxLength(200, fnName)}`);
   }

src/resolve/resolveContext.ts

@@ -132,16 +132,15 @@ export default class ResolveContext {
    * @param locals: are the angular $injector-style locals to inject
    * @param options: options (TODO: document)
    */
-  invokeLater(state: State, fn: IInjectable, locals: any = {}, options: IOptions1 = {}): IPromise<any> {
-    let isolateCtx = this.isolateRootTo(state);
-    let resolvables = this.getResolvablesForFn(fn, isolateCtx);
-    trace.tracePathElementInvoke(state, fn, Object.keys(resolvables), extend({when: "Later"}, options));
-    const getPromise = (resolvable: Resolvable) => resolvable.get(isolateCtx, options);
+  invokeLater(fn: IInjectable, locals: any = {}, options: IOptions1 = {}): IPromise<any> {
+    let resolvables = this.getResolvablesForFn(fn, this);
+    trace.tracePathElementInvoke(tail(this._path), fn, Object.keys(resolvables), extend({when: "Later"}, options));
+    const getPromise = (resolvable: Resolvable) => resolvable.get(this, options);
     let promises: IPromises = <any> map(resolvables, getPromise);
 
     return runtime.$q.all(promises).then(() => {
       try {
-        return isolateCtx.invokeNow(state, fn, locals, options);
+        return this.invokeNow(fn, locals, options);
       } catch (error) {
         return runtime.$q.reject(error);
       }
@@ -163,13 +162,11 @@ export default class ResolveContext {
    */
   // Injects a function at this PathElement level with available Resolvables
   // Does not wait until all Resolvables have been resolved; you must call PathElement.resolve() (or manually resolve each dep) first
-  invokeNow(state: State, fn: IInjectable, locals: any, options: any = {}) {
-    let isolateCtx = this.isolateRootTo(state);
-    let resolvables = this.getResolvablesForFn(fn, isolateCtx);
-    trace.tracePathElementInvoke(state, fn, Object.keys(resolvables), extend({when: "Now  "}, options));
+  invokeNow(fn: IInjectable, locals: any, options: any = {}) {
+    let resolvables = this.getResolvablesForFn(fn, this);
+    trace.tracePathElementInvoke(tail(this._path), fn, Object.keys(resolvables), extend({when: "Now  "}, options));
     let resolvedLocals = map(resolvables, prop("data"));
-    let combinedLocals = extend({}, locals, resolvedLocals);
-    return runtime.$injector.invoke(<Function> fn, state, combinedLocals);
+    return runtime.$injector.invoke(<Function> fn, null, extend({}, locals, resolvedLocals));
   }
 }
 

src/resolve/resolveInjector.ts

@@ -8,12 +8,12 @@ export default class ResolveInjector {
 
   /** Returns a promise to invoke an annotated function in the resolve context */
   invokeLater(injectedFn, locals) {
-    return this._resolveContext.invokeLater(this._state, injectedFn, locals);
+    return this._resolveContext.invokeLater(injectedFn, locals);
   }
 
   /** Invokes an annotated function in the resolve context */
   invokeNow(injectedFn, locals) {
-    return this._resolveContext.invokeNow(this._state, injectedFn, locals);
+    return this._resolveContext.invokeNow(null, injectedFn, locals);
   }
 
   /** Returns the a promise for locals (realized Resolvables) that a function wants */

src/transition/transitionHook.ts

@@ -58,10 +58,10 @@ export default class TransitionHook {
 
     // TODO: Need better integration of returned promises in synchronous code.
     if (!options.async) {
-      let hookResult = resolveContext.invokeNow(state, fn, locals, options);
+      let hookResult = resolveContext.invokeNow(fn, locals, options);
       return this.handleHookResult(hookResult);
     }
-    return resolveContext.invokeLater(state, fn, locals, options).then(this.handleHookResult.bind(this));
+    return resolveContext.invokeLater(fn, locals, options).then(this.handleHookResult.bind(this));
   };
 
   /**

test/resolveSpec.ts

@@ -242,7 +242,7 @@ describe('Resolvables system:', function () {
       let result;
 
       let onEnter1 = function (_C2) { result = _C2; };
-      let promise = ctx.invokeLater(statesMap["C"], onEnter1, {});
+      let promise = ctx.invokeLater(onEnter1, {});
       promise.then(function (data) {
         expect(result).toBe("C2");
         expect(getResolvedData(ctx)).toEqualData({_C2: "C2"});
@@ -260,7 +260,7 @@ describe('Resolvables system:', function () {
 
       let result;
       let cOnEnter1 = function (_C2) { result = _C2; };
-      let promise = ctx.invokeLater(statesMap["C"], cOnEnter1, {});
+      let promise = ctx.invokeLater(cOnEnter1, {});
       promise.then(function (data) {
         expect(result).toBe("C2");
         expect(getResolvedData(ctx)).toEqualData({_C2: "C2"})
@@ -270,7 +270,7 @@ describe('Resolvables system:', function () {
       expect(asyncCount).toBe(1);
 
       let cOnEnter2 = function (_C) { result = _C; };
-      promise = ctx.invokeLater(statesMap["C"], cOnEnter2, {});
+      promise = ctx.invokeLater(cOnEnter2, {});
       promise.then(function (data) {
         expect(result).toBe("ABC");
         expect(getResolvedData(ctx)).toEqualData({_A: "A", _B: "B", _C: "ABC", _C2: "C2"})
@@ -283,12 +283,12 @@ describe('Resolvables system:', function () {
 
   describe('invokeLater', function () {
     it('should Error if the onEnter dependency cannot be injected', inject(function ($q) {
-      let path = makePath([ "A", "B", "C", "D" ]);
+      let path = makePath([ "A", "B", "C" ]);
       let ctx = new ResolveContext(path);
 
       let cOnEnter = function (_D) {  };
       let caught;
-      let promise = ctx.invokeLater(statesMap["C"], cOnEnter, {});
+      let promise = ctx.invokeLater(cOnEnter, {});
       promise.catch(function (err) {
         caught = err;
         asyncCount++;
@@ -311,7 +311,7 @@ describe('Resolvables system:', function () {
         result = _D;
       };
 
-      let promise = ctx.invokeLater(statesMap["D"], dOnEnter, {});
+      let promise = ctx.invokeLater(dOnEnter, {});
       promise.then(function () {
         expect(result).toBe("D1D2");
         expect(getResolvedData(ctx)).toEqualData({_D: "D1D2", _D2: "D2"})
@@ -333,7 +333,7 @@ describe('Resolvables system:', function () {
         result = _F;
       };
 
-      let promise = ctx.invokeLater(statesMap["F"], fOnEnter, {});
+      let promise = ctx.invokeLater(fOnEnter, {});
       promise.then(function () {
         expect(result).toBe("_EF");
         asyncCount++;
@@ -365,7 +365,7 @@ describe('Resolvables system:', function () {
         result = _H;
       };
 
-      promise = ctx.invokeLater(statesMap["H"], hOnEnter, {});
+      promise = ctx.invokeLater(hOnEnter, {});
       promise.then(function (data) {
         expect(result).toBe("G_GH");
         asyncCount++;
@@ -384,7 +384,7 @@ describe('Resolvables system:', function () {
       // let iPathElement = path.elements[1];
       let iOnEnter = function (_I) {  };
       let caught;
-      let promise = ctx.invokeLater(statesMap["I"], iOnEnter, {});
+      let promise = ctx.invokeLater(iOnEnter, {});
       promise.catch(function (err) {
         caught = err;
         asyncCount++;
@@ -432,13 +432,13 @@ describe('Resolvables system:', function () {
         result = _K;
         onEnterCount++;
       };
-      let promise = ctx.invokeLater(statesMap["K"], kOnEnter, {});
+      let promise = ctx.invokeLater(kOnEnter, {});
       promise.then(checkCounts);
       $q.flush();
       expect(onEnterCount).toBe(1);
 
       // invoke again
-      promise = ctx.invokeLater(statesMap["K"], kOnEnter, {});
+      promise = ctx.invokeLater(kOnEnter, {});
       promise.then(checkCounts);
       $q.flush();
       expect(onEnterCount).toBe(2);

test/stateSpec.js

@@ -224,9 +224,9 @@ describe('state', function () {
   }));
 
   var log, logEvents, logEnterExit;
-  function callbackLogger(what) {
+  function callbackLogger(state, what) {
     return function () {
-      if (logEnterExit) log += this.name + '.' + what + ';';
+      if (logEnterExit) log += state.name + '.' + what + ';';
     };
   }
 
@@ -254,8 +254,8 @@ describe('state', function () {
 
   beforeEach(module(function ($stateProvider, $provide) {
     angular.forEach([ A, B, C, D, DD, E, H, HH, HHH ], function (state) {
-      state.onEnter = callbackLogger('onEnter');
-      state.onExit = callbackLogger('onExit');
+      state.onEnter = callbackLogger(state, 'onEnter');
+      state.onExit = callbackLogger(state, 'onExit');
     });
     stateProvider = $stateProvider;