refactor(http): remove default settings from RequestOptions constructor

The BaseRequestOptions class is responsible for declaring default values,
while the RequestOptions class is merely responsible for setting values
based on values provided in the constructor.

Author: jeffbcross

modules/angular2/core.ts

@@ -17,5 +17,6 @@ export * from './src/core/compiler/dynamic_component_loader';
 export {ViewRef, ProtoViewRef} from './src/core/compiler/view_ref';
 export {ViewContainerRef} from './src/core/compiler/view_container_ref';
 export {ElementRef} from './src/core/compiler/element_ref';
+export {EventEmitter} from './src/facade/async';
 
 export {NgZone} from './src/core/zone/ng_zone';

modules/angular2/http.ts

@@ -6,30 +6,39 @@
  * class.
  */
 import {bind, Binding} from 'angular2/di';
-import {Http} from './src/http/http';
+import {Http} from 'angular2/src/http/http';
 import {XHRBackend, XHRConnection} from 'angular2/src/http/backends/xhr_backend';
-import {BrowserXHR} from 'angular2/src/http/backends/browser_xhr';
+import {BrowserXhr} from 'angular2/src/http/backends/browser_xhr';
 import {BaseRequestOptions, RequestOptions} from 'angular2/src/http/base_request_options';
 import {ConnectionBackend} from 'angular2/src/http/interfaces';
 
 export {MockConnection, MockBackend} from 'angular2/src/http/backends/mock_backend';
 export {Request} from 'angular2/src/http/static_request';
 export {Response} from 'angular2/src/http/static_response';
+import {BaseResponseOptions, ResponseOptions} from 'angular2/src/http/base_response_options';
 
 export {
   IRequestOptions,
-  IResponse,
+  IResponseOptions,
   Connection,
   ConnectionBackend
 } from 'angular2/src/http/interfaces';
 
 export {BaseRequestOptions, RequestOptions} from 'angular2/src/http/base_request_options';
+export {BaseResponseOptions, ResponseOptions} from 'angular2/src/http/base_response_options';
 export {XHRBackend, XHRConnection} from 'angular2/src/http/backends/xhr_backend';
-export {Http} from './src/http/http';
+export {Http} from 'angular2/src/http/http';
 
 export {Headers} from 'angular2/src/http/headers';
 
-export * from 'angular2/src/http/enums';
+export {
+  ResponseTypes,
+  ReadyStates,
+  RequestMethods,
+  RequestCredentialsOpts,
+  RequestCacheOpts,
+  RequestModesOpts
+} from 'angular2/src/http/enums';
 export {URLSearchParams} from 'angular2/src/http/url_search_params';
 
 /**
@@ -49,5 +58,11 @@ export {URLSearchParams} from 'angular2/src/http/url_search_params';
  * ```
  *
  */
-export var httpInjectables: List<any> =
-    [bind(ConnectionBackend).toClass(XHRBackend), BrowserXHR, XHRBackend, BaseRequestOptions, Http];
+export var httpInjectables: List<any> = [
+  bind(ConnectionBackend)
+      .toClass(XHRBackend),
+  BrowserXhr,
+  bind(RequestOptions).toClass(BaseRequestOptions),
+  bind(ResponseOptions).toClass(BaseResponseOptions),
+  Http
+];

modules/angular2/src/http/backends/browser_xhr.dart

@@ -4,7 +4,7 @@ import 'dart:html' show HttpRequest;
 import 'package:angular2/di.dart';
 
 @Injectable()
