Skip to content

Commit e4a1f19

Browse files
christopherthielenchristopherthielen
committed
BC-BREAK: remove ResolveContext.getResolvables() in favor of .getToken() and .getResolvable()`
BC-BREAK: remove `ResolveContext.invokeLater()` and `.invokeNow()` BC-BREAK: remove support for `JIT` resolves This also obviates the need for the `loadAllControllerLocals` hook
1 parent 0896646 commit e4a1f19

File tree

2 files changed

+46
-136
lines changed

2 files changed

+46
-136
lines changed

‎test/core/resolveSpec.ts

Lines changed: 34 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,10 @@ var states, statesTree, statesMap: { [key:string]: State } = {};
2020
var vals, counts, expectCounts;
2121
var asyncCount;
2222

23+
function invokeLater(fn: Function, ctx: ResolveContext) {
24+
return new Resolvable("", fn, services.$injector.annotate(fn)).get(ctx)
25+
}
26+
2327
function getStates() {
2428
return {
2529
A: { resolve: { _A: function () { return "A"; }, _A2: function() { return "A2"; }},
@@ -36,15 +40,15 @@ function getStates() {
3640
},
3741
I: { resolve: { _I: function(_I) { return "I"; } } }
3842
},
39-
J: { resolvePolicy: "JIT", resolve: { _J: function() { counts['_J']++; return "J"; }, _J2: function(_J) { counts['_J2']++; return _J + "J2"; } },
40-
K: { resolvePolicy: "JIT", resolve: { _K: function(_J2) { counts['_K']++; return _J2 + "K"; }},
41-
L: { resolvePolicy: "JIT", resolve: { _L: function(_K) { counts['_L']++; return _K + "L"; }},
42-
M: { resolvePolicy: "JIT", resolve: { _M: function(_L) { counts['_M']++; return _L + "M"; }} }
43+
J: { resolve: { _J: function() { counts['_J']++; return "J"; }, _J2: function(_J) { counts['_J2']++; return _J + "J2"; } },
44+
K: { resolve: { _K: function(_J2) { counts['_K']++; return _J2 + "K"; }},
45+
L: { resolve: { _L: function(_K) { counts['_L']++; return _K + "L"; }},
46+
M: { resolve: { _M: function(_L) { counts['_M']++; return _L + "M"; }} }
4347
}
4448
},
4549
N: {
4650
resolve: { _N: function(_J) { return _J + "N"; }, _N2: function(_J) { return _J + "N2"; }, _N3: function(_J) { return _J + "N3"; } },
47-
resolvePolicy: { _N: "EAGER", _N2: "LAZY", _N3: "JIT" }
51+
resolvePolicy: { _N: "EAGER", _N2: "LAZY", _N3: "LAZY" }
4852
}
4953
},
5054
O: { resolve: { _O: function(_O2) { return _O2 + "O"; }, _O2: function(_O) { return _O + "O2"; } } },
@@ -93,7 +97,9 @@ function makePath(names: string[]): PathNode[] {
9397
}
9498

9599
function getResolvedData(pathContext: ResolveContext) {
96-
return map(filter(pathContext.getResolvables(), r => r.name !== '$stateParams'), prop("data"));
100+
return pathContext.getTokens().filter(t => t !== '$stateParams')
101+
.map(token => pathContext.getResolvable(token))
102+
.reduce((acc, resolvable) => { acc[resolvable.token] = resolvable.data; return acc; }, {});
97103
}
98104

99105

@@ -113,7 +119,7 @@ describe('Resolvables system:', function () {
113119
let ctx = new ResolveContext(path);
114120
ctx.resolvePathElement(statesMap["B"]).then(function () {
115121
expect(getResolvedData(ctx)).toEqualData({_B: "B", _B2: "B2" });
116-
expect(ctx.getResolvables()["_A"]).toBeDefined();
122+
expect(ctx.getResolvable("_A")).toBeDefined();
117123
}).then(done);
118124
});
119125

@@ -129,7 +135,7 @@ describe('Resolvables system:', function () {
129135
let path = makePath([ "J", "N" ]);
130136
let ctx = new ResolveContext(path);
131137
ctx.resolvePathElement(statesMap["N"], { resolvePolicy: "LAZY" }).then(function () {
132-
expect(getResolvedData(ctx)).toEqualData({ _J: "J", _N: "JN", _N2: "JN2" });
138+
expect(getResolvedData(ctx)).toEqualData({ _J: "J", _N: "JN", _N2: "JN2", _N3: "JN3"});
133139
}).then(done);
134140
});
135141
});
@@ -138,9 +144,8 @@ describe('Resolvables system:', function () {
138144
it('should return Resolvables from the deepest element and all ancestors', () => {
139145
let path = makePath([ "A", "B", "C" ]);
140146
let ctx = new ResolveContext(path);
141-
let resolvableLocals = ctx.getResolvables(statesMap["C"]);
142-
let keys = Object.keys(resolvableLocals).sort();
143-
expect(keys).toEqual( [ "_A", "_A2", "_B", "_B2", "_C", "_C2" ] );
147+
let tokens = ctx.getTokens().sort();
148+
expect(tokens).toEqual( [ "_A", "_A2", "_B", "_B2", "_C", "_C2" ] );
144149
});
145150
});
146151

@@ -165,7 +170,7 @@ describe('Resolvables system:', function () {
165170
let path = makePath([ "J", "N" ]);
166171
let ctx = new ResolveContext(path);
167172
ctx.resolvePath({ resolvePolicy: "LAZY" }).then(function () {
168-
expect(getResolvedData(ctx)).toEqualData({ _J: "J", _N: "JN", _N2: "JN2"});
173+
expect(getResolvedData(ctx)).toEqualData({ _J: "J", _J2: "JJ2", _N: "JN", _N2: "JN2", _N3: "JN3"});
169174
}).then(done);
170175
});
171176
});
@@ -174,7 +179,7 @@ describe('Resolvables system:', function () {
174179
it('should resolve one Resolvable, and its deps', done => {
175180
let path = makePath([ "A", "B", "C" ]);
176181
let ctx = new ResolveContext(path);
177-
ctx.getResolvables()["_C"].resolve(ctx).then(function () {
182+
ctx.getResolvable("_C").resolve(ctx).then(function () {
178183
expect(getResolvedData(ctx)).toEqualData({ _A: "A", _B: "B",_C: "ABC" });
179184
}).then(done);
180185
});
@@ -187,7 +192,7 @@ describe('Resolvables system:', function () {
187192
let result;
188193

189194
let onEnter1 = function (_C2) { result = _C2; };
190-
ctx.invokeLater(onEnter1, {}).then(function () {
195+
invokeLater(onEnter1, ctx).then(function () {
191196
expect(result).toBe("C2");
192197
expect(getResolvedData(ctx)).toEqualData({_C2: "C2"});
193198
}).then(done);
@@ -203,10 +208,10 @@ describe('Resolvables system:', function () {
203208
let cOnEnter1 = function (_C2) { result = _C2; };
204209
let cOnEnter2 = function (_C) { result = _C; };
205210

206-
ctx.invokeLater(cOnEnter1, {}).then(() => {
211+
invokeLater(cOnEnter1, ctx).then(() => {
207212
expect(result).toBe("C2");
208213
expect(getResolvedData(ctx)).toEqualData({_C2: "C2"});
209-
}).then(() => ctx.invokeLater(cOnEnter2, {})).then(() => {
214+
}).then(() => invokeLater(cOnEnter2, ctx)).then(() => {
210215
expect(result).toBe("ABC");
211216
expect(getResolvedData(ctx)).toEqualData({_A: "A", _B: "B", _C: "ABC", _C2: "C2"});
212217
}).then(done);
@@ -219,7 +224,7 @@ describe('Resolvables system:', function () {
219224
let ctx = new ResolveContext(path);
220225

221226
let cOnEnter = function (_D) { };
222-
ctx.invokeLater(cOnEnter, {}).catch(function (err) {
227+
invokeLater(cOnEnter, ctx).catch(function (err) {
223228
expect(err.message).toContain('Could not find Dependency Injection token: "_D"');
224229
done();
225230
});
@@ -237,7 +242,7 @@ describe('Resolvables system:', function () {
237242
result = _D;
238243
};
239244

240-
ctx.invokeLater(dOnEnter, {}).then(function () {
245+
invokeLater(dOnEnter, ctx).then(function () {
241246
expect(result).toBe("D1D2");
242247
expect(getResolvedData(ctx)).toEqualData({_D: "D1D2", _D2: "D2"});
243248
}).then(done);
@@ -254,7 +259,7 @@ describe('Resolvables system:', function () {
254259
result = _F;
255260
};
256261

257-
ctx.invokeLater(fOnEnter, {}).then(function () {
262+
invokeLater(fOnEnter, ctx).then(function () {
258263
expect(result).toBe("_EF");
259264
}).then(done);
260265
});
@@ -269,9 +274,9 @@ describe('Resolvables system:', function () {
269274
let result;
270275
let ctx = new ResolveContext(path);
271276

272-
ctx.getResolvables()["_G"].get(ctx).then(data => {
277+
ctx.getResolvable("_G").get(ctx).then(data => {
273278
expect(data).toBe("G_G");
274-
}).then(() => ctx.invokeLater(hOnEnter, {})).then(() => {
279+
}).then(() => invokeLater(hOnEnter, ctx)).then(() => {
275280
expect(result).toBe("G_GH");
276281
}).then(done);
277282
});
@@ -284,7 +289,7 @@ describe('Resolvables system:', function () {
284289

285290
// let iPathElement = path.elements[1];
286291
let iOnEnter = function (_I) { };
287-
let promise = ctx.invokeLater(iOnEnter, {});
292+
let promise = invokeLater(iOnEnter, ctx);
288293
promise.catch(function (err) {
289294
expect(err.message).toContain('Could not find Dependency Injection token: "_I"');
290295
done();
@@ -298,7 +303,7 @@ describe('Resolvables system:', function () {
298303
let ctx = new ResolveContext(path);
299304

300305
var iOnEnter = function (_O) { };
301-
ctx.invokeLater(iOnEnter, {}).catch(function (err) {
306+
invokeLater(iOnEnter, ctx).catch(function (err) {
302307
expect(err.message).toContain("[$injector:unpr] Unknown provider: _IProvider ");
303308
done();
304309
});
@@ -323,9 +328,9 @@ describe('Resolvables system:', function () {
323328
result = _K;
324329
onEnterCount++;
325330
};
326-
ctx.invokeLater(kOnEnter, {})
331+
invokeLater(kOnEnter, ctx)
327332
.then(checkCounts)
328-
.then(() => ctx.invokeLater(kOnEnter, {}))
333+
.then(() => invokeLater(kOnEnter, ctx))
329334
.then(checkCounts)
330335
.then(done)
331336
});
@@ -341,12 +346,12 @@ describe('Resolvables system:', function () {
341346
expect(counts["_J"]).toBe(0);
342347
expect(counts["_J2"]).toBe(0);
343348

344-
ctx1.resolvePath({ resolvePolicy: "JIT" }).then(function () {
349+
ctx1.resolvePath({ resolvePolicy: "LAZY" }).then(function () {
345350
expect(counts["_J"]).toBe(1);
346351
expect(counts["_J2"]).toBe(1);
347352
expect(counts["_K"]).toBe(1);
348353
asyncCount++;
349-
}).then(() => ctx2.resolvePath({ resolvePolicy: "JIT" })).then(() => {
354+
}).then(() => ctx2.resolvePath({ resolvePolicy: "LAZY" })).then(() => {
350355
expect(counts["_J"]).toBe(1);
351356
expect(counts["_J2"]).toBe(1);
352357
expect(counts["_K"]).toBe(1);
@@ -360,7 +365,7 @@ describe('Resolvables system:', function () {
360365
it('should create a partial path from an original path', done => {
361366
let path = makePath([ "J", "K", "L" ]);
362367
let ctx1 = new ResolveContext(path);
363-
ctx1.resolvePath({ resolvePolicy: 'JIT' }).then(function () {
368+
ctx1.resolvePath({ resolvePolicy: 'LAZY' }).then(function () {
364369
expect(counts["_J"]).toBe(1);
365370
expect(counts["_J2"]).toBe(1);
366371
expect(counts["_K"]).toBe(1);
@@ -373,7 +378,7 @@ describe('Resolvables system:', function () {
373378
}).then(() => {
374379
let path2 = path.concat(makePath([ "L", "M" ]));
375380
let ctx2 = new ResolveContext(path2);
376-
return ctx2.resolvePath({resolvePolicy: "JIT"});
381+
return ctx2.resolvePath({resolvePolicy: "LAZY"});
377382
}).then(() => {
378383
expect(counts["_J"]).toBe(1);
379384
expect(counts["_J2"]).toBe(1);

‎test/ng1/resolveSpec.ts

Lines changed: 12 additions & 107 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,8 @@ import {
88

99
import Spy = jasmine.Spy;
1010
import {tail} from "../../src/common/common";
11+
import {Resolvable} from "../../src/resolve/resolvable";
12+
import {services} from "../../src/common/coreservices";
1113

1214
let module = angular.mock.module;
1315
///////////////////////////////////////////////
@@ -17,6 +19,10 @@ var emptyPath;
1719
var vals, counts, expectCounts;
1820
var asyncCount;
1921

22+
function invokeLater(fn: Function, ctx: ResolveContext) {
23+
return new Resolvable("", fn, services.$injector.annotate(fn)).get(ctx)
24+
}
25+
2026
function getStates() {
2127
return {
2228
A: { resolve: { _A: function () { return "A"; }, _A2: function() { return "A2"; }},
@@ -33,15 +39,15 @@ function getStates() {
3339
},
3440
I: { resolve: { _I: function(_I) { return "I"; } } }
3541
},
36-
J: { resolvePolicy: "JIT", resolve: { _J: function() { counts['_J']++; return "J"; }, _J2: function(_J) { counts['_J2']++; return _J + "J2"; } },
37-
K: { resolvePolicy: "JIT", resolve: { _K: function(_J2) { counts['_K']++; return _J2 + "K"; }},
38-
L: { resolvePolicy: "JIT", resolve: { _L: function(_K) { counts['_L']++; return _K + "L"; }},
39-
M: { resolvePolicy: "JIT", resolve: { _M: function(_L) { counts['_M']++; return _L + "M"; }} }
42+
J: { resolve: { _J: function() { counts['_J']++; return "J"; }, _J2: function(_J) { counts['_J2']++; return _J + "J2"; } },
43+
K: { resolve: { _K: function(_J2) { counts['_K']++; return _J2 + "K"; }},
44+
L: { resolve: { _L: function(_K) { counts['_L']++; return _K + "L"; }},
45+
M: { resolve: { _M: function(_L) { counts['_M']++; return _L + "M"; }} }
4046
}
4147
},
4248
N: {
4349
resolve: { _N: function(_J) { return _J + "N"; }, _N2: function(_J) { return _J + "N2"; }, _N3: function(_J) { return _J + "N3"; } },
44-
resolvePolicy: { _N: "EAGER", _N2: "LAZY", _N3: "JIT" }
50+
resolvePolicy: { _N: "EAGER", _N2: "LAZY", _N3: "LAZY" }
4551
}
4652
},
4753
O: { resolve: { _O: function(_O2) { return _O2 + "O"; }, _O2: function(_O) { return _O + "O2"; } } },
@@ -85,11 +91,6 @@ function makePath(names: string[]): PathNode[] {
8591
return PathFactory.bindResolveContexts(nodes);
8692
}
8793

88-
function getResolvedData(pathContext: ResolveContext) {
89-
return map(pathContext.getResolvables(), prop("data"));
90-
}
91-
92-
9394
describe('Resolvables system:', function () {
9495
beforeEach(inject(function ($transitions, $injector) {
9596
emptyPath = [];
@@ -426,102 +427,6 @@ describe("$resolve", function () {
426427
});
427428

428429

429-
describe("State transitions with resolves", function() {
430-
var stateDefs: any = statesMap;
431-
beforeEach(module(function($stateProvider) {
432-
// allow tests to specify controllers after registration
433-
function controllerProvider(state) {
434-
return function() {
435-
return stateDefs[state.name].controller || function emptyController() {}
436-
}
437-
}
438-
439-
angular.forEach(stateDefs, function(state: StateDeclaration, key) {
440-
if (!key) return;
441-
state.template = "<div ui-view></div> state"+key;
442-
state.controllerProvider = controllerProvider(state);
443-
$stateProvider.state(key, state);
444-
});
445-
}));
446-
447-
var $state, $transitions, $q, $compile, $rootScope, $scope, $timeout;
448-
beforeEach(inject(function (_$transitions_, _$state_, _$q_, _$compile_, _$rootScope_, _$timeout_, $injector) {
449-
$state = _$state_;
450-
$transitions = _$transitions_;
451-
$q = _$q_;
452-
$compile = _$compile_;
453-
$rootScope = _$rootScope_;
454-
$timeout = _$timeout_;
455-
$scope = $rootScope.$new();
456-
emptyPath = [];
457-
asyncCount = 0;
458-
$compile(angular.element("<div ui-view></div>"))($scope);
459-
}));
460-
461-
function flush() {
462-
$q.flush();
463-
$timeout.flush();
464-
}
465-
466-
function testGo(state, params?, options?) {
467-
$state.go(state, params, options);
468-
$q.flush();
469-
expect($state.current).toBe($state.get(state));
470-
}
471-
472-
it("should not resolve jit resolves that are not injected anywhere", inject(function() {
473-
testGo("J");
474-
expect(counts).toEqualData(expectCounts);
475-
testGo("K");
476-
expect(counts).toEqualData(expectCounts);
477-
}));
478-
479-
it("should invoke jit resolves when they are injected", inject(function() {
480-
stateDefs.J.controller = function JController(_J) { };
481-
482-
testGo("J");
483-
expectCounts._J++;
484-
expect(counts).toEqualData(expectCounts);
485-
}));
486-
487-
it("should invoke jit resolves only when injected", inject(function() {
488-
stateDefs.K.controller = function KController(_K) { };
489-
490-
testGo("J");
491-
expect(counts).toEqualData(expectCounts);
492-
493-
testGo("K");
494-
expectCounts._K++;
495-
expectCounts._J++;
496-
expectCounts._J2++;
497-
expect(counts).toEqualData(expectCounts);
498-
}));
499-
500-
it("should not re-invoke jit resolves", inject(function() {
501-
stateDefs.J.controller = function JController(_J) { };
502-
stateDefs.K.controller = function KController(_K) { };
503-
testGo("J");
504-
expectCounts._J++;
505-
expect(counts).toEqualData(expectCounts);
506-
507-
testGo("K");
508-
509-
expectCounts._K++;
510-
expectCounts._J2++;
511-
expect(counts).toEqualData(expectCounts);
512-
}));
513-
514-
// TODO: remove JIT resolve feature
515-
xit("should invoke jit resolves during a transition that are injected in a hook like onEnter", inject(function() {
516-
stateDefs.J.onEnter = function onEnter(_J) {};
517-
testGo("J");
518-
expectCounts._J++;
519-
expect(counts).toEqualData(expectCounts);
520-
}));
521-
});
522-
523-
524-
525430
// Integration tests
526431
describe("Integration: Resolvables system", () => {
527432
beforeEach(module(function ($stateProvider) {
@@ -548,7 +453,7 @@ describe("Integration: Resolvables system", () => {
548453
$transitions.onStart({to: "J"}, ($transition$) => {
549454
// TODO: use lazy resolve for test, not JIT resolve
550455
var ctx = tail($transition$.treeChanges().to).resolveContext;
551-
return ctx.invokeLater(function (_J) {}).then(function() {
456+
return invokeLater(function (_J) {}, ctx).then(function() {
552457
expect(counts._J).toEqualData(1);
553458
return $state.target("K");
554459
});

0 commit comments

Comments
 (0)