cargdev/angular
1
0
Fork 0
Code Issues 16 Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(): use const and let instead of var

Browse Source
This commit is contained in:
Joao Dias
2016-11-12 14:08:58 +01:00
committed by Victor Berchet
parent 73593d4bf3
commit 77ee27c59e
435 changed files with 4637 additions and 4663 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
modules/@angular/core/test/di/forward_ref_spec.ts
View File

@ -13,7 +13,7 @@ import {describe, expect, it} from '@angular/core/testing/testing_internal';
export function main() {
describe('forwardRef', function() {
it('should wrap and unwrap the reference', () => {
var ref = forwardRef(() => String);
const ref = forwardRef(() => String);
expect(ref instanceof Type).toBe(true);
expect(resolveForwardRef(ref)).toBe(String);
});

166
modules/@angular/core/test/di/reflective_injector_spec.ts
View File

@ -74,7 +74,7 @@ class NoAnnotations {
function factoryFn(a: any) {}
export function main() {
var dynamicProviders = [
const dynamicProviders = [
{provide: 'provider0', useValue: 1}, {provide: 'provider1', useValue: 1},
{provide: 'provider2', useValue: 1}, {provide: 'provider3', useValue: 1},
{provide: 'provider4', useValue: 1}, {provide: 'provider5', useValue: 1},
@ -90,7 +90,7 @@ export function main() {
}].forEach((context) => {
function createInjector(
providers: Provider[], parent: ReflectiveInjector = null): ReflectiveInjector_ {
var resolvedProviders = ReflectiveInjector.resolve(providers.concat(context['providers']));
const resolvedProviders = ReflectiveInjector.resolve(providers.concat(context['providers']));
if (isPresent(parent)) {
return <ReflectiveInjector_>parent.createChildFromResolved(resolvedProviders);
} else {
@ -100,28 +100,28 @@ export function main() {
describe(`injector ${context['strategy']}`, () => {
it('should use the right strategy', () => {
var injector = createInjector([]);
const injector = createInjector([]);
expect(injector.internalStrategy).toBeAnInstanceOf(context['strategyClass']);
});
it('should instantiate a class without dependencies', () => {
var injector = createInjector([Engine]);
var engine = injector.get(Engine);
const injector = createInjector([Engine]);
const engine = injector.get(Engine);
expect(engine).toBeAnInstanceOf(Engine);
});
it('should resolve dependencies based on type information', () => {
var injector = createInjector([Engine, Car]);
var car = injector.get(Car);
const injector = createInjector([Engine, Car]);
const car = injector.get(Car);
expect(car).toBeAnInstanceOf(Car);
expect(car.engine).toBeAnInstanceOf(Engine);
});
it('should resolve dependencies based on @Inject annotation', () => {
var injector = createInjector([TurboEngine, Engine, CarWithInject]);
var car = injector.get(CarWithInject);
const injector = createInjector([TurboEngine, Engine, CarWithInject]);
const car = injector.get(CarWithInject);
expect(car).toBeAnInstanceOf(CarWithInject);
expect(car.engine).toBeAnInstanceOf(TurboEngine);
@ -144,28 +144,28 @@ export function main() {
});
it('should cache instances', () => {
var injector = createInjector([Engine]);
const injector = createInjector([Engine]);
var e1 = injector.get(Engine);
var e2 = injector.get(Engine);
const e1 = injector.get(Engine);
const e2 = injector.get(Engine);
expect(e1).toBe(e2);
});
it('should provide to a value', () => {
var injector = createInjector([{provide: Engine, useValue: 'fake engine'}]);
const injector = createInjector([{provide: Engine, useValue: 'fake engine'}]);
var engine = injector.get(Engine);
const engine = injector.get(Engine);
expect(engine).toEqual('fake engine');
});
it('should provide to a factory', () => {
function sportsCarFactory(e: any /** TODO #9100 */) { return new SportsCar(e); }
var injector =
const injector =
createInjector([Engine, {provide: Car, useFactory: sportsCarFactory, deps: [Engine]}]);
var car = injector.get(Car);
const car = injector.get(Car);
expect(car).toBeAnInstanceOf(SportsCar);
expect(car.engine).toBeAnInstanceOf(Engine);
});
@ -173,7 +173,7 @@ export function main() {
it('should throw when using a factory with more than 20 dependencies', () => {
function factoryWithTooManyArgs() { return new Car(null); }
var injector = createInjector([
const injector = createInjector([
Engine, {
provide: Car,
useFactory: factoryWithTooManyArgs,
@ -195,52 +195,52 @@ export function main() {
});
it('should supporting provider to null', () => {
var injector = createInjector([{provide: Engine, useValue: null}]);
var engine = injector.get(Engine);
const injector = createInjector([{provide: Engine, useValue: null}]);
const engine = injector.get(Engine);
expect(engine).toBeNull();
});
it('should provide to an alias', () => {
var injector = createInjector([
const injector = createInjector([
Engine, {provide: SportsCar, useClass: SportsCar},
{provide: Car, useExisting: SportsCar}
]);
var car = injector.get(Car);
var sportsCar = injector.get(SportsCar);
const car = injector.get(Car);
const sportsCar = injector.get(SportsCar);
expect(car).toBeAnInstanceOf(SportsCar);
expect(car).toBe(sportsCar);
});
it('should support multiProviders', () => {
var injector = createInjector([
const injector = createInjector([
Engine, {provide: Car, useClass: SportsCar, multi: true},
{provide: Car, useClass: CarWithOptionalEngine, multi: true}
]);
var cars = injector.get(Car);
const cars = injector.get(Car);
expect(cars.length).toEqual(2);
expect(cars[0]).toBeAnInstanceOf(SportsCar);
expect(cars[1]).toBeAnInstanceOf(CarWithOptionalEngine);
});
it('should support multiProviders that are created using useExisting', () => {
var injector = createInjector(
const injector = createInjector(
[Engine, SportsCar, {provide: Car, useExisting: SportsCar, multi: true}]);
var cars = injector.get(Car);
const cars = injector.get(Car);
expect(cars.length).toEqual(1);
expect(cars[0]).toBe(injector.get(SportsCar));
});
it('should throw when the aliased provider does not exist', () => {
var injector = createInjector([{provide: 'car', useExisting: SportsCar}]);
var e = `No provider for ${stringify(SportsCar)}! (car -> ${stringify(SportsCar)})`;
const injector = createInjector([{provide: 'car', useExisting: SportsCar}]);
const e = `No provider for ${stringify(SportsCar)}! (car -> ${stringify(SportsCar)})`;
expect(() => injector.get('car')).toThrowError(e);
});
it('should handle forwardRef in useExisting', () => {
var injector = createInjector([
const injector = createInjector([
{provide: 'originalEngine', useClass: forwardRef(() => Engine)},
{provide: 'aliasedEngine', useExisting: <any>forwardRef(() => 'originalEngine')}
]);
@ -248,37 +248,37 @@ export function main() {
});
it('should support overriding factory dependencies', () => {
var injector = createInjector(
const injector = createInjector(
[Engine, {provide: Car, useFactory: (e: Engine) => new SportsCar(e), deps: [Engine]}]);
var car = injector.get(Car);
const car = injector.get(Car);
expect(car).toBeAnInstanceOf(SportsCar);
expect(car.engine).toBeAnInstanceOf(Engine);
});
it('should support optional dependencies', () => {
var injector = createInjector([CarWithOptionalEngine]);
const injector = createInjector([CarWithOptionalEngine]);
var car = injector.get(CarWithOptionalEngine);
const car = injector.get(CarWithOptionalEngine);
expect(car.engine).toEqual(null);
});
it('should flatten passed-in providers', () => {
var injector = createInjector([[[Engine, Car]]]);
const injector = createInjector([[[Engine, Car]]]);
var car = injector.get(Car);
const car = injector.get(Car);
expect(car).toBeAnInstanceOf(Car);
});
it('should use the last provider when there are multiple providers for same token', () => {
var injector = createInjector(
const injector = createInjector(
[{provide: Engine, useClass: Engine}, {provide: Engine, useClass: TurboEngine}]);
expect(injector.get(Engine)).toBeAnInstanceOf(TurboEngine);
});
it('should use non-type tokens', () => {
var injector = createInjector([{provide: 'token', useValue: 'value'}]);
const injector = createInjector([{provide: 'token', useValue: 'value'}]);
expect(injector.get('token')).toEqual('value');
});
@ -290,26 +290,26 @@ export function main() {
});
it('should provide itself', () => {
var parent = createInjector([]);
var child = parent.resolveAndCreateChild([]);
const parent = createInjector([]);
const child = parent.resolveAndCreateChild([]);
expect(child.get(Injector)).toBe(child);
});
it('should throw when no provider defined', () => {
var injector = createInjector([]);
const injector = createInjector([]);
expect(() => injector.get('NonExisting')).toThrowError('No provider for NonExisting!');
});
it('should show the full path when no provider', () => {
var injector = createInjector([CarWithDashboard, Engine, Dashboard]);
const injector = createInjector([CarWithDashboard, Engine, Dashboard]);
expect(() => injector.get(CarWithDashboard))
.toThrowError(
`No provider for DashboardSoftware! (${stringify(CarWithDashboard)} -> ${stringify(Dashboard)} -> DashboardSoftware)`);
});
it('should throw when trying to instantiate a cyclic dependency', () => {
var injector = createInjector([Car, {provide: Engine, useClass: CyclicEngine}]);
const injector = createInjector([Car, {provide: Engine, useClass: CyclicEngine}]);
expect(() => injector.get(Car))
.toThrowError(
@ -317,10 +317,10 @@ export function main() {
});
it('should show the full path when error happens in a constructor', () => {
var providers =
const providers =
ReflectiveInjector.resolve([Car, {provide: Engine, useClass: BrokenEngine}]);
var proto = new ReflectiveProtoInjector([providers[0], providers[1]]);
var injector = new ReflectiveInjector_(proto);
const proto = new ReflectiveProtoInjector([providers[0], providers[1]]);
const injector = new ReflectiveInjector_(proto);
try {
injector.get(Car);
@ -334,9 +334,9 @@ export function main() {
});
it('should instantiate an object after a failed attempt', () => {
var isBroken = true;
let isBroken = true;
var injector = createInjector([
const injector = createInjector([
Car,
{provide: Engine, useFactory: (() => isBroken ? new BrokenEngine() : new Engine())}
]);
@ -350,7 +350,7 @@ export function main() {
});
it('should support null values', () => {
var injector = createInjector([{provide: 'null', useValue: null}]);
const injector = createInjector([{provide: 'null', useValue: null}]);
expect(injector.get('null')).toBe(null);
});
@ -359,52 +359,52 @@ export function main() {
describe('child', () => {
it('should load instances from parent injector', () => {
var parent = ReflectiveInjector.resolveAndCreate([Engine]);
var child = parent.resolveAndCreateChild([]);
const parent = ReflectiveInjector.resolveAndCreate([Engine]);
const child = parent.resolveAndCreateChild([]);
var engineFromParent = parent.get(Engine);
var engineFromChild = child.get(Engine);
const engineFromParent = parent.get(Engine);
const engineFromChild = child.get(Engine);
expect(engineFromChild).toBe(engineFromParent);
});
it('should not use the child providers when resolving the dependencies of a parent provider',
() => {
var parent = ReflectiveInjector.resolveAndCreate([Car, Engine]);
var child = parent.resolveAndCreateChild([{provide: Engine, useClass: TurboEngine}]);
const parent = ReflectiveInjector.resolveAndCreate([Car, Engine]);
const child = parent.resolveAndCreateChild([{provide: Engine, useClass: TurboEngine}]);
var carFromChild = child.get(Car);
const carFromChild = child.get(Car);
expect(carFromChild.engine).toBeAnInstanceOf(Engine);
});
it('should create new instance in a child injector', () => {
var parent = ReflectiveInjector.resolveAndCreate([Engine]);
var child = parent.resolveAndCreateChild([{provide: Engine, useClass: TurboEngine}]);
const parent = ReflectiveInjector.resolveAndCreate([Engine]);
const child = parent.resolveAndCreateChild([{provide: Engine, useClass: TurboEngine}]);
var engineFromParent = parent.get(Engine);
var engineFromChild = child.get(Engine);
const engineFromParent = parent.get(Engine);
const engineFromChild = child.get(Engine);
expect(engineFromParent).not.toBe(engineFromChild);
expect(engineFromChild).toBeAnInstanceOf(TurboEngine);
});
it('should give access to parent', () => {
var parent = ReflectiveInjector.resolveAndCreate([]);
var child = parent.resolveAndCreateChild([]);
const parent = ReflectiveInjector.resolveAndCreate([]);
const child = parent.resolveAndCreateChild([]);
expect(child.parent).toBe(parent);
});
});
describe('resolveAndInstantiate', () => {
it('should instantiate an object in the context of the injector', () => {
var inj = ReflectiveInjector.resolveAndCreate([Engine]);
var car = inj.resolveAndInstantiate(Car);
const inj = ReflectiveInjector.resolveAndCreate([Engine]);
const car = inj.resolveAndInstantiate(Car);
expect(car).toBeAnInstanceOf(Car);
expect(car.engine).toBe(inj.get(Engine));
});
it('should not store the instantiated object in the injector', () => {
var inj = ReflectiveInjector.resolveAndCreate([Engine]);
const inj = ReflectiveInjector.resolveAndCreate([Engine]);
inj.resolveAndInstantiate(Car);
expect(() => inj.get(Car)).toThrowError();
});
@ -412,8 +412,8 @@ export function main() {
describe('instantiate', () => {
it('should instantiate an object in the context of the injector', () => {
var inj = ReflectiveInjector.resolveAndCreate([Engine]);
var car = inj.instantiateResolved(ReflectiveInjector.resolve([Car])[0]);
const inj = ReflectiveInjector.resolveAndCreate([Engine]);
const car = inj.instantiateResolved(ReflectiveInjector.resolve([Car])[0]);
expect(car).toBeAnInstanceOf(Car);
expect(car.engine).toBe(inj.get(Engine));
});
@ -422,7 +422,7 @@ export function main() {
describe('depedency resolution', () => {
describe('@Self()', () => {
it('should return a dependency from self', () => {
var inj = ReflectiveInjector.resolveAndCreate([
const inj = ReflectiveInjector.resolveAndCreate([
Engine,
{provide: Car, useFactory: (e: Engine) => new Car(e), deps: [[Engine, new Self()]]}
]);
@ -431,8 +431,8 @@ export function main() {
});
it('should throw when not requested provider on self', () => {
var parent = ReflectiveInjector.resolveAndCreate([Engine]);
var child = parent.resolveAndCreateChild([
const parent = ReflectiveInjector.resolveAndCreate([Engine]);
const child = parent.resolveAndCreateChild([
{provide: Car, useFactory: (e: Engine) => new Car(e), deps: [[Engine, new Self()]]}
]);
@ -443,8 +443,8 @@ export function main() {
describe('default', () => {
it('should not skip self', () => {
var parent = ReflectiveInjector.resolveAndCreate([Engine]);
var child = parent.resolveAndCreateChild([
const parent = ReflectiveInjector.resolveAndCreate([Engine]);
const child = parent.resolveAndCreateChild([
{provide: Engine, useClass: TurboEngine},
{provide: Car, useFactory: (e: Engine) => new Car(e), deps: [Engine]}
]);
@ -456,7 +456,7 @@ export function main() {
describe('resolve', () => {
it('should resolve and flatten', () => {
var providers = ReflectiveInjector.resolve([Engine, [BrokenEngine]]);
const providers = ReflectiveInjector.resolve([Engine, [BrokenEngine]]);
providers.forEach(function(b) {
if (!b) return; // the result is a sparse array
expect(b instanceof ResolvedReflectiveProvider_).toBe(true);
@ -464,7 +464,7 @@ export function main() {
});
it('should support multi providers', () => {
var provider = ReflectiveInjector.resolve([
const provider = ReflectiveInjector.resolve([
{provide: Engine, useClass: BrokenEngine, multi: true},
{provide: Engine, useClass: TurboEngine, multi: true}
])[0];
@ -476,7 +476,7 @@ export function main() {
it('should support providers as hash', () => {
var provider = ReflectiveInjector.resolve([
const provider = ReflectiveInjector.resolve([
{provide: Engine, useClass: BrokenEngine, multi: true},
{provide: Engine, useClass: TurboEngine, multi: true}
])[0];
@ -487,7 +487,7 @@ export function main() {
});
it('should support multi providers with only one provider', () => {
var provider =
const provider =
ReflectiveInjector.resolve([{provide: Engine, useClass: BrokenEngine, multi: true}])[0];
expect(provider.key.token).toBe(Engine);
@ -508,7 +508,7 @@ export function main() {
});
it('should resolve forward references', () => {
var providers = ReflectiveInjector.resolve([
const providers = ReflectiveInjector.resolve([
forwardRef(() => Engine),
[{provide: forwardRef(() => BrokenEngine), useClass: forwardRef(() => Engine)}], {
provide: forwardRef(() => String),
@ -517,9 +517,9 @@ export function main() {
}
]);
var engineProvider = providers[0];
var brokenEngineProvider = providers[1];
var stringProvider = providers[2];
const engineProvider = providers[0];
const brokenEngineProvider = providers[1];
const stringProvider = providers[2];
expect(engineProvider.resolvedFactories[0].factory() instanceof Engine).toBe(true);
expect(brokenEngineProvider.resolvedFactories[0].factory() instanceof Engine).toBe(true);
@ -528,21 +528,21 @@ export function main() {
});
it('should support overriding factory dependencies with dependency annotations', () => {
var providers = ReflectiveInjector.resolve([{
const providers = ReflectiveInjector.resolve([{
provide: 'token',
useFactory: (e: any /** TODO #9100 */) => 'result',
deps: [[new Inject('dep')]]
}]);
var provider = providers[0];
const provider = providers[0];
expect(provider.resolvedFactories[0].dependencies[0].key.token).toEqual('dep');
});
it('should allow declaring dependencies with flat arrays', () => {
var resolved = ReflectiveInjector.resolve(
const resolved = ReflectiveInjector.resolve(
[{provide: 'token', useFactory: (e: any) => e, deps: [new Inject('dep')]}]);
var nestedResolved = ReflectiveInjector.resolve(
const nestedResolved = ReflectiveInjector.resolve(
[{provide: 'token', useFactory: (e: any) => e, deps: [[new Inject('dep')]]}]);
expect(resolved[0].resolvedFactories[0].dependencies[0].key.token)
.toEqual(nestedResolved[0].resolvedFactories[0].dependencies[0].key.token);

2
modules/@angular/core/test/di/reflective_key_spec.ts
View File

@ -10,7 +10,7 @@ import {KeyRegistry} from '@angular/core/src/di/reflective_key';
export function main() {
describe('key', function() {
var registry: KeyRegistry;
let registry: KeyRegistry;
beforeEach(function() { registry = new KeyRegistry(); });