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

refactor: change provide(...) for {provide: ...}

Browse Source 
- provide() is deprecated,
- {} syntax is required by the offline compiler
This commit is contained in:
Victor Berchet
2016-06-02 17:30:40 -07:00
parent 27a47e7841
commit a6ad61d83e
128 changed files with 676 additions and 728 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
modules/@angular/http/http.ts
View File

@ -110,7 +110,7 @@ export {URLSearchParams} from './src/url_search_params';
* search: string = 'coreTeam=true';
* }
*
* bootstrap(App, [HTTP_PROVIDERS, provide(RequestOptions, {useClass: MyOptions})])
* bootstrap(App, [HTTP_PROVIDERS, {provide: RequestOptions, useClass: MyOptions}])
* .catch(err => console.error(err));
* ```
*
@ -130,7 +130,7 @@ export {URLSearchParams} from './src/url_search_params';
* var injector = Injector.resolveAndCreate([
* HTTP_PROVIDERS,
* MockBackend,
* provide(XHRBackend, {useExisting: MockBackend})
* {provide: XHRBackend, useExisting: MockBackend}
* ]);
* var http = injector.get(Http);
* var backend = injector.get(MockBackend);
@ -174,27 +174,26 @@ export {URLSearchParams} from './src/url_search_params';
*
* bootstrap(
* App,
* [HTTP_PROVIDERS, provide(XSRFStrategy,
* {useValue: new CookieXSRFStrategy('MY-XSRF-COOKIE-NAME', 'X-MY-XSRF-HEADER-NAME')})])
* [HTTP_PROVIDERS, {provide: XSRFStrategy,
* useValue: new CookieXSRFStrategy('MY-XSRF-COOKIE-NAME', 'X-MY-XSRF-HEADER-NAME')}])
* .catch(err => console.error(err));
* ```
*/
export const HTTP_PROVIDERS: any[] = [
// TODO(pascal): use factory type annotations once supported in DI
// issue: https://github.com/angular/angular/issues/3183
provide(Http,
{
useFactory: (xhrBackend: XHRBackend, requestOptions: RequestOptions) =>
new Http(xhrBackend, requestOptions),
deps: [XHRBackend, RequestOptions]
}),
{ provide: Http, useFactory: httpFactory, deps: [XHRBackend, RequestOptions]},
BrowserXhr,
provide(RequestOptions, {useClass: BaseRequestOptions}),
provide(ResponseOptions, {useClass: BaseResponseOptions}),
{provide: RequestOptions, useClass: BaseRequestOptions},
{provide: ResponseOptions, useClass: BaseResponseOptions},
XHRBackend,
provide(XSRFStrategy, {useValue: new CookieXSRFStrategy()}),
{provide: XSRFStrategy, useValue: new CookieXSRFStrategy()},
];
function httpFactory(xhrBackend: XHRBackend, requestOptions: RequestOptions): Http {
return new Http(xhrBackend, requestOptions);
}
/**
* See {@link HTTP_PROVIDERS} instead.
*
@ -267,7 +266,7 @@ export const HTTP_BINDINGS = HTTP_PROVIDERS;
* search: string = 'coreTeam=true';
* }
*
* bootstrap(App, [JSONP_PROVIDERS, provide(RequestOptions, {useClass: MyOptions})])
* bootstrap(App, [JSONP_PROVIDERS, {provide: RequestOptions, useClass: MyOptions}])
* .catch(err => console.error(err));
* ```
*
@ -285,7 +284,7 @@ export const HTTP_BINDINGS = HTTP_PROVIDERS;
* var injector = Injector.resolveAndCreate([
* JSONP_PROVIDERS,
* MockBackend,
* provide(JSONPBackend, {useExisting: MockBackend})
* {provide: JSONPBackend, useExisting: MockBackend}
* ]);
* var jsonp = injector.get(Jsonp);
* var backend = injector.get(MockBackend);
@ -312,18 +311,18 @@ export const HTTP_BINDINGS = HTTP_PROVIDERS;
export const JSONP_PROVIDERS: any[] = [
// TODO(pascal): use factory type annotations once supported in DI
// issue: https://github.com/angular/angular/issues/3183
provide(Jsonp,
{
useFactory: (jsonpBackend: JSONPBackend, requestOptions: RequestOptions) =>
new Jsonp(jsonpBackend, requestOptions),
deps: [JSONPBackend, RequestOptions]
}),
{provide: Jsonp, useFactory: jsonpFactory, deps: [JSONPBackend, RequestOptions]},
BrowserJsonp,
provide(RequestOptions, {useClass: BaseRequestOptions}),
provide(ResponseOptions, {useClass: BaseResponseOptions}),
provide(JSONPBackend, {useClass: JSONPBackend_})
{provide: RequestOptions, useClass: BaseRequestOptions},
{provide: ResponseOptions, useClass: BaseResponseOptions},
{provide: JSONPBackend, useClass: JSONPBackend_},
];
function jsonpFactory(jsonpBackend: JSONPBackend, requestOptions: RequestOptions) {
return new Jsonp(jsonpBackend, requestOptions);
}
/**
* See {@link JSONP_PROVIDERS} instead.
*

4
modules/@angular/http/src/backends/xhr_backend.ts
View File

@ -171,9 +171,9 @@ export class CookieXSRFStrategy implements XSRFStrategy {
* @Component({
* viewProviders: [
* HTTP_PROVIDERS,
* provide(Http, {useFactory: (backend, options) => {
* {provide: Http, useFactory: (backend, options) => {
* return new Http(backend, options);
* }, deps: [MyNodeBackend, BaseRequestOptions]})]
* }, deps: [MyNodeBackend, BaseRequestOptions]}]
* })
* class MyComponent {
* constructor(http:Http) {

2
modules/@angular/http/src/base_request_options.ts
View File

@ -133,7 +133,7 @@ export class RequestOptions {
* search: string = 'coreTeam=true';
* }
*
* bootstrap(App, [HTTP_PROVIDERS, provide(RequestOptions, {useClass: MyOptions})]);
* bootstrap(App, [HTTP_PROVIDERS, {provide: RequestOptions, useClass: MyOptions}]);
* ```
*
* The options could also be extended when manually creating a {@link Request}

2
modules/@angular/http/src/base_response_options.ts
View File

@ -125,7 +125,7 @@ export class ResponseOptions {
* headers:Headers = new Headers({network: 'github'});
* }
*
* bootstrap(App, [HTTP_PROVIDERS, provide(ResponseOptions, {useClass: MyOptions})]);
* bootstrap(App, [HTTP_PROVIDERS, {provide: ResponseOptions, useClass: MyOptions}]);
* ```
*
* The options could also be extended when manually creating a {@link Response}

4
modules/@angular/http/src/http.ts
View File

@ -82,11 +82,11 @@ function mergeOptions(defaultOpts: BaseRequestOptions, providedOpts: RequestOpti
* var injector = Injector.resolveAndCreate([
* BaseRequestOptions,
* MockBackend,
* provide(Http, {useFactory:
* {provide: Http, useFactory:
* function(backend, defaultOptions) {
* return new Http(backend, defaultOptions);
* },
* deps: [MockBackend, BaseRequestOptions]})
* deps: [MockBackend, BaseRequestOptions]}
* ]);
* var http = injector.get(Http);
* http.get('request-from-mock-backend.json').subscribe((res:Response) => doSomething(res));

6
modules/@angular/http/test/backends/jsonp_backend_spec.ts
View File

@ -71,9 +71,9 @@ export function main() {
beforeEach(() => {
let injector = ReflectiveInjector.resolveAndCreate([
provide(ResponseOptions, {useClass: BaseResponseOptions}),
provide(BrowserJsonp, {useClass: MockBrowserJsonp}),
provide(JSONPBackend, {useClass: JSONPBackend_})
{provide: ResponseOptions, useClass: BaseResponseOptions},
{provide: BrowserJsonp, useClass: MockBrowserJsonp},
{provide: JSONPBackend, useClass: JSONPBackend_}
]);
backend = injector.get(JSONPBackend);
let base = new BaseRequestOptions();

2
modules/@angular/http/test/backends/mock_backend_spec.ts
View File

@ -34,7 +34,7 @@ export function main() {
beforeEach(() => {
var injector = ReflectiveInjector.resolveAndCreate(
[provide(ResponseOptions, {useClass: BaseResponseOptions}), MockBackend]);
[{provide: ResponseOptions, useClass: BaseResponseOptions}, MockBackend]);
backend = injector.get(MockBackend);
var base = new BaseRequestOptions();
sampleRequest1 = new Request(base.merge(new RequestOptions({url: 'https://google.com'})));

13
modules/@angular/http/test/backends/xhr_backend_spec.ts
View File

@ -94,9 +94,11 @@ export function main() {
beforeEachProviders(
() =>
[provide(ResponseOptions, {useClass: BaseResponseOptions}),
provide(BrowserXhr, {useClass: MockBrowserXHR}), XHRBackend,
provide(XSRFStrategy, {useValue: new CookieXSRFStrategy()}),
[
{provide: ResponseOptions, useClass: BaseResponseOptions},
{provide: BrowserXhr, useClass: MockBrowserXHR},
XHRBackend,
{provide: XSRFStrategy, useValue: new CookieXSRFStrategy()},
]);
beforeEach(inject([XHRBackend], (be: XHRBackend) => {
@ -112,7 +114,7 @@ export function main() {
class NoopXsrfStrategy implements XSRFStrategy {
configureRequest(req: Request) {}
}
beforeEachProviders(() => [provide(XSRFStrategy, {useClass: NoopXsrfStrategy})]);
beforeEachProviders(() => [{provide: XSRFStrategy, useClass: NoopXsrfStrategy}]);
it('succeeds',
() => { expect(() => backend.createConnection(sampleRequest)).not.toThrow(); });
@ -135,8 +137,7 @@ export function main() {
describe('configuration', () => {
beforeEachProviders(
() => [provide(
XSRFStrategy, {useValue: new CookieXSRFStrategy('my cookie', 'X-MY-HEADER')})]);
() => [{provide: XSRFStrategy, useValue: new CookieXSRFStrategy('my cookie', 'X-MY-HEADER')}]);
it('uses the configured names', () => {
getDOM().setCookie('my cookie', 'XSRF value');

38
modules/@angular/http/test/http_spec.ts
View File

@ -44,15 +44,15 @@ export function main() {
it('should allow using jsonpInjectables and httpInjectables in same injector',
inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
parentInjector = ReflectiveInjector.resolveAndCreate([
provide(XHRBackend, {useClass: MockBackend}),
provide(JSONPBackend, {useClass: MockBackend})
{provide: XHRBackend, useClass: MockBackend},
{provide: JSONPBackend, useClass: MockBackend}
]);
childInjector = parentInjector.resolveAndCreateChild([
HTTP_PROVIDERS,
JSONP_PROVIDERS,
provide(XHRBackend, {useClass: MockBackend}),
provide(JSONPBackend, {useClass: MockBackend})
{provide: XHRBackend, useClass: MockBackend},
{provide: JSONPBackend, useClass: MockBackend}
]);
http = childInjector.get(Http);
@ -97,22 +97,20 @@ export function main() {
injector = ReflectiveInjector.resolveAndCreate([
BaseRequestOptions,
MockBackend,
provide(
Http,
{
useFactory: function(backend: ConnectionBackend, defaultOptions: BaseRequestOptions) {
return new Http(backend, defaultOptions);
},
deps: [MockBackend, BaseRequestOptions]
}),
provide(
Jsonp,
{
useFactory: function(backend: ConnectionBackend, defaultOptions: BaseRequestOptions) {
return new Jsonp(backend, defaultOptions);
},
deps: [MockBackend, BaseRequestOptions]
})
{
provide: Http,
useFactory: function(backend: ConnectionBackend, defaultOptions: BaseRequestOptions) {
return new Http(backend, defaultOptions);
},
deps: [MockBackend, BaseRequestOptions]
},
{
provide: Jsonp,
useFactory: function(backend: ConnectionBackend, defaultOptions: BaseRequestOptions) {
return new Jsonp(backend, defaultOptions);
},
deps: [MockBackend, BaseRequestOptions]
}
]);
http = injector.get(Http);
jsonp = injector.get(Jsonp);

12
modules/@angular/http/testing/mock_backend.ts
View File

@ -81,7 +81,7 @@ export class MockConnection implements Connection {
* Emits the provided error object as an error to the {@link Response} {@link EventEmitter}
* returned
* from {@link Http}.
*
*
* ### Example
*
* ```
@ -90,7 +90,7 @@ export class MockConnection implements Connection {
* http.request('data.json').subscribe(res => res, err => console.log(err)));
* connection.mockError(new Error('error'));
* ```
*
*
*/
mockError(err?: Error) {
// Matches XHR semantics
@ -114,9 +114,9 @@ export class MockConnection implements Connection {
* var connection;
* var injector = Injector.resolveAndCreate([
* MockBackend,
* provide(Http, {useFactory: (backend, options) => {
* {provide: Http, useFactory: (backend, options) => {
* return new Http(backend, options);
* }, deps: [MockBackend, BaseRequestOptions]})]);
* }, deps: [MockBackend, BaseRequestOptions]}]);
* var http = injector.get(Http);
* var backend = injector.get(MockBackend);
* //Assign any newly-created connection to local variable
@ -150,9 +150,9 @@ export class MockBackend implements ConnectionBackend {
* var text; //this will be set from mock response
* var injector = Injector.resolveAndCreate([
* MockBackend,
* provide(Http, {useFactory: (backend, options) => {
* {provide: Http, useFactory: (backend, options) => {
* return new Http(backend, options);
* }, deps: [MockBackend, BaseRequestOptions]})]);
* }, deps: [MockBackend, BaseRequestOptions]}]);
* var backend = injector.get(MockBackend);
* var http = injector.get(Http);
* backend.connections.subscribe(c => connection = c);