chore(format): update to latest formatter

Closes #7958

modules/angular2/test/http/http_spec.ts

@@ -1,33 +1,7 @@
-import {
-  AsyncTestCompleter,
-  afterEach,
-  beforeEach,
-  ddescribe,
-  describe,
-  expect,
-  iit,
-  inject,
-  it,
-  xit
-} from 'angular2/testing_internal';
+import {AsyncTestCompleter, afterEach, beforeEach, ddescribe, describe, expect, iit, inject, it, xit} from 'angular2/testing_internal';
 import {Injector, provide} from 'angular2/core';
 import {MockBackend, MockConnection} from 'angular2/src/http/backends/mock_backend';
-import {
-  BaseRequestOptions,
-  ConnectionBackend,
-  Request,
-  RequestMethod,
-  RequestOptions,
-  Response,
-  ResponseOptions,
-  URLSearchParams,
-  JSONP_PROVIDERS,
-  HTTP_PROVIDERS,
-  XHRBackend,
-  JSONPBackend,
-  Http,
-  Jsonp
-} from 'angular2/http';
+import {BaseRequestOptions, ConnectionBackend, Request, RequestMethod, RequestOptions, Response, ResponseOptions, URLSearchParams, JSONP_PROVIDERS, HTTP_PROVIDERS, XHRBackend, JSONPBackend, Http, Jsonp} from 'angular2/http';
 import {Observable} from 'rxjs/Observable';
 import {Subject} from 'rxjs/Subject';
 
@@ -49,9 +23,7 @@ export function main() {
          ]);
 
          childInjector = parentInjector.resolveAndCreateChild([
-           HTTP_PROVIDERS,
-           JSONP_PROVIDERS,
-           provide(XHRBackend, {useClass: MockBackend}),
+           HTTP_PROVIDERS, JSONP_PROVIDERS, provide(XHRBackend, {useClass: MockBackend}),
            provide(JSONPBackend, {useClass: MockBackend})
          ]);
 
@@ -95,24 +67,18 @@ export function main() {
     var jsonp: Jsonp;
     beforeEach(() => {
       injector = Injector.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]
-            })
+        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]
+        })
       ]);
       http = injector.get(Http);
       jsonp = injector.get(Jsonp);
@@ -156,11 +122,10 @@ export function main() {
         it('should perform a get request for given url if only passed a string',
            inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
              backend.connections.subscribe((c: MockConnection) => c.mockRespond(baseResponse));
-             http.request('http://basic.connection')
-                 .subscribe((res: Response) => {
-                   expect(res.text()).toBe('base response');
-                   async.done();
-                 });
+             http.request('http://basic.connection').subscribe((res: Response) => {
+               expect(res.text()).toBe('base response');
+               async.done();
+             });
            }));
 
         it('should perform a post request for given url if options include a method',
@@ -170,11 +135,10 @@ export function main() {
                c.mockRespond(baseResponse);
              });
              let requestOptions = new RequestOptions({method: RequestMethod.Post});
-             http.request('http://basic.connection', requestOptions)
-                 .subscribe((res: Response) => {
-                   expect(res.text()).toBe('base response');
-                   async.done();
-                 });
+             http.request('http://basic.connection', requestOptions).subscribe((res: Response) => {
+               expect(res.text()).toBe('base response');
+               async.done();
+             });
            }));
 
         it('should perform a post request for given url if options include a method',
@@ -184,30 +148,32 @@ export function main() {
                c.mockRespond(baseResponse);
              });
              let requestOptions = {method: RequestMethod.Post};
-             http.request('http://basic.connection', requestOptions)
-                 .subscribe((res: Response) => {
-                   expect(res.text()).toBe('base response');
-                   async.done();
-                 });
+             http.request('http://basic.connection', requestOptions).subscribe((res: Response) => {
+               expect(res.text()).toBe('base response');
+               async.done();
+             });
            }));
 
         it('should perform a get request and complete the response',
            inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
              backend.connections.subscribe((c: MockConnection) => c.mockRespond(baseResponse));
              http.request('http://basic.connection')
-                 .subscribe((res: Response) => { expect(res.text()).toBe('base response'); }, null,
-                            () => { async.done(); });
+                 .subscribe(
+                     (res: Response) => { expect(res.text()).toBe('base response'); }, null,
+                     () => { async.done(); });
            }));
 
         it('should perform multiple get requests and complete the responses',
            inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
              backend.connections.subscribe((c: MockConnection) => c.mockRespond(baseResponse));
 
+             http.request('http://basic.connection').subscribe((res: Response) => {
+               expect(res.text()).toBe('base response');
+             });
              http.request('http://basic.connection')
-                 .subscribe((res: Response) => { expect(res.text()).toBe('base response'); });
-             http.request('http://basic.connection')
-                 .subscribe((res: Response) => { expect(res.text()).toBe('base response'); }, null,
-                            () => { async.done(); });
+                 .subscribe(
+                     (res: Response) => { expect(res.text()).toBe('base response'); }, null,
+                     () => { async.done(); });
            }));
 
         it('should throw if url is not a string or Request', () => {
@@ -373,9 +339,8 @@ export function main() {
         it('should allow case insensitive strings for method names', () => {
           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
             backend.connections.subscribe((c: MockConnection) => {
-              expect(c.request.method)
-                  .toBe(RequestMethod.Post)
-                      c.mockRespond(new Response(new ResponseOptions({body: 'Thank you'})));
+              expect(c.request.method).toBe(RequestMethod.Post)
+              c.mockRespond(new Response(new ResponseOptions({body: 'Thank you'})));
               async.done();
             });
             http.request(