-class BrowserXHR {
+class BrowserXhr {
 	HttpRequest build() {
 		return new HttpRequest();
 	}

modules/angular2/src/http/backends/browser_xhr.ts

@@ -1,10 +1,8 @@
-declare var window;
-
 import {Injectable} from 'angular2/di';
 
 // Make sure not to evaluate this in a non-browser environment!
 @Injectable()
-export class BrowserXHR {
+export class BrowserXhr {
   constructor() {}
-  build(): any { return <any>(new window.XMLHttpRequest()); }
+  build(): any { return <any>(new XMLHttpRequest()); }
 }

modules/angular2/src/http/backends/mock_backend.ts

@@ -9,11 +9,7 @@ import {IMPLEMENTS, BaseException} from 'angular2/src/facade/lang';
 
 /**
  *
- * Connection class used by MockBackend
- *
- * This class is typically not instantiated directly, but instances can be retrieved by subscribing
- *to the `connections` Observable of
- * {@link MockBackend} in order to mock responses to requests.
+ * Mock Connection to represent a {@link Connection} for tests.
  *
  **/
 @IMPLEMENTS(Connection)
@@ -32,9 +28,8 @@ export class MockConnection {
   request: Request;
 
   /**
-   * [RxJS
-   * Observable](https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/observable.md)
-   * of {@link Response}. Can be subscribed to in order to be notified when a response is available.
+   * {@link EventEmitter} of {@link Response}. Can be subscribed to in order to be notified when a
+   * response is available.
    */
   response: EventEmitter;
 
@@ -55,7 +50,7 @@ export class MockConnection {
 
   /**
    * Sends a mock response to the connection. This response is the value that is emitted to the
-   * `Observable` returned by {@link Http}.
+   * {@link EventEmitter} returned by {@link Http}.
    *
    * #Example
    *
@@ -91,7 +86,8 @@ export class MockConnection {
 
   // TODO(jeffbcross): consider using Response type
   /**
-   * Emits the provided error object as an error to the {@link Response} observable returned
+   * Emits the provided error object as an error to the {@link Response} {@link EventEmitter}
+   * returned
    * from {@link Http}.
    */
   mockError(err?) {
@@ -137,8 +133,7 @@ export class MockConnection {
 @IMPLEMENTS(ConnectionBackend)
 export class MockBackend {
   /**
-   * [RxJS
-   * Subject](https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/subjects/subject.md)
+   * {@link EventEmitter}
    * of {@link MockConnection} instances that have been created by this backend. Can be subscribed
    * to in order to respond to connections.
    *
@@ -162,7 +157,7 @@ export class MockBackend {
    *   http.request('something.json').subscribe(res => {
    *     text = res.text();
    *   });
-   *   connection.mockRespond(new Response('Something'));
+   *   connection.mockRespond(new Response({body: 'Something'}));
    *   expect(text).toBe('Something');
    * });
    * ```
@@ -179,8 +174,8 @@ export class MockBackend {
    */
   connectionsArray: Array<MockConnection>;
   /**
-   * [Observable](https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/observable.md)
-   * of {@link MockConnection} instances that haven't yet been resolved (i.e. with a `readyState`
+   * {@link EventEmitter} of {@link MockConnection} instances that haven't yet been resolved (i.e.
+   * with a `readyState`
    * less than 4). Used internally to verify that no connections are pending via the
    * `verifyNoPendingRequests` method.
    *
@@ -193,7 +188,6 @@ export class MockBackend {
     ObservableWrapper.subscribe(this.connections,
                                 connection => this.connectionsArray.push(connection));
     this.pendingConnections = new EventEmitter();
-    // Observable.fromArray(this.connectionsArray).filter((c) => c.readyState < ReadyStates.DONE);
   }
 
   /**
@@ -218,10 +212,10 @@ export class MockBackend {
   /**
    * Creates a new {@link MockConnection}. This is equivalent to calling `new
    * MockConnection()`, except that it also will emit the new `Connection` to the `connections`
-   * observable of this `MockBackend` instance. This method will usually only be used by tests
+   * emitter of this `MockBackend` instance. This method will usually only be used by tests
    * against the framework itself, not by end-users.
    */
-  createConnection(req: Request) {
+  createConnection(req: Request): Connection {
     if (!isPresent(req) || !(req instanceof Request)) {
       throw new BaseException(`createConnection requires an instance of Request, got ${req}`);
     }

modules/angular2/src/http/backends/xhr_backend.ts

@@ -2,8 +2,9 @@ import {ConnectionBackend, Connection} from '../interfaces';
 import {ReadyStates, RequestMethods, RequestMethodsMap} from '../enums';
 import {Request} from '../static_request';
 import {Response} from '../static_response';
+import {ResponseOptions, BaseResponseOptions} from '../base_response_options';
 import {Injectable} from 'angular2/di';
-import {BrowserXHR} from './browser_xhr';
+import {BrowserXhr} from './browser_xhr';
 import {EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
 import {isPresent, ENUM_INDEX} from 'angular2/src/facade/lang';
 
@@ -18,14 +19,14 @@ import {isPresent, ENUM_INDEX} from 'angular2/src/facade/lang';
 export class XHRConnection implements Connection {
   request: Request;
   /**
-   * Response
-   * [Subject](https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/subjects/subject.md)
-   * which emits a single {@link Response} value on load event of `XMLHttpRequest`.
+   * Response {@link EventEmitter} which emits a single {@link Response} value on load event of
+   * `XMLHttpRequest`.
    */
-  response: EventEmitter;  //<Response>;
+  response: EventEmitter;  // TODO: Make generic of <Response>;
   readyState: ReadyStates;
-  private _xhr;
-  constructor(req: Request, browserXHR: BrowserXHR) {
+  private _xhr;  // TODO: make type XMLHttpRequest, pending resolution of
+                 // https://github.com/angular/ts2dart/issues/230
+  constructor(req: Request, browserXHR: BrowserXhr, baseResponseOptions?: ResponseOptions) {
     // TODO: get rid of this when enum lookups are available in ts2dart
     // https://github.com/angular/ts2dart/issues/221
     var requestMethodsMap = new RequestMethodsMap();
@@ -34,12 +35,15 @@ export class XHRConnection implements Connection {
     this._xhr = browserXHR.build();
     // TODO(jeffbcross): implement error listening/propagation
     this._xhr.open(requestMethodsMap.getMethod(ENUM_INDEX(req.method)), req.url);
-    this._xhr.addEventListener(
-        'load',
-        (_) => {ObservableWrapper.callNext(
-            this.response, new Response({
-              body: isPresent(this._xhr.response) ? this._xhr.response : this._xhr.responseText
-            }))});
+    this._xhr.addEventListener('load', (_) => {
+      var responseOptions = new ResponseOptions(
+          {body: isPresent(this._xhr.response) ? this._xhr.response : this._xhr.responseText});
+      if (isPresent(baseResponseOptions)) {
+        responseOptions = baseResponseOptions.merge(responseOptions);
+      }
+
+      ObservableWrapper.callNext(this.response, new Response(responseOptions))
+    });
     // TODO(jeffbcross): make this more dynamic based on body type
     this._xhr.send(this.request.text());
   }
@@ -78,8 +82,8 @@ export class XHRConnection implements Connection {
  **/
 @Injectable()
 export class XHRBackend implements ConnectionBackend {
-  constructor(private _browserXHR: BrowserXHR) {}
+  constructor(private _browserXHR: BrowserXhr, private _baseResponseOptions: ResponseOptions) {}
   createConnection(request: Request): XHRConnection {
-    return new XHRConnection(request, this._browserXHR);
+    return new XHRConnection(request, this._browserXHR, this._baseResponseOptions);
   }
 }

modules/angular2/src/http/base_request_options.ts

@@ -3,23 +3,22 @@ import {Headers} from './headers';
 import {RequestModesOpts, RequestMethods, RequestCacheOpts, RequestCredentialsOpts} from './enums';
 import {IRequestOptions} from './interfaces';
 import {Injectable} from 'angular2/di';
-import {ListWrapper, StringMapWrapper, StringMap} from 'angular2/src/facade/collection';
 
-const INITIALIZER = CONST_EXPR({});
 /**
- * Creates a request options object with default properties as described in the [Fetch
+ * Creates a request options object similar to the `RequestInit` description
+ * in the [Fetch
  * Spec](https://fetch.spec.whatwg.org/#requestinit) to be optionally provided when instantiating a
- * {@link Request}. This class is used implicitly by {@link Http} to merge in provided request
- * options with the default options specified here. These same default options are injectable via
- * the {@link BaseRequestOptions} class.
+ * {@link Request}.
+ *
+ * All values are null by default.
  */
 export class RequestOptions implements IRequestOptions {
   /**
    * Http method with which to execute the request.
    *
    * Defaults to "GET".
    */
-  method: RequestMethods = RequestMethods.GET;
+  method: RequestMethods;
   /**
    * Headers object based on the `Headers` class in the [Fetch
    * Spec](https://fetch.spec.whatwg.org/#headers-class).
@@ -28,54 +27,42 @@ export class RequestOptions implements IRequestOptions {
   /**
    * Body to be used when creating the request.
    */
-  // TODO: support FormData, Blob, URLSearchParams, JSON
+  // TODO: support FormData, Blob, URLSearchParams
   body: string;
-  mode: RequestModesOpts = RequestModesOpts.Cors;
+  mode: RequestModesOpts;
   credentials: RequestCredentialsOpts;
   cache: RequestCacheOpts;
   url: string;
   constructor({method, headers, body, mode, credentials, cache, url}: IRequestOptions = {}) {
-    this.method = isPresent(method) ? method : RequestMethods.GET;
-    this.headers = headers;
-    this.body = body;
-    this.mode = isPresent(mode) ? mode : RequestModesOpts.Cors;
-    this.credentials = credentials;
-    this.cache = cache;
-    this.url = url;
+    this.method = isPresent(method) ? method : null;
+    this.headers = isPresent(headers) ? headers : null;
+    this.body = isPresent(body) ? body : null;
+    this.mode = isPresent(mode) ? mode : null;
+    this.credentials = isPresent(credentials) ? credentials : null;
+    this.cache = isPresent(cache) ? cache : null;
+    this.url = isPresent(url) ? url : null;
   }
 
   /**
    * Creates a copy of the `RequestOptions` instance, using the optional input as values to override
    * existing values.
    */
-  merge({url = null, method = null, headers = null, body = null, mode = null, credentials = null,
-         cache = null}: any = {}): RequestOptions {
+  merge(options?: IRequestOptions): RequestOptions {
     return new RequestOptions({
-      method: isPresent(method) ? method : this.method,
-      headers: isPresent(headers) ? headers : this.headers,
-      body: isPresent(body) ? body : this.body,
-      mode: isPresent(mode) ? mode : this.mode,
-      credentials: isPresent(credentials) ? credentials : this.credentials,
-      cache: isPresent(cache) ? cache : this.cache,
-      url: isPresent(url) ? url : this.url
+      method: isPresent(options) && isPresent(options.method) ? options.method : this.method,
+      headers: isPresent(options) && isPresent(options.headers) ? options.headers : this.headers,
+      body: isPresent(options) && isPresent(options.body) ? options.body : this.body,
+      mode: isPresent(options) && isPresent(options.mode) ? options.mode : this.mode,
+      credentials: isPresent(options) && isPresent(options.credentials) ? options.credentials :
+                                                                          this.credentials,
+      cache: isPresent(options) && isPresent(options.cache) ? options.cache : this.cache,
+      url: isPresent(options) && isPresent(options.url) ? options.url : this.url
     });
   }
-
-  static fromStringWrapper(map: StringMap<string, any>): RequestOptions {
-    return new RequestOptions({
-      method: StringMapWrapper.get(map, 'method'),
-      headers: StringMapWrapper.get(map, 'headers'),
-      body: StringMapWrapper.get(map, 'body'),
-      mode: StringMapWrapper.get(map, 'mode'),
-      credentials: StringMapWrapper.get(map, 'credentials'),
-      cache: StringMapWrapper.get(map, 'cache'),
-      url:<string>StringMapWrapper.get(map, 'url')
-    })
-  }
 }
 
 /**
- * Injectable version of {@link RequestOptions}.
+ * Injectable version of {@link RequestOptions}, with overridable default values.
  *
  * #Example
  *
@@ -84,8 +71,8 @@ export class RequestOptions implements IRequestOptions {
  * ...
  * class MyComponent {
  *   constructor(baseRequestOptions:BaseRequestOptions, http:Http) {
- *     var options = baseRequestOptions.merge({body: 'foobar'});
- *     var request = new Request('https://foo/', options);
+ *     var options = baseRequestOptions.merge({body: 'foobar', url: 'https://foo/'});
+ *     var request = new Request(options);
  *     http.request(request).subscribe(res => this.bars = res.json());
  *   }
  * }
@@ -94,5 +81,7 @@ export class RequestOptions implements IRequestOptions {
  */
 @Injectable()
 export class BaseRequestOptions extends RequestOptions {
-  constructor() { super(); }
+  constructor() {
+    super({method: RequestMethods.GET, headers: new Headers(), mode: RequestModesOpts.Cors});
+  }
 }